firetruss/dist/firetruss.es2015.js

import _ from 'lodash';
import Vue from 'vue';
import performanceNow from 'performance-now';

var vue;
var lastDigestRequest = 0, digestInProgress = false;
var bareDigest = function() {
  if (vue.digestRequest > lastDigestRequest) { return; }
  vue.digestRequest = lastDigestRequest + 1;
};

var angularProxy = {
  active: typeof window !== 'undefined' && window.angular
};

if (angularProxy.active) {
  initAngular();
} else {
  _.forEach(['digest', 'watch', 'defineModule', 'debounceDigest'], function (method) {
    angularProxy[method] = _.noop;
  });
}

function initAngular() {
  var module = window.angular.module('firetruss', []);
  angularProxy.digest = bareDigest;
  angularProxy.watch = function() {throw new Error('Angular watch proxy not yet initialized');};
  angularProxy.defineModule = function(Truss) {
    module.constant('Truss', Truss);
  };
  angularProxy.debounceDigest = function(wait) {
    if (wait) {
      var debouncedDigest = _.debounce(bareDigest, wait);
      angularProxy.digest = function() {
        if (vue.digestRequest > lastDigestRequest) { return; }
        if (digestInProgress) { bareDigest(); } else { debouncedDigest(); }
      };
    } else {
      angularProxy.digest = bareDigest;
    }
  };

  module.config(['$provide', function($provide) {
    $provide.decorator('$rootScope', ['$delegate', '$exceptionHandler',
      function($delegate, $exceptionHandler) {
        var rootScope = $delegate;
        angularProxy.watch = rootScope.$watch.bind(rootScope);
        var proto = Object.getPrototypeOf(rootScope);
        var angularDigest = proto.$digest;
        proto.$digest = bareDigest;
        proto.$digest.original = angularDigest;
        vue = new Vue({data: {digestRequest: 0}});
        vue.$watch(function () { return vue.digestRequest; }, function () {
          if (vue.digestRequest > lastDigestRequest) {
            // Make sure we execute the digest outside the Vue task queue, because otherwise if the
            // client replaced Promise with angular.$q all Truss.nextTick().then() functions will be
            // executed inside the Angular digest and hence inside the Vue task queue. But
            // Truss.nextTick() is used precisely to avoid that.  Note that it's OK to use
            // Vue.nextTick() here because even though it will schedule a flush via Promise.then()
            // it only uses the native Promise, before it could've been monkey-patched by the app.
            Vue.nextTick(function () {
              if (vue.digestRequest <= lastDigestRequest) { return; }
              digestInProgress = true;
              rootScope.$digest.original.call(rootScope);
              lastDigestRequest = vue.digestRequest = vue.digestRequest + 1;
            });
          } else {
            digestInProgress = false;
          }
        });
        _.last(vue._watchers).id = Infinity;  // make sure watcher is scheduled last
        patchRenderWatcherGet(Object.getPrototypeOf(_.last(vue._watchers)));
        return rootScope;
      }
    ]);
  }]);
}

// This is a kludge that catches errors that get through render watchers and end up killing the
// entire Vue event loop (e.g., errors raised in transition callbacks).  The state of the DOM may
// not be consistent after such an error is caught, but the global error handler should stop the
// world anyway.  May be related to https://github.com/vuejs/vue/issues/7653.
function patchRenderWatcherGet(prototype) {
  var originalGet = prototype.get;
  prototype.get = function get() {
    try {
      return originalGet.call(this);
    } catch (e) {
      if (this.vm._watcher === this && Vue.config.errorHandler) {
        Vue.config.errorHandler(e, this.vm, 'uncaught render error');
      } else {
        throw e;
      }
    }
  };
}

var LruCacheItem = function LruCacheItem(key, value) {
  this.key = key;
  this.value = value;
  this.touch();
};

LruCacheItem.prototype.touch = function touch () {
  this.timestamp = Date.now();
};


var LruCache = function LruCache(maxSize, pruningSize) {
  this._items = Object.create(null);
  this._size = 0;
  this._maxSize = maxSize;
  this._pruningSize = pruningSize || Math.ceil(maxSize * 0.10);
};

LruCache.prototype.has = function has (key) {
  return Boolean(this._items[key]);
};

LruCache.prototype.get = function get (key) {
  var item = this._items[key];
  if (!item) { return; }
  item.touch();
  return item.value;
};

LruCache.prototype.set = function set (key, value) {
  var item = this._items[key];
  if (item) {
    item.value = value;
  } else {
    if (this._size >= this._maxSize) { this._prune(); }
    this._items[key] = new LruCacheItem(key, value);
    this._size += 1;
  }
};

LruCache.prototype.delete = function delete$1 (key) {
  var item = this._items[key];
  if (!item) { return; }
  delete this._items[key];
  this._size -= 1;
};

LruCache.prototype._prune = function _prune () {
  var itemsToPrune =
    _(this._items).toArray().sortBy('timestamp').take(this._pruningSize).value();
  for (var i = 0, list = itemsToPrune; i < list.length; i += 1) {
      var item = list[i];

      this.delete(item.key);
    }
};

var pathSegments = new LruCache(1000);
var pathMatchers = {};
var maxNumPathMatchers = 1000;


function escapeKey(key) {
  if (!key) { return key; }
  // eslint-disable-next-line no-control-regex
  return key.toString().replace(/[\x00-\x1f\\.$#[\]\x7f/]/g, function(char) {
    return '\\' + _.padStart(char.charCodeAt(0).toString(16), 2, '0');
  });
}

function unescapeKey(key) {
  if (!key) { return key; }
  return key.toString().replace(/\\[0-9a-f]{2}/gi, function(code) {
    return String.fromCharCode(parseInt(code.slice(1), 16));
  });
}

function escapeKeys(object) {
  // isExtensible check avoids trying to escape references to Firetruss internals.
  if (!(_.isObject(object) && Object.isExtensible(object))) { return object; }
  var result = object;
  for (var key in object) {
    if (!object.hasOwnProperty(key)) { continue; }
    var value = object[key];
    var escapedKey = escapeKey(key);
    var escapedValue = escapeKeys(value);
    if (escapedKey !== key || escapedValue !== value) {
      if (result === object) { result = _.clone(object); }
      result[escapedKey] = escapedValue;
      if (result[key] === value) { delete result[key]; }
    }
  }
  return result;
}

function joinPath() {
  var segments = [];
  for (var i = 0, list = arguments; i < list.length; i += 1) {
    var segment = list[i];

    if (!_.isString(segment)) { segment = '' + segment; }
    if (segment.charAt(0) === '/') { segments.splice(0, segments.length); }
    segments.push(segment);
  }
  if (segments[0] === '/') { segments[0] = ''; }
  return segments.join('/');
}

function splitPath(path, leaveSegmentsEscaped) {
  var key = (leaveSegmentsEscaped ? 'esc:' : '') + path;
  var segments = pathSegments.get(key);
  if (!segments) {
    segments = path.split('/');
    if (!leaveSegmentsEscaped) { segments = _.map(segments, unescapeKey); }
    pathSegments.set(key, segments);
  }
  return segments;
}


var PathMatcher = function PathMatcher(pattern) {
  var this$1 = this;

  this.variables = [];
  var prefixMatch = _.endsWith(pattern, '/$*');
  if (prefixMatch) { pattern = pattern.slice(0, -3); }
  var pathTemplate = pattern.replace(/\/\$[^/]*/g, function (match) {
    if (match.length > 1) { this$1.variables.push(match.slice(1)); }
    return '\u0001';
  });
  Object.freeze(this.variables);
  if (/[.$#[\]]|\\(?![0-9a-f][0-9a-f])/i.test(pathTemplate)) {
    throw new Error('Path pattern has unescaped keys: ' + pattern);
  }
  this._regex = new RegExp(
    // eslint-disable-next-line no-control-regex
    '^' + pathTemplate.replace(/\u0001/g, '/([^/]+)') + (prefixMatch ? '($|/)' : '$'));
};

PathMatcher.prototype.match = function match (path) {
  this._regex.lastIndex = 0;
  var match = this._regex.exec(path);
  if (!match) { return; }
  var bindings = {};
  for (var i = 0; i < this.variables.length; i++) {
    bindings[this.variables[i]] = unescapeKey(match[i + 1]);
  }
  return bindings;
};

PathMatcher.prototype.test = function test (path) {
  return this._regex.test(path);
};

PathMatcher.prototype.toString = function toString () {
  return this._regex.toString();
};

function makePathMatcher(pattern) {
  var matcher = pathMatchers[pattern];
  if (!matcher) {
    matcher = new PathMatcher(pattern);
    // Minimal pseudo-LRU behavior, since we don't expect to actually fill up the cache.
    if (_.size(pathMatchers) === maxNumPathMatchers) { delete pathMatchers[_.keys(pathMatchers)[0]]; }
    pathMatchers[pattern] = matcher;
  }
  return matcher;
}

var MIN_WORKER_VERSION = '2.2.0';


var Snapshot = function Snapshot(ref) {
  var path = ref.path;
  var value = ref.value;
  var exists = ref.exists;
  var writeSerial = ref.writeSerial;

  this._path = path;
  this._value = value;
  this._exists = value === undefined ? exists || false : value !== null;
  this._writeSerial = writeSerial;
};

var prototypeAccessors = { path: { configurable: true },exists: { configurable: true },value: { configurable: true },key: { configurable: true },writeSerial: { configurable: true } };

prototypeAccessors.path.get = function () {
  return this._path;
};

prototypeAccessors.exists.get = function () {
  return this._exists;
};

prototypeAccessors.value.get = function () {
  if (this._value === undefined) { throw new Error('Value omitted from snapshot'); }
  return this._value;
};

prototypeAccessors.key.get = function () {
  if (this._key === undefined) { this._key = unescapeKey(this._path.replace(/.*\//, '')); }
  return this._key;
};

prototypeAccessors.writeSerial.get = function () {
  return this._writeSerial;
};

Object.defineProperties( Snapshot.prototype, prototypeAccessors );


var Bridge = function Bridge(webWorker) {
  var this$1 = this;

  this._idCounter = 0;
  this._deferreds = {};
  this._suspended = false;
  this._servers = {};
  this._callbacks = {};
  this._log = _.noop;
  this._inboundMessages = [];
  this._outboundMessages = [];
  this._flushMessageQueue = this._flushMessageQueue.bind(this);
  this._port = webWorker.port || webWorker;
  this._shared = !!webWorker.port;
  Object.seal(this);
  this._port.onmessage = this._receive.bind(this);
  window.addEventListener('unload', function () {this$1._send({msg: 'destroy'});});
};

Bridge.prototype.init = function init (webWorker, config) {
  var items = [];
  try {
    var storage = window.localStorage || window.sessionStorage;
    if (!storage) { throw new Error('localStorage and sessionStorage not available'); }
    for (var i = 0; i < storage.length; i++) {
      var key = storage.key(i);
      items.push({key: key, value: storage.getItem(key)});
    }
  } catch (e) {
    // Some browsers don't like us accessing local storage -- nothing we can do.
  }
  return this._send({msg: 'init', storage: items, config: config}).then(function (response) {
    var workerVersion = response.version.match(/^(\d+)\.(\d+)\.(\d+)(-.*)?$/);
    if (workerVersion) {
      var minVersion = MIN_WORKER_VERSION.match(/^(\d+)\.(\d+)\.(\d+)(-.*)?$/);
      // Major version must match precisely, minor and patch must be greater than or equal.
      var sufficient = workerVersion[1] === minVersion[1] && (
        workerVersion[2] > minVersion[2] ||
        workerVersion[2] === minVersion[2] && workerVersion[3] >= minVersion[3]
      );
      if (!sufficient) {
        return Promise.reject(new Error(
          "Incompatible Firetruss worker version: " + (response.version) + " " +
          "(" + MIN_WORKER_VERSION + " or better required)"
        ));
      }
    }
    return response;
  });
};

Bridge.prototype.suspend = function suspend (suspended) {
  if (suspended === undefined) { suspended = true; }
  if (this._suspended === suspended) { return; }
  this._suspended = suspended;
  if (!suspended) {
    this._receiveMessages(this._inboundMessages);
    this._inboundMessages = [];
    if (this._outboundMessages.length) { Promise.resolve().then(this._flushMessageQueue); }
  }
};

Bridge.prototype.enableLogging = function enableLogging (fn) {
  if (fn) {
    if (fn === true) { fn = console.log.bind(console); }
    this._log = fn;
  } else {
    this._log = _.noop;
  }
};

Bridge.prototype._send = function _send (message) {
    var this$1 = this;

  message.id = ++this._idCounter;
  var promise;
  if (message.oneWay) {
    promise = Promise.resolve();
  } else {
    promise = new Promise(function (resolve, reject) {
      this$1._deferreds[message.id] = {resolve: resolve, reject: reject};
    });
    var deferred = this._deferreds[message.id];
    deferred.promise = promise;
    promise.sent = new Promise(function (resolve) {
      deferred.resolveSent = resolve;
    });
    deferred.params = message;
  }
  if (!this._outboundMessages.length && !this._suspended) {
    Promise.resolve().then(this._flushMessageQueue);
  }
  this._log('send:', message);
  this._outboundMessages.push(message);
  return promise;
};

Bridge.prototype._flushMessageQueue = function _flushMessageQueue () {
  try {
    this._port.postMessage(this._outboundMessages);
    this._outboundMessages = [];
  } catch (e) {
    e.extra = {messages: this._outboundMessages};
    throw e;
  }
};

Bridge.prototype._receive = function _receive (event) {
  if (this._suspended) {
    this._inboundMessages = this._inboundMessages.concat(event.data);
  } else {
    this._receiveMessages(event.data);
  }
};

Bridge.prototype._receiveMessages = function _receiveMessages (messages) {
  for (var i = 0, list = messages; i < list.length; i += 1) {
    var message = list[i];

      this._log('recv:', message);
    var fn = this[message.msg];
    if (!_.isFunction(fn)) { throw new Error('Unknown message: ' + message.msg); }
    fn.call(this, message);
  }
};

Bridge.prototype.bindExposedFunction = function bindExposedFunction (name) {
  return (function() {
    return this._send({msg: 'call', name: name, args: Array.prototype.slice.call(arguments)});
  }).bind(this);
};

Bridge.prototype.resolve = function resolve (message) {
  var deferred = this._deferreds[message.id];
  if (!deferred) { throw new Error('Received resolution to inexistent Firebase call'); }
  delete this._deferreds[message.id];
  deferred.resolve(message.result);
};

Bridge.prototype.reject = function reject (message) {
  var deferred = this._deferreds[message.id];
  if (!deferred) { throw new Error('Received rejection of inexistent Firebase call'); }
  delete this._deferreds[message.id];
  deferred.reject(errorFromJson(message.error, deferred.params));
};

Bridge.prototype.updateLocalStorage = function updateLocalStorage (ref) {
    var items = ref.items;

  try {
    var storage = window.localStorage || window.sessionStorage;
    for (var i = 0, list = items; i < list.length; i += 1) {
      var item = list[i];

        if (item.value === null) {
        storage.removeItem(item.key);
      } else {
        storage.setItem(item.key, item.value);
      }
    }
  } catch (e) {
    // If we're denied access, there's nothing we can do.
  }
};

Bridge.prototype.trackServer = function trackServer (rootUrl) {
  if (this._servers.hasOwnProperty(rootUrl)) { return Promise.resolve(); }
  var server = this._servers[rootUrl] = {authListeners: []};
  var authCallbackId = this._registerCallback(this._authCallback.bind(this, server));
  this._send({msg: 'onAuth', url: rootUrl, callbackId: authCallbackId});
};

Bridge.prototype._authCallback = function _authCallback (server, auth) {
  server.auth = auth;
  for (var i = 0, list = server.authListeners; i < list.length; i += 1) {
      var listener = list[i];

      listener(auth);
    }
};

Bridge.prototype.onAuth = function onAuth (rootUrl, callback, context) {
  var listener = callback.bind(context);
  listener.callback = callback;
  listener.context = context;
  this._servers[rootUrl].authListeners.push(listener);
  listener(this.getAuth(rootUrl));
};

Bridge.prototype.offAuth = function offAuth (rootUrl, callback, context) {
  var authListeners = this._servers[rootUrl].authListeners;
  for (var i = 0; i < authListeners.length; i++) {
    var listener = authListeners[i];
    if (listener.callback === callback && listener.context === context) {
      authListeners.splice(i, 1);
      break;
    }
  }
};

Bridge.prototype.getAuth = function getAuth (rootUrl) {
  return this._servers[rootUrl].auth;
};

Bridge.prototype.authWithCustomToken = function authWithCustomToken (url, authToken) {
  return this._send({msg: 'authWithCustomToken', url: url, authToken: authToken});
};

Bridge.prototype.authAnonymously = function authAnonymously (url) {
  return this._send({msg: 'authAnonymously', url: url});
};

Bridge.prototype.unauth = function unauth (url) {
  return this._send({msg: 'unauth', url: url});
};

Bridge.prototype.set = function set (url, value, writeSerial) {return this._send({msg: 'set', url: url, value: value, writeSerial: writeSerial});};
Bridge.prototype.update = function update (url, value, writeSerial) {return this._send({msg: 'update', url: url, value: value, writeSerial: writeSerial});};

Bridge.prototype.once = function once (url, writeSerial) {
  return this._send({msg: 'once', url: url, writeSerial: writeSerial}).then(function (snapshot) { return new Snapshot(snapshot); });
};

Bridge.prototype.on = function on (listenerKey, url, spec, eventType, snapshotCallback, cancelCallback, context, options) {
  var handle = {
    listenerKey: listenerKey, eventType: eventType, snapshotCallback: snapshotCallback, cancelCallback: cancelCallback, context: context,
    params: {msg: 'on', listenerKey: listenerKey, url: url, spec: spec, eventType: eventType, options: options}
  };
  var callback = this._onCallback.bind(this, handle);
  this._registerCallback(callback, handle);
  // Keep multiple IDs to allow the same snapshotCallback to be reused.
  snapshotCallback.__callbackIds = snapshotCallback.__callbackIds || [];
  snapshotCallback.__callbackIds.push(handle.id);
  this._send({
    msg: 'on', listenerKey: listenerKey, url: url, spec: spec, eventType: eventType, callbackId: handle.id, options: options
  }).catch(function (error) {
    callback(error);
  });
};

Bridge.prototype.off = function off (listenerKey, url, spec, eventType, snapshotCallback, context) {
    var this$1 = this;

  var idsToDeregister = [];
  var callbackId;
  if (snapshotCallback) {
    callbackId = this._findAndRemoveCallbackId(
      snapshotCallback, function (handle) { return _.isMatch(handle, {listenerKey: listenerKey, eventType: eventType, context: context}); }
    );
    if (!callbackId) { return Promise.resolve(); }// no-op, never registered or already deregistered
    idsToDeregister.push(callbackId);
  } else {
    for (var i = 0, list = _.keys(this._callbacks); i < list.length; i += 1) {
      var id = list[i];

        var handle = this._callbacks[id];
      if (handle.listenerKey === listenerKey && (!eventType || handle.eventType === eventType)) {
        idsToDeregister.push(id);
      }
    }
  }
  // Nullify callbacks first, then deregister after off() is complete.We don't want any
  // callbacks in flight from the worker to be invoked while the off() is processing, but we don't
  // want them to throw an exception either.
  for (var i$1 = 0, list$1 = idsToDeregister; i$1 < list$1.length; i$1 += 1) {
      var id$1 = list$1[i$1];

      this._nullifyCallback(id$1);
    }
  return this._send({msg: 'off', listenerKey: listenerKey, url: url, spec: spec, eventType: eventType, callbackId: callbackId}).then(function () {
    for (var i = 0, list = idsToDeregister; i < list.length; i += 1) {
        var id = list[i];

        this$1._deregisterCallback(id);
      }
  });
};

Bridge.prototype._onCallback = function _onCallback (handle, error, snapshotJson) {
  if (error) {
    this._deregisterCallback(handle.id);
    var e = errorFromJson(error, handle.params);
    if (handle.cancelCallback) {
      handle.cancelCallback.call(handle.context, e);
    } else {
      console.error(e);
    }
  } else {
    handle.snapshotCallback.call(handle.context, new Snapshot(snapshotJson));
  }
};

Bridge.prototype.transaction = function transaction (url, oldValue, relativeUpdates, writeSerial) {
  return this._send(
    {msg: 'transaction', url: url, oldValue: oldValue, relativeUpdates: relativeUpdates, writeSerial: writeSerial}
  ).then(function (result) {
    if (result.snapshots) {
      result.snapshots = _.map(result.snapshots, function (jsonSnapshot) { return new Snapshot(jsonSnapshot); });
    }
    return result;
  });
};

Bridge.prototype.onDisconnect = function onDisconnect (url, method, value) {
  return this._send({msg: 'onDisconnect', url: url, method: method, value: value});
};

Bridge.prototype.bounceConnection = function bounceConnection () {
  return this._send({msg: 'bounceConnection'});
};

Bridge.prototype.callback = function callback (ref) {
    var id = ref.id;
    var args = ref.args;

  var handle = this._callbacks[id];
  if (!handle) { throw new Error('Unregistered callback: ' + id); }
  handle.callback.apply(null, args);
};

Bridge.prototype._registerCallback = function _registerCallback (callback, handle) {
  handle = handle || {};
  handle.callback = callback;
  handle.id = "cb" + (++this._idCounter);
  this._callbacks[handle.id] = handle;
  return handle.id;
};

Bridge.prototype._nullifyCallback = function _nullifyCallback (id) {
  this._callbacks[id].callback = _.noop;
};

Bridge.prototype._deregisterCallback = function _deregisterCallback (id) {
  delete this._callbacks[id];
};

Bridge.prototype._findAndRemoveCallbackId = function _findAndRemoveCallbackId (callback, predicate) {
  if (!callback.__callbackIds) { return; }
  var i = 0;
  while (i < callback.__callbackIds.length) {
    var id = callback.__callbackIds[i];
    var handle = this._callbacks[id];
    if (!handle) {
      callback.__callbackIds.splice(i, 1);
      continue;
    }
    if (predicate(handle)) {
      callback.__callbackIds.splice(i, 1);
      return id;
    }
    i += 1;
  }
};


function errorFromJson(json, params) {
  if (!json || _.isError(json)) { return json; }
  var error = new Error(json.message);
  error.params = params;
  for (var propertyName in json) {
    if (propertyName === 'message' || !json.hasOwnProperty(propertyName)) { continue; }
    try {
      error[propertyName] = json[propertyName];
    } catch (e) {
      error.extra = error.extra || {};
      error.extra[propertyName] = json[propertyName];
    }
  }
  return error;
}

/* eslint-disable no-use-before-define */

var EMPTY_ANNOTATIONS = {};
Object.freeze(EMPTY_ANNOTATIONS);


var Handle = function Handle(tree, path, annotations) {
  this._tree = tree;
  this._path = path.replace(/^\/*/, '/').replace(/\/$/, '') || '/';
  if (annotations) {
    this._annotations = annotations;
    Object.freeze(annotations);
  }
};

var prototypeAccessors$1 = { $ref: { configurable: true },key: { configurable: true },path: { configurable: true },_pathPrefix: { configurable: true },parent: { configurable: true },annotations: { configurable: true } };

prototypeAccessors$1.$ref.get = function () {return this;};
prototypeAccessors$1.key.get = function () {
  if (!this._key) { this._key = unescapeKey(this._path.replace(/.*\//, '')); }
  return this._key;
};
prototypeAccessors$1.path.get = function () {return this._path;};
prototypeAccessors$1._pathPrefix.get = function () {return this._path === '/' ? '' : this._path;};
prototypeAccessors$1.parent.get = function () {
  return new Reference(this._tree, this._path.replace(/\/[^/]*$/, ''), this._annotations);
};

prototypeAccessors$1.annotations.get = function () {
  return this._annotations || EMPTY_ANNOTATIONS;
};

Handle.prototype.child = function child () {
  if (!arguments.length) { return this; }
  var segments = [];
  for (var i = 0, list = arguments; i < list.length; i += 1) {
    var key = list[i];

      if (_.isNil(key)) { return; }
    segments.push(escapeKey(key));
  }
  return new Reference(
    this._tree, ((this._pathPrefix) + "/" + (segments.join('/'))),
    this._annotations
  );
};

Handle.prototype.children = function children () {
    var arguments$1 = arguments;

  if (!arguments.length) { return this; }
  var escapedKeys = [];
  for (var i = 0; i < arguments.length; i++) {
    var arg = arguments$1[i];
    if (_.isArray(arg)) {
      var mapping = {};
      var subPath = this._pathPrefix + (escapedKeys.length ? ("/" + (escapedKeys.join('/'))) : '');
      var rest = _.slice(arguments$1, i + 1);
      for (var i$1 = 0, list = arg; i$1 < list.length; i$1 += 1) {
        var key = list[i$1];

          var subRef =
          new Reference(this._tree, (subPath + "/" + (escapeKey(key))), this._annotations);
        var subMapping = subRef.children.apply(subRef, rest);
        if (subMapping) { mapping[key] = subMapping; }
      }
      return mapping;
    }
    if (_.isNil(arg)) { return; }
    escapedKeys.push(escapeKey(arg));
  }
  return new Reference(
    this._tree, ((this._pathPrefix) + "/" + (escapedKeys.join('/'))), this._annotations);
};

Handle.prototype.peek = function peek (callback) {
  return this._tree.truss.peek(this, callback);
};

Handle.prototype.match = function match (pattern) {
  return makePathMatcher(pattern).match(this.path);
};

Handle.prototype.test = function test (pattern) {
  return makePathMatcher(pattern).test(this.path);
};

Handle.prototype.isEqual = function isEqual (that) {
  if (!(that instanceof Handle)) { return false; }
  return this._tree === that._tree && this.toString() === that.toString() &&
    _.isEqual(this._annotations, that._annotations);
};

Handle.prototype.belongsTo = function belongsTo (truss) {
  return this._tree.truss === truss;
};

Object.defineProperties( Handle.prototype, prototypeAccessors$1 );


var Query = /*@__PURE__*/(function (Handle) {
  function Query(tree, path, spec, annotations) {
    Handle.call(this, tree, path, annotations);
    this._spec = this._copyAndValidateSpec(spec);
    var queryTerms = _(this._spec)
      .map(function (value, key) { return (key + "=" + (encodeURIComponent(JSON.stringify(value)))); })
      .sortBy()
      .join('&');
    this._string = (this._path) + "?" + queryTerms;
    Object.freeze(this);
  }

  if ( Handle ) Query.__proto__ = Handle;
  Query.prototype = Object.create( Handle && Handle.prototype );
  Query.prototype.constructor = Query;

  var prototypeAccessors$1 = { ready: { configurable: true },constraints: { configurable: true } };

  // Vue-bound
  prototypeAccessors$1.ready.get = function () {
    return this._tree.isQueryReady(this);
  };

  prototypeAccessors$1.constraints.get = function () {
    return this._spec;
  };

  Query.prototype.annotate = function annotate (annotations) {
    return new Query(
      this._tree, this._path, this._spec, _.assign({}, this._annotations, annotations));
  };

  Query.prototype._copyAndValidateSpec = function _copyAndValidateSpec (spec) {
    if (!spec.by) { throw new Error('Query needs "by" clause: ' + JSON.stringify(spec)); }
    if (('at' in spec) + ('from' in spec) + ('to' in spec) > 1) {
      throw new Error(
        'Query must contain at most one of "at", "from", or "to" clauses: ' + JSON.stringify(spec));
    }
    if (('first' in spec) + ('last' in spec) > 1) {
      throw new Error(
        'Query must contain at most one of "first" or "last" clauses: ' + JSON.stringify(spec));
    }
    if (!_.some(['at', 'from', 'to', 'first', 'last'], function (clause) { return clause in spec; })) {
      throw new Error(
        'Query must contain at least one of "at", "from", "to", "first", or "last" clauses: ' +
        JSON.stringify(spec));
    }
    spec = _.clone(spec);
    if (spec.by !== '$key' && spec.by !== '$value') {
      if (!(spec.by instanceof Reference)) {
        throw new Error('Query "by" value must be a reference: ' + spec.by);
      }
      var childPath = spec.by.toString();
      if (!_.startsWith(childPath, this._path)) {
        throw new Error(
          'Query "by" value must be a descendant of target reference: ' + spec.by);
      }
      childPath = childPath.slice(this._path.length).replace(/^\/?/, '');
      if (!_.includes(childPath, '/')) {
        throw new Error(
          'Query "by" value must not be a direct child of target reference: ' + spec.by);
      }
      spec.by = childPath.replace(/.*?\//, '');
    }
    Object.freeze(spec);
    return spec;
  };


  Query.prototype.toString = function toString () {
    return this._string;
  };

  Object.defineProperties( Query.prototype, prototypeAccessors$1 );

  return Query;
}(Handle));


var Reference = /*@__PURE__*/(function (Handle) {
  function Reference(tree, path, annotations) {
    Handle.call(this, tree, path, annotations);
    Object.freeze(this);
  }

  if ( Handle ) Reference.__proto__ = Handle;
  Reference.prototype = Object.create( Handle && Handle.prototype );
  Reference.prototype.constructor = Reference;

  var prototypeAccessors$2 = { ready: { configurable: true },value: { configurable: true } };

  prototypeAccessors$2.ready.get = function () {return this._tree.isReferenceReady(this);};  // Vue-bound
  prototypeAccessors$2.value.get = function () {return this._tree.getObject(this.path);};  // Vue-bound
  Reference.prototype.toString = function toString () {return this._path;};

  Reference.prototype.annotate = function annotate (annotations) {
    return new Reference(this._tree, this._path, _.assign({}, this._annotations, annotations));
  };

  Reference.prototype.query = function query (spec) {
    return new Query(this._tree, this._path, spec, this._annotations);
  };

  Reference.prototype.set = function set (value) {
    var obj;

    this._checkForUndefinedPath();
    return this._tree.update(this, 'set', ( obj = {}, obj[this.path] = value, obj ));
  };

  Reference.prototype.update = function update (values) {
    this._checkForUndefinedPath();
    return this._tree.update(this, 'update', values);
  };

  Reference.prototype.override = function override (value) {
    var obj;

    this._checkForUndefinedPath();
    return this._tree.update(this, 'override', ( obj = {}, obj[this.path] = value, obj ));
  };

  Reference.prototype.commit = function commit (updateFunction) {
    this._checkForUndefinedPath();
    return this._tree.commit(this, updateFunction);
  };

  Reference.prototype._checkForUndefinedPath = function _checkForUndefinedPath () {
    if (this.path === '/undefined') { throw new Error('Invalid path for operation: ' + this.path); }
  };

  Object.defineProperties( Reference.prototype, prototypeAccessors$2 );

  return Reference;
}(Handle));

var SERVER_TIMESTAMP = Object.freeze({'.sv': 'timestamp'});

function isTrussEqual(a, b) {
  return _.isEqualWith(a, b, isTrussValueEqual);
}

function isTrussValueEqual(a, b) {
  if (a === b || a === undefined || a === null || b === undefined || b === null ||
      a.$truss || b.$truss) { return a === b; }
  if (a.isEqual) { return a.isEqual(b); }
}

function copyPrototype(a, b) {
  for (var i = 0, list = Object.getOwnPropertyNames(a.prototype); i < list.length; i += 1) {
    var prop = list[i];

    if (prop === 'constructor') { continue; }
    Object.defineProperty(b.prototype, prop, Object.getOwnPropertyDescriptor(a.prototype, prop));
  }
}

var StatItem = function StatItem(name) {
  _.assign(this, {name: name, numRecomputes: 0, numUpdates: 0, runtime: 0});
};

var prototypeAccessors$2 = { runtimePerRecompute: { configurable: true } };

StatItem.prototype.add = function add (item) {
  this.runtime += item.runtime;
  this.numUpdates += item.numUpdates;
  this.numRecomputes += item.numRecomputes;
};

prototypeAccessors$2.runtimePerRecompute.get = function () {
  return this.numRecomputes ? this.runtime / this.numRecomputes : 0;
};

StatItem.prototype.toLogParts = function toLogParts (totals) {
  return [
    ((this.name) + ":"), (" " + ((this.runtime / 1000).toFixed(2)) + "s"),
    ("(" + ((this.runtime / totals.runtime * 100).toFixed(1)) + "%)"),
    (" " + (this.numUpdates) + " upd /"), ((this.numRecomputes) + " runs"),
    ("(" + ((this.numUpdates / this.numRecomputes * 100).toFixed(1)) + "%)"),
    (" " + (this.runtimePerRecompute.toFixed(2)) + "ms / run")
  ];
};

Object.defineProperties( StatItem.prototype, prototypeAccessors$2 );

var Stats = function Stats() {
  this._items = {};
};

var prototypeAccessors$1$1 = { list: { configurable: true } };

Stats.prototype.for = function for$1 (name) {
  if (!this._items[name]) { this._items[name] = new StatItem(name); }
  return this._items[name];
};

prototypeAccessors$1$1.list.get = function () {
  return _(this._items).values().sortBy(function (item) { return -item.runtime; }).value();
};

Stats.prototype.log = function log (n) {
    if ( n === void 0 ) n = 10;

  var stats = this.list;
  if (!stats.length) { return; }
  var totals = new StatItem('=== Total');
  _.forEach(stats, function (stat) {totals.add(stat);});
  stats = _.take(stats, n);
  var above = new StatItem('--- Above');
  _.forEach(stats, function (stat) {above.add(stat);});
  var lines = _.map(stats, function (item) { return item.toLogParts(totals); });
  lines.push(above.toLogParts(totals));
  lines.push(totals.toLogParts(totals));
  var widths = _.map(_.range(lines[0].length), function (i) { return _(lines).map(function (line) { return line[i].length; }).max(); });
  _.forEach(lines, function (line) {
    console.log(_.map(line, function (column, i) { return _.padStart(column, widths[i]); }).join(' '));
  });
};

Stats.prototype.wrap = function wrap (getter, className, propName) {
  var item = this.for((className + "." + propName));
  return function() {
    /* eslint-disable no-invalid-this */
    var startTime = performanceNow();
    var oldValue = this._computedWatchers && this._computedWatchers[propName].value;
    try {
      var newValue = getter.call(this);
      if (!isTrussEqual(oldValue, newValue)) { item.numUpdates += 1; }
      return newValue;
    } finally {
      item.runtime += performanceNow() - startTime;
      item.numRecomputes += 1;
    }
  };
};

Object.defineProperties( Stats.prototype, prototypeAccessors$1$1 );

var stats = new Stats();

var Connector = function Connector(scope, connections, tree, method, refs) {
  var this$1 = this;

  Object.freeze(connections);
  this._scope = scope;
  this._connections = connections;
  this._tree = tree;
  this._method = method;

  this._subConnectors = {};
  this._disconnects = {};
  this._angularUnwatches = undefined;
  this._data = {};
  this._vue = new Vue({data: {
    descriptors: {},
    refs: refs || {},
    values: _.mapValues(connections, _.constant(undefined))
  }});
  // allow instance-level overrides of destroy() method
  this.destroy = this.destroy;// eslint-disable-line no-self-assign
  Object.seal(this);

  this._linkScopeProperties();

  _.forEach(connections, function (descriptor, key) {
    if (_.isFunction(descriptor)) {
      this$1._bindComputedConnection(key, descriptor);
    } else {
      this$1._connect(key, descriptor);
    }
  });

  if (angularProxy.active && scope && scope.$on && scope.$id) {
    scope.$on('$destroy', function () {this$1.destroy();});
  }
};

var prototypeAccessors$3 = { ready: { configurable: true },at: { configurable: true },data: { configurable: true } };

prototypeAccessors$3.ready.get = function () {
    var this$1 = this;

  return _.every(this._connections, function (ignored, key) {
    var descriptor = this$1._vue.descriptors[key];
    if (!descriptor) { return false; }
    if (descriptor instanceof Handle) { return descriptor.ready; }
    return this$1._subConnectors[key].ready;
  });
};

prototypeAccessors$3.at.get = function () {
  return this._vue.refs;
};

prototypeAccessors$3.data.get = function () {
  return this._data;
};

Connector.prototype.destroy = function destroy () {
    var this$1 = this;

  this._unlinkScopeProperties();
  _.forEach(this._angularUnwatches, function (unwatch) {unwatch();});
  _.forEach(this._connections, function (descriptor, key) {this$1._disconnect(key);});
  this._vue.$destroy();
};

Connector.prototype._linkScopeProperties = function _linkScopeProperties () {
    var this$1 = this;

  var dataProperties = _.mapValues(this._connections, function (unused, key) { return ({
    configurable: true, enumerable: false, get: function () {
      var descriptor = this$1._vue.descriptors[key];
      if (descriptor instanceof Reference) { return descriptor.value; }
      return this$1._vue.values[key];
    }
  }); });
  Object.defineProperties(this._data, dataProperties);
  if (this._scope) {
    for (var key in this._connections) {
      if (key in this._scope) {
        throw new Error(("Property already defined on connection target: " + key));
      }
    }
    Object.defineProperties(this._scope, dataProperties);
    if (this._scope.__ob__) { this._scope.__ob__.dep.notify(); }
  }
};

Connector.prototype._unlinkScopeProperties = function _unlinkScopeProperties () {
    var this$1 = this;

  if (!this._scope) { return; }
  _.forEach(this._connections, function (descriptor, key) {
    delete this$1._scope[key];
  });
};

Connector.prototype._bindComputedConnection = function _bindComputedConnection (key, fn) {
  var connectionStats = stats.for(("connection.at." + key));
  var getter = this._computeConnection.bind(this, fn, connectionStats);
  var update = this._updateComputedConnection.bind(this, key, fn, connectionStats);
  var angularWatch = angularProxy.active && !fn.angularWatchSuppressed;
  // Use this._vue.$watch instead of truss.observe here so that we can disable the immediate
  // callback if we'll get one from Angular anyway.
  this._vue.$watch(getter, update, {immediate: !angularWatch});
  if (angularWatch) {
    if (!this._angularUnwatches) { this._angularUnwatches = []; }
    this._angularUnwatches.push(angularProxy.watch(getter, update, true));
  }
};

Connector.prototype._computeConnection = function _computeConnection (fn, connectionStats) {
  var startTime = performanceNow();
  try {
    return flattenRefs(fn.call(this._scope));
  } finally {
    connectionStats.runtime += performanceNow() - startTime;
    connectionStats.numRecomputes += 1;
  }
};

Connector.prototype._updateComputedConnection = function _updateComputedConnection (key, value, connectionStats) {
  var newDescriptor = _.isFunction(value) ? value(this._scope) : value;
  var oldDescriptor = this._vue.descriptors[key];
  var descriptorChanged = !isTrussEqual(oldDescriptor, newDescriptor);
  if (!descriptorChanged) { return; }
  if (connectionStats && descriptorChanged) { connectionStats.numUpdates += 1; }
  if (!newDescriptor) {
    this._disconnect(key);
    return;
  }
  if (newDescriptor instanceof Handle || !_.has(this._subConnectors, key)) {
    this._disconnect(key);
    this._connect(key, newDescriptor);
  } else {
    this._subConnectors[key]._updateConnections(newDescriptor);
  }
  Vue.set(this._vue.descriptors, key, newDescriptor);
  angularProxy.digest();
};

Connector.prototype._updateConnections = function _updateConnections (connections) {
    var this$1 = this;

  _.forEach(connections, function (descriptor, key) {
    this$1._updateComputedConnection(key, descriptor);
  });
  _.forEach(this._connections, function (descriptor, key) {
    if (!_.has(connections, key)) { this$1._updateComputedConnection(key); }
  });
  this._connections = connections;
};

Connector.prototype._connect = function _connect (key, descriptor) {
    var this$1 = this;

  Vue.set(this._vue.descriptors, key, descriptor);
  angularProxy.digest();
  if (!descriptor) { return; }
  Vue.set(this._vue.values, key, undefined);
  if (descriptor instanceof Reference) {
    Vue.set(this._vue.refs, key, descriptor);
    this._disconnects[key] = this._tree.connectReference(descriptor, this._method);
  } else if (descriptor instanceof Query) {
    Vue.set(this._vue.refs, key, descriptor);
    var updateFn = this._updateQueryValue.bind(this, key);
    this._disconnects[key] = this._tree.connectQuery(descriptor, updateFn, this._method);
  } else {
    var subScope = {}, subRefs = {};
    Vue.set(this._vue.refs, key, subRefs);
    var subConnector = this._subConnectors[key] =
      new Connector(subScope, descriptor, this._tree, this._method, subRefs);
    // Use a truss.observe here instead of this._vue.$watch so that the "immediate" execution
    // actually takes place after we've captured the unwatch function, in case the subConnector
    // is ready immediately.
    var unobserve = this._disconnects[key] = this._tree.truss.observe(
      function () { return subConnector.ready; },
      function (subReady) {
        if (!subReady) { return; }
        unobserve();
        delete this$1._disconnects[key];
        Vue.set(this$1._vue.values, key, subScope);
        angularProxy.digest();
      }
    );
  }
};

Connector.prototype._disconnect = function _disconnect (key) {
  Vue.delete(this._vue.refs, key);
  this._updateRefValue(key, undefined);
  if (_.has(this._subConnectors, key)) {
    this._subConnectors[key].destroy();
    delete this._subConnectors[key];
  }
  if (this._disconnects[key]) { this._disconnects[key](); }
  delete this._disconnects[key];
  Vue.delete(this._vue.descriptors, key);
  angularProxy.digest();
};

Connector.prototype._updateRefValue = function _updateRefValue (key, value) {
  if (this._vue.values[key] !== value) {
    Vue.set(this._vue.values, key, value);
    angularProxy.digest();
  }
};

Connector.prototype._updateQueryValue = function _updateQueryValue (key, childKeys) {
  if (!this._vue.values[key]) {
    Vue.set(this._vue.values, key, {});
    angularProxy.digest();
  }
  var subScope = this._vue.values[key];
  for (var childKey in subScope) {
    if (!subScope.hasOwnProperty(childKey)) { continue; }
    if (!_.includes(childKeys, childKey)) {
      Vue.delete(subScope, childKey);
      angularProxy.digest();
    }
  }
  var object = this._tree.getObject(this._vue.descriptors[key].path);
  for (var i = 0, list = childKeys; i < list.length; i += 1) {
    var childKey$1 = list[i];

      if (subScope.hasOwnProperty(childKey$1)) { continue; }
    Vue.set(subScope, childKey$1, object[childKey$1]);
    angularProxy.digest();
  }
};

Object.defineProperties( Connector.prototype, prototypeAccessors$3 );

function flattenRefs(refs) {
  if (!refs) { return; }
  if (refs instanceof Handle) { return refs.toString(); }
  return _.mapValues(refs, flattenRefs);
}

function wrapPromiseCallback(callback) {
  return function() {
    try {
      // eslint-disable-next-line no-invalid-this
      return Promise.resolve(callback.apply(this, arguments));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function promiseCancel(promise, cancel) {
  promise = promiseFinally(promise, function () {cancel = null;});
  promise.cancel = function () {
    if (!cancel) { return; }
    cancel();
    cancel = null;
  };
  propagatePromiseProperty(promise, 'cancel');
  return promise;
}

function propagatePromiseProperty(promise, propertyName) {
  var originalThen = promise.then, originalCatch = promise.catch;
  promise.then = function (onResolved, onRejected) {
    var derivedPromise = originalThen.call(promise, onResolved, onRejected);
    derivedPromise[propertyName] = promise[propertyName];
    propagatePromiseProperty(derivedPromise, propertyName);
    return derivedPromise;
  };
  promise.catch = function (onRejected) {
    var derivedPromise = originalCatch.call(promise, onRejected);
    derivedPromise[propertyName] = promise[propertyName];
    propagatePromiseProperty(derivedPromise, propertyName);
    return derivedPromise;
  };
  return promise;
}

function promiseFinally(promise, onFinally) {
  if (!onFinally) { return promise; }
  onFinally = wrapPromiseCallback(onFinally);
  return promise.then(function (result) {
    return onFinally().then(function () { return result; });
  }, function (error) {
    return onFinally().then(function () { return Promise.reject(error); });
  });
}

var INTERCEPT_KEYS = [
  'read', 'write', 'auth', 'set', 'update', 'commit', 'connect', 'peek', 'authenticate',
  'unathenticate', 'certify', 'all'
];

var EMPTY_ARRAY = [];


var SlowHandle = function SlowHandle(operation, delay, callback) {
  this._operation = operation;
  this._delay = delay;
  this._callback = callback;
  this._fired = false;
};

SlowHandle.prototype.initiate = function initiate () {
    var this$1 = this;

  this.cancel();
  this._fired = false;
  var elapsed = Date.now() - this._operation._startTimestamp;
  this._timeoutId = setTimeout(function () {
    this$1._fired = true;
    this$1._callback(this$1._operation);
  }, this._delay - elapsed);
};

SlowHandle.prototype.cancel = function cancel () {
  if (this._fired) { this._callback(this._operation); }
  if (this._timeoutId) { clearTimeout(this._timeoutId); }
};


var Operation = function Operation(type, method, target, operand) {
  this._type = type;
  this._method = method;
  this._target = target;
  this._operand = operand;
  this._ready = false;
  this._running = false;
  this._ended = false;
  this._tries = 0;
  this._startTimestamp = Date.now();
  this._slowHandles = [];
};

var prototypeAccessors$4 = { type: { configurable: true },method: { configurable: true },target: { configurable: true },targets: { configurable: true },operand: { configurable: true },ready: { configurable: true },running: { configurable: true },ended: { configurable: true },tries: { configurable: true },error: { configurable: true } };

prototypeAccessors$4.type.get = function () {return this._type;};
prototypeAccessors$4.method.get = function () {return this._method;};
prototypeAccessors$4.target.get = function () {return this._target;};
prototypeAccessors$4.targets.get = function () {
    var this$1 = this;

  if (this._method !== 'update') { return [this._target]; }
  return _.map(this._operand, function (value, escapedPathFragment) {
    return new Reference(
      this$1._target._tree, joinPath(this$1._target.path, escapedPathFragment),
      this$1._target._annotations);
  });
};
prototypeAccessors$4.operand.get = function () {return this._operand;};
prototypeAccessors$4.ready.get = function () {return this._ready;};
prototypeAccessors$4.running.get = function () {return this._running;};
prototypeAccessors$4.ended.get = function () {return this._ended;};
prototypeAccessors$4.tries.get = function () {return this._tries;};
prototypeAccessors$4.error.get = function () {return this._error;};

Operation.prototype.onSlow = function onSlow (delay, callback) {
  var handle = new SlowHandle(this, delay, callback);
  this._slowHandles.push(handle);
  handle.initiate();
};

Operation.prototype._setRunning = function _setRunning (value) {
  this._running = value;
};

Operation.prototype._setEnded = function _setEnded (value) {
  this._ended = value;
};

Operation.prototype._markReady = function _markReady (ending) {
  this._ready = true;
  if (!ending) { this._tries = 0; }
  _.forEach(this._slowHandles, function (handle) { return handle.cancel(); });
};

Operation.prototype._clearReady = function _clearReady () {
  this._ready = false;
  this._startTimestamp = Date.now();
  _.forEach(this._slowHandles, function (handle) { return handle.initiate(); });
};

Operation.prototype._incrementTries = function _incrementTries () {
  this._tries++;
};

Object.defineProperties( Operation.prototype, prototypeAccessors$4 );


var Dispatcher = function Dispatcher(bridge) {
  this._bridge = bridge;
  this._callbacks = {};
  Object.freeze(this);
};

Dispatcher.prototype.intercept = function intercept (interceptKey, callbacks) {
  if (!_.includes(INTERCEPT_KEYS, interceptKey)) {
    throw new Error('Unknown intercept operation type: ' + interceptKey);
  }
  var badCallbackKeys =
    _.difference(_.keys(callbacks), ['onBefore', 'onAfter', 'onError', 'onFailure']);
  if (badCallbackKeys.length) {
    throw new Error('Unknown intercept callback types: ' + badCallbackKeys.join(', '));
  }
  var wrappedCallbacks = {
    onBefore: this._addCallback('onBefore', interceptKey, callbacks.onBefore),
    onAfter: this._addCallback('onAfter', interceptKey, callbacks.onAfter),
    onError: this._addCallback('onError', interceptKey, callbacks.onError),
    onFailure: this._addCallback('onFailure', interceptKey, callbacks.onFailure)
  };
  return this._removeCallbacks.bind(this, interceptKey, wrappedCallbacks);
};

Dispatcher.prototype._addCallback = function _addCallback (stage, interceptKey, callback) {
  if (!callback) { return; }
  var key = this._getCallbacksKey(stage, interceptKey);
  var wrappedCallback = wrapPromiseCallback(callback);
  (this._callbacks[key] || (this._callbacks[key] = [])).push(wrappedCallback);
  return wrappedCallback;
};

Dispatcher.prototype._removeCallback = function _removeCallback (stage, interceptKey, wrappedCallback) {
  if (!wrappedCallback) { return; }
  var key = this._getCallbacksKey(stage, interceptKey);
  if (this._callbacks[key]) { _.pull(this._callbacks[key], wrappedCallback); }
};

Dispatcher.prototype._removeCallbacks = function _removeCallbacks (interceptKey, wrappedCallbacks) {
    var this$1 = this;

  _.forEach(wrappedCallbacks, function (wrappedCallback, stage) {
    this$1._removeCallback(stage, interceptKey, wrappedCallback);
  });
};

Dispatcher.prototype._getCallbacks = function _getCallbacks (stage, operationType, method) {
  return [].concat(
    this._callbacks[this._getCallbacksKey(stage, method)] || EMPTY_ARRAY,
    this._callbacks[this._getCallbacksKey(stage, operationType)] || EMPTY_ARRAY,
    this._callbacks[this._getCallbacksKey(stage, 'all')] || EMPTY_ARRAY
  );
};

Dispatcher.prototype._getCallbacksKey = function _getCallbacksKey (stage, interceptKey) {
  return (stage + "_" + interceptKey);
};

Dispatcher.prototype.execute = function execute (operationType, method, target, operand, executor) {
    var this$1 = this;

  executor = wrapPromiseCallback(executor);
  var operation = this.createOperation(operationType, method, target, operand);
  return this.begin(operation).then(function () {
    var executeWithRetries = function () {
      return executor().catch(function (e) { return this$1._retryOrEnd(operation, e).then(executeWithRetries); });
    };
    return executeWithRetries();
  }).then(function (result) { return this$1.end(operation).then(function () { return result; }); });
};

Dispatcher.prototype.createOperation = function createOperation (operationType, method, target, operand) {
  return new Operation(operationType, method, target, operand);
};

Dispatcher.prototype.begin = function begin (operation) {
    var this$1 = this;

  return Promise.all(_.map(
    this._getCallbacks('onBefore', operation.type, operation.method),
    function (onBefore) { return onBefore(operation); }
  )).then(function () {
    if (!operation.ended) { operation._setRunning(true); }
  }, function (e) { return this$1.end(operation, e); });
};

Dispatcher.prototype.markReady = function markReady (operation) {
  operation._markReady();
};

Dispatcher.prototype.clearReady = function clearReady (operation) {
  operation._clearReady();
};

Dispatcher.prototype.retry = function retry (operation, error) {
  operation._incrementTries();
  operation._error = error;
  return Promise.all(_.map(
    this._getCallbacks('onError', operation.type, operation.method),
    function (onError) { return onError(operation, error); }
  )).then(function (results) {
    // If the operation ended in the meantime, bail.This will cause the caller to attempt to
    // fail the operation, but since it's already ended the call to end() with an error will be a
    // no-op.
    if (operation.ended) { return; }
    var retrying = _.some(results);
    if (retrying) { delete operation._error; }
    return retrying;
  });
};

Dispatcher.prototype._retryOrEnd = function _retryOrEnd (operation, error) {
    var this$1 = this;

  return this.retry(operation, error).then(function (result) {
    if (!result) { return this$1.end(operation, error); }
  }, function (e) { return this$1.end(operation, e); });
};

Dispatcher.prototype.end = function end (operation, error) {
    var this$1 = this;

  if (operation.ended) { return Promise.resolve(); }
  operation._setRunning(false);
  operation._setEnded(true);
  if (error) {
    operation._error = error;
  } else {
    // In case we're racing with a retry(), wipe out the error.
    delete operation._error;
  }
  return Promise.all(_.map(
    this._getCallbacks('onAfter', operation.type, operation.method),
    function (onAfter) { return onAfter(operation); }
  )).then(
    function () { return this$1._afterEnd(operation); },
    function (e) {
      operation._error = e;
      return this$1._afterEnd(operation);
    }
  );
};

Dispatcher.prototype._afterEnd = function _afterEnd (operation) {
  operation._markReady(true);
  if (!operation.error) { return Promise.resolve(); }
  var onFailureCallbacks = this._getCallbacks('onFailure', operation.type, operation.method);
  if (onFailureCallbacks) {
    setTimeout(function () {
      _.forEach(onFailureCallbacks, function (onFailure) { return onFailure(operation); });
    }, 0);
  }
  return Promise.reject(operation.error);
};

var ALPHABET = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';

var getRandomValues = window.crypto && window.crypto.getRandomValues &&
  window.crypto.getRandomValues.bind(window.crypto);

var KeyGenerator = function KeyGenerator() {
  this._lastUniqueKeyTime = 0;
  this._lastRandomValues = [];
};

KeyGenerator.prototype.generateUniqueKey = function generateUniqueKey (now) {
  now = now || Date.now();
  var chars = new Array(20);
  var prefix = now;
  for (var i = 7; i >= 0; i--) {
    chars[i] = ALPHABET.charAt(prefix & 0x3f);// eslint-disable-line no-bitwise
    prefix = Math.floor(prefix / 64);
  }
  if (now === this._lastUniqueKeyTime) {
    var i$1 = 11;
    while (i$1 >= 0 && this._lastRandomValues[i$1] === 63) {
      this._lastRandomValues[i$1] = 0;
      i$1 -= 1;
    }
    if (i$1 === -1) {
      throw new Error('Internal assertion failure: ran out of unique IDs for this millisecond');
    }
    this._lastRandomValues[i$1] += 1;
  } else {
    this._lastUniqueKeyTime = now;
    if (getRandomValues) {
      var array = new Uint8Array(12);
      getRandomValues(array);
      for (var i$2 = 0; i$2 < 12; i$2++) {
        // eslint-disable-next-line no-bitwise
        this._lastRandomValues[i$2] = array[i$2] & (i$2 ? 0x3f : 0x0f);
      }
    } else {
      for (var i$3 = 0; i$3 < 12; i$3++) {
        // Make sure to leave some space for incrementing in the top nibble.
        this._lastRandomValues[i$3] = Math.floor(Math.random() * (i$3 ? 64 : 16));
      }
    }
  }
  for (var i$4 = 0; i$4 < 12; i$4++) {
    chars[i$4 + 8] = ALPHABET[this._lastRandomValues[i$4]];
  }
  return chars.join('');
};

var MetaTree = function MetaTree(rootUrl, tree, bridge, dispatcher) {
  this._rootUrl = rootUrl;
  this._tree = tree;
  this._dispatcher = dispatcher;
  this._bridge = bridge;
  this._vue = new Vue({data: {$root: {
    connected: undefined, timeOffset: 0, user: undefined, userid: undefined,
    nowAtInterval: function nowAtInterval(intervalMillis) {
      var this$1 = this;

      var key = 'now' + intervalMillis;
      if (!this.hasOwnProperty(key)) {
        var update = function () {
          Vue.set(this$1, key, Date.now() + this$1.timeOffset);
          angularProxy.digest();
        };
        update();
        setInterval(update, intervalMillis);
      }
      return this[key];
    }
  }}});

  this._auth = {serial: 0, initialAuthChangeReceived: false};

  bridge.onAuth(rootUrl, this._handleAuthChange, this);

  this._connectInfoProperty('serverTimeOffset', 'timeOffset');
  this._connectInfoProperty('connected', 'connected');
  Object.freeze(this);
};

var prototypeAccessors$5 = { root: { configurable: true } };

prototypeAccessors$5.root.get = function () {
  return this._vue.$data.$root;
};

MetaTree.prototype.destroy = function destroy () {
  this._bridge.offAuth(this._rootUrl, this._handleAuthChange, this);
  this._vue.$destroy();
};

MetaTree.prototype.authenticate = function authenticate (token) {
    var this$1 = this;

  this._auth.serial++;
  return this._dispatcher.execute(
    'auth', 'authenticate', new Reference(this._tree, '/'), token, function () {
      if (token) { return this$1._bridge.authWithCustomToken(this$1._rootUrl, token); }
      return this$1._bridge.authAnonymously(this$1._rootUrl);
    }
  );
};

MetaTree.prototype.unauthenticate = function unauthenticate () {
    var this$1 = this;

  // Signal user change to null pre-emptively.This is what the Firebase SDK does as well, since
  // it lets the app tear down user-required connections before the user is actually deauthed,
  // which can prevent spurious permission denied errors.
  this._auth.serial++;
  return this._handleAuthChange(null).then(function (approved) {
    // Bail if auth change callback initiated another authentication, since it will have already
    // sent the command to the bridge and sending our own now would incorrectly override it.
    if (!approved) { return; }
    return this$1._dispatcher.execute(
      'auth', 'unauthenticate', new Reference(this$1._tree, '/'), undefined, function () {
        return this$1._bridge.unauth(this$1._rootUrl);
      }
    );
  });
};

MetaTree.prototype._handleAuthChange = function _handleAuthChange (user) {
    var this$1 = this;

  var supersededChange = !this._auth.initialAuthChangeReceived && this._auth.serial;
  if (user !== undefined) { this._auth.initialAuthChangeReceived = true; }
  if (supersededChange) { return; }
  var authSerial = this._auth.serial;
  if (this.root.user === user) { return Promise.resolve(false); }
  return this._dispatcher.execute('auth', 'certify', new Reference(this._tree, '/'), user, function () {
    if (this$1.root.user === user || authSerial !== this$1._auth.serial) { return false; }
    if (user) { Object.freeze(user); }
    this$1.root.user = user;
    this$1.root.userid = user && user.uid;
    angularProxy.digest();
    return true;
  });
};

MetaTree.prototype._isAuthChangeStale = function _isAuthChangeStale (user) {
  return this.root.user === user;
};

MetaTree.prototype._connectInfoProperty = function _connectInfoProperty (property, attribute) {
    var this$1 = this;

  var propertyUrl = (this._rootUrl) + "/.info/" + property;
  this._bridge.on(propertyUrl, propertyUrl, null, 'value', function (snap) {
    this$1.root[attribute] = snap.value;
    angularProxy.digest();
  });
};

Object.defineProperties( MetaTree.prototype, prototypeAccessors$5 );

// These are defined separately for each object so they're not included in Value below.
var RESERVED_VALUE_PROPERTY_NAMES = {$$$trussCheck: true, __ob__: true};

// Holds properties that we're going to set on a model object that's being created right now as soon
// as it's been created, but that we'd like to be accessible in the constructor.  The object
// prototype's getters will pick those up until they get overridden in the instance.
var creatingObjectProperties;

var currentPropertyFrozen;


var BaseValue = function BaseValue () {};

var prototypeAccessors$6 = { $meta: { configurable: true },$store: { configurable: true },$now: { configurable: true },$$finalizers: { configurable: true } };

prototypeAccessors$6.$meta.get = function () {return this.$truss.meta;};
prototypeAccessors$6.$store.get = function () {return this.$truss.store;};// access indirectly to leave dependency trace
prototypeAccessors$6.$now.get = function () {return this.$truss.now;};

BaseValue.prototype.$newKey = function $newKey () {return this.$truss.newKey();};

BaseValue.prototype.$intercept = function $intercept (actionType, callbacks) {
    var this$1 = this;

  if (this.$destroyed) { throw new Error('Object already destroyed'); }
  var unintercept = this.$truss.intercept(actionType, callbacks);
  var uninterceptAndRemoveFinalizer = function () {
    unintercept();
    _.pull(this$1.$$finalizers, uninterceptAndRemoveFinalizer);
  };
  this.$$finalizers.push(uninterceptAndRemoveFinalizer);
  return uninterceptAndRemoveFinalizer;
};

BaseValue.prototype.$connect = function $connect (scope, connections) {
    var this$1 = this;

  if (this.$destroyed) { throw new Error('Object already destroyed'); }
  if (!connections) {
    connections = scope;
    scope = undefined;
  }
  var connector = this.$truss.connect(scope, wrapConnections(this, connections));
  var originalDestroy = connector.destroy;
  var destroy = function () {
    _.pull(this$1.$$finalizers, destroy);
    return originalDestroy.call(connector);
  };
  this.$$finalizers.push(destroy);
  connector.destroy = destroy;
  return connector;
};

BaseValue.prototype.$peek = function $peek (target, callback) {
    var this$1 = this;

  if (this.$destroyed) { throw new Error('Object already destroyed'); }
  var promise = promiseFinally(
    this.$truss.peek(target, callback), function () {_.pull(this$1.$$finalizers, promise.cancel);}
  );
  this.$$finalizers.push(promise.cancel);
  return promise;
};

BaseValue.prototype.$observe = function $observe (subjectFn, callbackFn, options) {
    var this$1 = this;

  if (this.$destroyed) { throw new Error('Object already destroyed'); }
  var unobserveAndRemoveFinalizer;

  var unobserve = this.$truss.observe(function () {
    this$1.$$touchThis();
    return subjectFn.call(this$1);
  }, callbackFn.bind(this), options);

  unobserveAndRemoveFinalizer = function () {// eslint-disable-line prefer-const
    unobserve();
    _.pull(this$1.$$finalizers, unobserveAndRemoveFinalizer);
  };
  this.$$finalizers.push(unobserveAndRemoveFinalizer);
  return unobserveAndRemoveFinalizer;
};

BaseValue.prototype.$when = function $when (expression, options) {
    var this$1 = this;

  if (this.$destroyed) { throw new Error('Object already destroyed'); }
  var promise = this.$truss.when(function () {
    this$1.$$touchThis();
    return expression.call(this$1);
  }, options);
  promiseFinally(promise, function () {_.pull(this$1.$$finalizers, promise.cancel);});
  this.$$finalizers.push(promise.cancel);
  return promise;
};

prototypeAccessors$6.$$finalizers.get = function () {
  Object.defineProperty(this, '$$finalizers', {
    value: [], writable: false, enumerable: false, configurable: false});
  return this.$$finalizers;
};

Object.defineProperties( BaseValue.prototype, prototypeAccessors$6 );


var Value = function Value () {};

var prototypeAccessors$1$2 = { $parent: { configurable: true },$path: { configurable: true },$truss: { configurable: true },$ref: { configurable: true },$refs: { configurable: true },$key: { configurable: true },$data: { configurable: true },$hidden: { configurable: true },$empty: { configurable: true },$keys: { configurable: true },$values: { configurable: true },$ready: { configurable: true },$overridden: { configurable: true },$$initializers: { configurable: true },$destroyed: { configurable: true } };

prototypeAccessors$1$2.$parent.get = function () {return creatingObjectProperties.$parent.value;};
prototypeAccessors$1$2.$path.get = function () {return creatingObjectProperties.$path.value;};
prototypeAccessors$1$2.$truss.get = function () {
  Object.defineProperty(this, '$truss', {value: this.$parent.$truss});
  return this.$truss;
};
prototypeAccessors$1$2.$ref.get = function () {
  Object.defineProperty(this, '$ref', {value: new Reference(this.$truss._tree, this.$path)});
  return this.$ref;
};
prototypeAccessors$1$2.$refs.get = function () {return this.$ref;};
prototypeAccessors$1$2.$key.get = function () {
  Object.defineProperty(
    this, '$key', {value: unescapeKey(this.$path.slice(this.$path.lastIndexOf('/') + 1))});
  return this.$key;
};
prototypeAccessors$1$2.$data.get = function () {return this;};
prototypeAccessors$1$2.$hidden.get = function () {return false;};// eslint-disable-line lodash/prefer-constant
prototypeAccessors$1$2.$empty.get = function () {return _.isEmpty(this.$data);};
prototypeAccessors$1$2.$keys.get = function () {return _.keys(this.$data);};
prototypeAccessors$1$2.$values.get = function () {return _.values(this.$data);};
prototypeAccessors$1$2.$ready.get = function () {return this.$ref.ready;};
prototypeAccessors$1$2.$overridden.get = function () {return false;};// eslint-disable-line lodash/prefer-constant

Value.prototype.$nextTick = function $nextTick () {
    var this$1 = this;

  if (this.$destroyed) { throw new Error('Object already destroyed'); }
  var promise = this.$truss.nextTick();
  promiseFinally(promise, function () {_.pull(this$1.$$finalizers, promise.cancel);});
  this.$$finalizers.push(promise.cancel);
  return promise;
};

Value.prototype.$freezeComputedProperty = function $freezeComputedProperty () {
  if (!_.isBoolean(currentPropertyFrozen)) {
    throw new Error('Cannot freeze a computed property outside of its getter function');
  }
  currentPropertyFrozen = true;
};

Value.prototype.$set = function $set (value) {return this.$ref.set(value);};
Value.prototype.$update = function $update (values) {return this.$ref.update(values);};
Value.prototype.$override = function $override (values) {return this.$ref.override(values);};
Value.prototype.$commit = function $commit (options, updateFn) {return this.$ref.commit(options, updateFn);};

Value.prototype.$$touchThis = function $$touchThis () {
  /* eslint-disable no-unused-expressions */
  if (this.__ob__) {
    this.__ob__.dep.depend();
  } else if (this.$parent) {
    (this.$parent.hasOwnProperty('$data') ? this.$parent.$data : this.$parent)[this.$key];
  } else {
    this.$store;
  }
  /* eslint-enable no-unused-expressions */
};

prototypeAccessors$1$2.$$initializers.get = function () {
  Object.defineProperty(this, '$$initializers', {
    value: [], writable: false, enumerable: false, configurable: true});
  return this.$$initializers;
};

prototypeAccessors$1$2.$destroyed.get = function () {// eslint-disable-line lodash/prefer-constant
  return false;
};

Object.defineProperties( Value.prototype, prototypeAccessors$1$2 );

copyPrototype(BaseValue, Value);

_.forEach(Value.prototype, function (prop, name) {
  Object.defineProperty(
    Value.prototype, name, {value: prop, enumerable: false, configurable: false, writable: false});
});


var ErrorWrapper = function ErrorWrapper(error) {
  this.error = error;
};


var FrozenWrapper = function FrozenWrapper(value) {
  this.value = value;
};


var Modeler = function Modeler(debug) {
  this._trie = {Class: Value};
  this._debug = debug;
  Object.freeze(this);
};

Modeler.prototype.init = function init (classes, rootAcceptable) {
    var this$1 = this;

  if (_.isPlainObject(classes)) {
    _.forEach(classes, function (Class, path) {
      if (Class.$trussMount) { return; }
      Class.$$trussMount = Class.$$trussMount || [];
      Class.$$trussMount.push(path);
    });
    classes = _.values(classes);
    _.forEach(classes, function (Class) {
      if (!Class.$trussMount && Class.$$trussMount) {
        Class.$trussMount = Class.$$trussMount;
        delete Class.$$trussMount;
      }
    });
  }
  classes = _.uniq(classes);
  _.forEach(classes, function (Class) { return this$1._mountClass(Class, rootAcceptable); });
  this._decorateTrie(this._trie);
};

Modeler.prototype.destroy = function destroy () {// eslint-disable-line no-empty-function
};

Modeler.prototype._getMount = function _getMount (path, scaffold, predicate) {
  var segments = splitPath(path, true);
  var node;
  for (var i = 0, list = segments; i < list.length; i += 1) {
    var segment = list[i];

      var child = segment ?
      node.children && (node.children[segment] || !scaffold && node.children.$) : this._trie;
    if (!child) {
      if (!scaffold) { return; }
      node.children = node.children || {};
      child = node.children[segment] = {Class: Value};
    }
    node = child;
    if (predicate && predicate(node)) { break; }
  }
  return node;
};

Modeler.prototype._findMount = function _findMount (predicate, node) {
  if (!node) { node = this._trie; }
  if (predicate(node)) { return node; }
  for (var i = 0, list = _.keys(node.children); i < list.length; i += 1) {
    var childKey = list[i];

      var result = this._findMount(predicate, node.children[childKey]);
    if (result) { return result; }
  }
};

Modeler.prototype._decorateTrie = function _decorateTrie (node) {
    var this$1 = this;

  _.forEach(node.children, function (child) {
    this$1._decorateTrie(child);
    if (child.local || child.localDescendants) { node.localDescendants = true; }
  });
};

Modeler.prototype._augmentClass = function _augmentClass (Class) {
  var computedProperties;
  var proto = Class.prototype;
  while (proto && proto.constructor !== Object) {
    for (var i = 0, list = Object.getOwnPropertyNames(proto); i < list.length; i += 1) {
      var name = list[i];

        var descriptor = Object.getOwnPropertyDescriptor(proto, name);
      if (name.charAt(0) === '$') {
        if (name === '$finalize') { continue; }
        if (_.isEqual(descriptor, Object.getOwnPropertyDescriptor(Value.prototype, name))) {
          continue;
        }
        throw new Error(("Property names starting with \"$\" are reserved: " + (Class.name) + "." + name));
      }
      if (descriptor.get && !(computedProperties && computedProperties[name])) {
        (computedProperties || (computedProperties = {}))[name] = {
          name: name, fullName: ((proto.constructor.name) + "." + name), get: descriptor.get,
          set: descriptor.set
        };
      }
    }
    proto = Object.getPrototypeOf(proto);
  }
  for (var i$1 = 0, list$1 = Object.getOwnPropertyNames(Value.prototype); i$1 < list$1.length; i$1 += 1) {
    var name$1 = list$1[i$1];

      if (name$1 === 'constructor' || Class.prototype.hasOwnProperty(name$1)) { continue; }
    Object.defineProperty(
      Class.prototype, name$1, Object.getOwnPropertyDescriptor(Value.prototype, name$1));
  }
  return computedProperties;
};

Modeler.prototype._mountClass = function _mountClass (Class, rootAcceptable) {
    var this$1 = this;

  var computedProperties = this._augmentClass(Class);
  var allVariables = [];
  var mounts = Class.$trussMount;
  if (!mounts) { throw new Error(("Class " + (Class.name) + " lacks a $trussMount static property")); }
  if (!_.isArray(mounts)) { mounts = [mounts]; }
  _.forEach(mounts, function (mount) {
    if (_.isString(mount)) { mount = {path: mount}; }
    if (!rootAcceptable && mount.path === '/') {
      throw new Error('Data root already accessed, too late to mount class');
    }
    var matcher = makePathMatcher(mount.path);
    for (var i = 0, list = matcher.variables; i < list.length; i += 1) {
      var variable = list[i];

        if (variable === '$' || variable.charAt(1) === '$') {
        throw new Error(("Invalid variable name: " + variable));
      }
      if (variable.charAt(0) === '$' && (
        _.has(Value.prototype, variable) || RESERVED_VALUE_PROPERTY_NAMES[variable]
      )) {
        throw new Error(("Variable name conflicts with built-in property or method: " + variable));
      }
      allVariables.push(variable);
    }
    var escapedKey = mount.path.match(/\/([^/]*)$/)[1];
    if (escapedKey.charAt(0) === '$') {
      if (mount.placeholder) {
        throw new Error(
          ("Class " + (Class.name) + " mounted at wildcard " + escapedKey + " cannot be a placeholder"));
      }
    } else if (!_.has(mount, 'placeholder')) {
      mount.placeholder = {};
    }
    var targetMount = this$1._getMount(mount.path.replace(/\$[^/]*/g, '$'), true);
    if (targetMount.matcher && (
      targetMount.escapedKey === escapedKey ||
      targetMount.escapedKey.charAt(0) === '$' && escapedKey.charAt(0) === '$'
    )) {
      throw new Error(
        ("Multiple classes mounted at " + (mount.path) + ": " + (targetMount.Class.name) + ", " + (Class.name)));
    }
    _.assign(
      targetMount, {Class: Class, matcher: matcher, computedProperties: computedProperties, escapedKey: escapedKey},
      _.pick(mount, 'placeholder', 'local', 'keysUnsafe', 'hidden'));
  });
  _.forEach(allVariables, function (variable) {
    if (!Class.prototype[variable]) {
      Object.defineProperty(Class.prototype, variable, {get: function get() {
        return creatingObjectProperties ?
          creatingObjectProperties[variable] && creatingObjectProperties[variable].value :
          undefined;
      }});
    }
  });
};

/**
 * Creates a Truss object and sets all its basic properties: path segment variables, user-defined
 * properties, and computed properties.The latter two will be enumerable so that Vue will pick
 * them up and make the reactive.
 */
Modeler.prototype.createObject = function createObject (path, properties) {
    var this$1 = this;

  var mount = this._getMount(path) || {Class: Value};
  try {
    if (mount.matcher) {
      var match = mount.matcher.match(path);
      for (var variable in match) {
        properties[variable] = {value: match[variable]};
      }
    }

    creatingObjectProperties = properties;
    var object = new mount.Class();
    creatingObjectProperties = null;

    if (angularProxy.active) { this._wrapProperties(object); }

    if (mount.keysUnsafe) {
      properties.$data = {value: Object.create(null), configurable: true, enumerable: true};
    }
    if (mount.hidden) { properties.$hidden = {value: true}; }
    if (mount.computedProperties) {
      _.forEach(mount.computedProperties, function (prop) {
        properties[prop.name] = this$1._buildComputedPropertyDescriptor(object, prop);
      });
    }

    return object;
  } catch (e) {
    e.extra = _.assign({mount: mount, properties: properties, className: mount.Class && mount.Class.name}, e.extra);
    throw e;
  }
};

Modeler.prototype._wrapProperties = function _wrapProperties (object) {
  _.forEach(object, function (value, key) {
      var obj;

    var valueKey = '$_' + key;
    Object.defineProperties(object, ( obj = {}, obj[valueKey] = {value: value, writable: true}, obj[key] = {
        get: function () { return object[valueKey]; },
        set: function (arg) {object[valueKey] = arg; angularProxy.digest();},
        enumerable: true, configurable: true
      }, obj ));
  });
};

Modeler.prototype._buildComputedPropertyDescriptor = function _buildComputedPropertyDescriptor (object, prop) {
    var this$1 = this;

  var propertyStats = stats.for(prop.fullName);

  var value, pendingPromise;
  var writeAllowed = false;

  object.$$initializers.push(function (vue) {
    var unwatchNow = false;
    var compute = computeValue.bind(object, prop, propertyStats);
    if (this$1._debug) { compute.toString = function () {return prop.fullName;}; }
    var unwatch = function () {unwatchNow = true;};
    unwatch = vue.$watch(compute, function (newValue) {
      if (object.$destroyed) {
        unwatch();
        return;
      }
      if (pendingPromise) {
        if (pendingPromise.cancel) { pendingPromise.cancel(); }
        pendingPromise = undefined;
      }
      if (_.isObject(newValue) && _.isFunction(newValue.then)) {
        var promise = newValue.then(function (finalValue) {
          if (promise === pendingPromise) { update(finalValue); }
          // No need to angular.digest() here, since if we're running under Angular then we expect
          // promises to be aliased to its $q service, which triggers digest itself.
        }, function (error) {
          if (promise === pendingPromise && update(new ErrorWrapper(error)) &&
              !error.trussExpectedException) { throw error; }
        });
        pendingPromise = promise;
      } else if (update(newValue)) {
        angularProxy.digest();
        if (newValue instanceof ErrorWrapper && !newValue.error.trussExpectedException) {
          throw newValue.error;
        }
      }
    }, {immediate: true});// use immediate:true since watcher will run computeValue anyway
    // Hack to change order of computed property watchers.By flipping their ids to be negative,
    // we ensure that they will settle before all other watchers, and also that children
    // properties will settle before their parents since values are often aggregated upwards.
    var watcher = _.last(vue._watchers);
    watcher.id = -watcher.id;

    function update(newValue) {
      if (newValue instanceof FrozenWrapper) {
        newValue = newValue.value;
        unwatch();
        _.pull(object.$$finalizers, unwatch);
      }
      if (isTrussEqual(value, newValue)) { return; }
      // console.log('updating', object.$key, prop.fullName, 'from', value, 'to', newValue);
      propertyStats.numUpdates += 1;
      writeAllowed = true;
      object[prop.name] = newValue;
      writeAllowed = false;
      // Freeze the computed value so it can't be accidentally modified by a third party.Ideally
      // we'd freeze it before setting it so that Vue wouldn't instrument the object recursively
      // (since it can't change anyway), but we actually need the instrumentation in case a client
      // tries to access an inexistent property off a computed pointer to an unfrozen value (e.g.,
      // a $truss-ified object).When instrumented, Vue will add a dependency on the unfrozen
      // value in case the property is later added.If uninstrumented, the dependency won't be
      // added and we won't be notified.And Vue only instruments extensible objects...
      freeze(newValue);
      return true;
    }

    if (unwatchNow) {
      unwatch();
    } else {
      object.$$finalizers.push(unwatch);
    }
  });
  return {
    enumerable: true, configurable: true,
    get: function get() {
      if (!writeAllowed && value instanceof ErrorWrapper) { throw value.error; }
      return value;
    },
    set: function set(newValue) {
      if (writeAllowed) {
        value = newValue;
      } else if (prop.set) {
        prop.set.call(this, newValue);
      } else {
        throw new Error(("You cannot set a computed property: " + (prop.name)));
      }
    }
  };
};

Modeler.prototype.destroyObject = function destroyObject (object) {
  if (_.has(object, '$$finalizers')) {
    // Some finalizers remove themselves from the array, so clone it before iterating.
    for (var i = 0, list = _.clone(object.$$finalizers); i < list.length; i += 1) {
        var fn = list[i];

        fn();
      }
  }
  if (_.isFunction(object.$finalize)) { object.$finalize(); }
  Object.defineProperty(
    object, '$destroyed', {value: true, enumerable: false, configurable: false});
};

Modeler.prototype.isPlaceholder = function isPlaceholder (path) {
  var mount = this._getMount(path);
  return mount && mount.placeholder;
};

Modeler.prototype.isLocal = function isLocal (path, value) {
  // eslint-disable-next-line no-shadow
  var mount = this._getMount(path, false, function (mount) { return mount.local; });
  if (mount && mount.local) { return true; }
  if (this._hasLocalProperties(mount, value)) {
    throw new Error('Write on a mix of local and remote tree paths.');
  }
  return false;
};

Modeler.prototype._hasLocalProperties = function _hasLocalProperties (mount, value) {
  if (!mount) { return false; }
  if (mount.local) { return true; }
  if (!mount.localDescendants || !_.isObject(value)) { return false; }
  for (var key in value) {
    var local =
      this._hasLocalProperties(mount.children[escapeKey(key)] || mount.children.$, value[key]);
    if (local) { return true; }
  }
  return false;
};

Modeler.prototype.forEachPlaceholderChild = function forEachPlaceholderChild (path, iteratee) {
  var mount = this._getMount(path);
  _.forEach(mount && mount.children, function (child) {
    if (child.placeholder) { iteratee(child); }
  });
};

Modeler.prototype.checkVueObject = function checkVueObject (object, path, checkedObjects) {
  var top = !checkedObjects;
  if (top) { checkedObjects = []; }
  try {
    for (var i = 0, list = Object.getOwnPropertyNames(object); i < list.length; i += 1) {
      var key = list[i];

        if (RESERVED_VALUE_PROPERTY_NAMES[key] || Value.prototype.hasOwnProperty(key) ||
          /^\$_/.test(key)) { continue; }
      // eslint-disable-next-line no-shadow
      var mount = this._findMount(function (mount) { return mount.Class === object.constructor; });
      if (mount && mount.matcher && _.includes(mount.matcher.variables, key)) { continue; }
      var value = (void 0);
      try {
        value = object[key];
      } catch (e) {
        // Ignore any values that hold exceptions, or otherwise throw on access -- we won't be
        // able to check them anyway.
        continue;
      }
      if (!(_.isArray(object) && (/\d+/.test(key) || key === 'length'))) {
        var descriptor = Object.getOwnPropertyDescriptor(object, key);
        if ('value' in descriptor || !descriptor.get) {
          throw new Error(
            ("Value at " + path + ", contained in a Firetruss object, has a rogue property: " + key));
        }
        if (object.$truss && descriptor.enumerable) {
          try {
            object[key] = value;
            throw new Error(
              ("Firetruss object at " + path + " has an enumerable non-Firebase property: " + key));
          } catch (e$1) {
            if (e$1.trussCode !== 'firebase_overwrite') { throw e$1; }
          }
        }
      }
      if (_.isObject(value) && !value.$$$trussCheck && Object.isExtensible(value) &&
          !(_.isFunction(value) || value instanceof Promise)) {
        value.$$$trussCheck = true;
        checkedObjects.push(value);
        this.checkVueObject(value, joinPath(path, escapeKey(key)), checkedObjects);
      }
    }
  } finally {
    if (top) {
      for (var i$1 = 0, list$1 = checkedObjects; i$1 < list$1.length; i$1 += 1) {
          var item = list$1[i$1];

          delete item.$$$trussCheck;
        }
    }
  }
};


function computeValue(prop, propertyStats) {
  /* eslint-disable no-invalid-this */
  if (this.$destroyed) { return; }
  // Touch this object, since a failed access to a missing property doesn't get captured as a
  // dependency.
  this.$$touchThis();

  var oldPropertyFrozen = currentPropertyFrozen;
  currentPropertyFrozen = false;
  var startTime = performanceNow();
  var value;
  try {
    try {
      value = prop.get.call(this);
    } catch (e) {
      value = new ErrorWrapper(e);
    } finally {
      propertyStats.runtime += performanceNow() - startTime;
      propertyStats.numRecomputes += 1;
    }
    if (currentPropertyFrozen) { value = new FrozenWrapper(value); }
    return value;
  } finally {
    currentPropertyFrozen = oldPropertyFrozen;
  }
  /* eslint-enable no-invalid-this */
}

function wrapConnections(object, connections) {
  if (!connections || connections instanceof Handle) { return connections; }
  return _.mapValues(connections, function (descriptor) {
    if (descriptor instanceof Handle) { return descriptor; }
    if (_.isFunction(descriptor)) {
      var fn = function() {
        /* eslint-disable no-invalid-this */
        object.$$touchThis();
        return wrapConnections(object, descriptor.call(this));
        /* eslint-enable no-invalid-this */
      };
      fn.angularWatchSuppressed = true;
      return fn;
    }
    return wrapConnections(object, descriptor);
  });
}

function freeze(object) {
  if (_.isNil(object) || !_.isObject(object) || Object.isFrozen(object) || object.$truss) {
    return object;
  }
  object = Object.freeze(object);
  if (_.isArray(object)) { return _.map(object, function (value) { return freeze(value); }); }
  return _.mapValues(object, function (value) { return freeze(value); });
}

var QueryHandler = function QueryHandler(coupler, query) {
  this._coupler = coupler;
  this._query = query;
  this._listeners = [];
  this._keys = [];
  this._url = this._coupler._rootUrl + query.path;
  this._segments = splitPath(query.path, true);
  this._listening = false;
  this.ready = false;
};

QueryHandler.prototype.attach = function attach (operation, keysCallback) {
  this._listen();
  this._listeners.push({operation: operation, keysCallback: keysCallback});
  if (keysCallback) { keysCallback(this._keys); }
};

QueryHandler.prototype.detach = function detach (operation) {
  var k = _.findIndex(this._listeners, {operation: operation});
  if (k >= 0) { this._listeners.splice(k, 1); }
  return this._listeners.length;
};

QueryHandler.prototype._listen = function _listen () {
  if (this._listening) { return; }
  this._coupler._bridge.on(
    this._query.toString(), this._url, this._query.constraints, 'value',
    this._handleSnapshot, this._handleError, this, {sync: true});
  this._listening = true;
};

QueryHandler.prototype.destroy = function destroy () {
  this._coupler._bridge.off(
    this._query.toString(), this._url, this._query.constraints, 'value', this._handleSnapshot,
    this);
  this._listening = false;
  this.ready = false;
  angularProxy.digest();
  for (var i = 0, list = this._keys; i < list.length; i += 1) {
    var key = list[i];

      this._coupler._decoupleSegments(this._segments.concat(key));
  }
};

QueryHandler.prototype._handleSnapshot = function _handleSnapshot (snap) {
    var this$1 = this;

  this._coupler._queueSnapshotCallback(function () {
    // Order is important here: first couple any new subpaths so _handleSnapshot will update the
    // tree, then tell the client to update its keys, pulling values from the tree.
    if (!this$1._listeners.length || !this$1._listening) { return; }
    var updatedKeys = this$1._updateKeys(snap);
    this$1._coupler._applySnapshot(snap);
    if (!this$1.ready) {
      this$1.ready = true;
      angularProxy.digest();
      for (var i = 0, list = this$1._listeners; i < list.length; i += 1) {
        var listener = list[i];

          this$1._coupler._dispatcher.markReady(listener.operation);
      }
    }
    if (updatedKeys) {
      for (var i$1 = 0, list$1 = this$1._listeners; i$1 < list$1.length; i$1 += 1) {
        var listener$1 = list$1[i$1];

          if (listener$1.keysCallback) { listener$1.keysCallback(updatedKeys); }
      }
    }
  });
};

QueryHandler.prototype._updateKeys = function _updateKeys (snap) {
  var updatedKeys;
  if (snap.path === this._query.path) {
    updatedKeys = _.keys(snap.value);
    updatedKeys.sort();
    if (_.isEqual(this._keys, updatedKeys)) {
      updatedKeys = null;
    } else {
      for (var i = 0, list = _.difference(updatedKeys, this._keys); i < list.length; i += 1) {
        var key = list[i];

          this._coupler._coupleSegments(this._segments.concat(key));
      }
      for (var i$1 = 0, list$1 = _.difference(this._keys, updatedKeys); i$1 < list$1.length; i$1 += 1) {
        var key$1 = list$1[i$1];

          this._coupler._decoupleSegments(this._segments.concat(key$1));
      }
      this._keys = updatedKeys;
    }
  } else if (snap.path.replace(/\/[^/]+/, '') === this._query.path) {
    var hasKey = _.includes(this._keys, snap.key);
    if (snap.value) {
      if (!hasKey) {
        this._coupler._coupleSegments(this._segments.concat(snap.key));
        this._keys.push(snap.key);
        this._keys.sort();
        updatedKeys = this._keys;
      }
    } else if (hasKey) {
      this._coupler._decoupleSegments(this._segments.concat(snap.key));
      _.pull(this._keys, snap.key);
      this._keys.sort();
      updatedKeys = this._keys;
    }
  }
  return updatedKeys;
};

QueryHandler.prototype._handleError = function _handleError (error) {
    var this$1 = this;

  if (!this._listeners.length || !this._listening) { return; }
  this._listening = false;
  this.ready = false;
  angularProxy.digest();
  Promise.all(_.map(this._listeners, function (listener) {
    this$1._coupler._dispatcher.clearReady(listener.operation);
    return this$1._coupler._dispatcher.retry(listener.operation, error).catch(function (e) {
      listener.operation._disconnect(e);
      return false;
    });
  })).then(function (results) {
    if (_.some(results)) {
      if (this$1._listeners.length) { this$1._listen(); }
    } else {
      for (var i = 0, list = this$1._listeners; i < list.length; i += 1) {
          var listener = list[i];

          listener.operation._disconnect(error);
        }
    }
  });
};


var Node = function Node(coupler, path, parent) {
  this._coupler = coupler;
  this.path = path;
  this.parent = parent;
  this.url = this._coupler._rootUrl + path;
  this.operations = [];
  this.queryCount = 0;
  this.listening = false;
  this.ready = false;
  this.children = {};
};

var prototypeAccessors$7 = { active: { configurable: true },count: { configurable: true } };

prototypeAccessors$7.active.get = function () {
  return this.count || this.queryCount;
};

prototypeAccessors$7.count.get = function () {
  return this.operations.length;
};

Node.prototype.listen = function listen (skip) {
    var this$1 = this;

  if (!skip && this.count) {
    if (this.listening) { return; }
    _.forEach(this.operations, function (op) {this$1._coupler._dispatcher.clearReady(op);});
    this._coupler._bridge.on(
      this.url, this.url, null, 'value', this._handleSnapshot, this._handleError, this,
      {sync: true});
    this.listening = true;
  } else {
    _.forEach(this.children, function (child) {child.listen();});
  }
};

Node.prototype.unlisten = function unlisten (skip) {
  if (!skip && this.listening) {
    this._coupler._bridge.off(this.url, this.url, null, 'value', this._handleSnapshot, this);
    this.listening = false;
    this._forAllDescendants(function (node) {
      if (node.listening) { return false; }
      if (node.ready) {
        node.ready = false;
        angularProxy.digest();
      }
    });
  } else {
    _.forEach(this.children, function (child) {child.unlisten();});
  }
};

Node.prototype._handleSnapshot = function _handleSnapshot (snap) {
    var this$1 = this;

  this._coupler._queueSnapshotCallback(function () {
    if (!this$1.listening || !this$1._coupler.isTrunkCoupled(snap.path)) { return; }
    this$1._coupler._applySnapshot(snap);
    if (!this$1.ready && snap.path === this$1.path) {
      this$1.ready = true;
      angularProxy.digest();
      this$1.unlisten(true);
      this$1._forAllDescendants(function (node) {
        for (var i = 0, list = node.operations; i < list.length; i += 1) {
            var op = list[i];

            this$1._coupler._dispatcher.markReady(op);
          }
      });
    }
  });
};

Node.prototype._handleError = function _handleError (error) {
    var this$1 = this;

  if (!this.count || !this.listening) { return; }
  this.listening = false;
  this._forAllDescendants(function (node) {
    if (node.listening) { return false; }
    if (node.ready) {
      node.ready = false;
      angularProxy.digest();
    }
    for (var i = 0, list = node.operations; i < list.length; i += 1) {
        var op = list[i];

        this$1._coupler._dispatcher.clearReady(op);
      }
  });
  return Promise.all(_.map(this.operations, function (op) {
    return this$1._coupler._dispatcher.retry(op, error).catch(function (e) {
      op._disconnect(e);
      return false;
    });
  })).then(function (results) {
    if (_.some(results)) {
      if (this$1.count) { this$1.listen(); }
    } else {
      for (var i = 0, list = this$1.operations; i < list.length; i += 1) {
          var op = list[i];

          op._disconnect(error);
        }
      // Pulling all the operations will automatically get us listening on descendants.
    }
  });
};

Node.prototype._forAllDescendants = function _forAllDescendants (iteratee) {
  if (iteratee(this) === false) { return; }
  _.forEach(this.children, function (child) { return child._forAllDescendants(iteratee); });
};

Node.prototype.collectCoupledDescendantPaths = function collectCoupledDescendantPaths (paths) {
  if (!paths) { paths = {}; }
  paths[this.path] = this.active;
  if (!this.active) {
    _.forEach(this.children, function (child) {child.collectCoupledDescendantPaths(paths);});
  }
  return paths;
};

Object.defineProperties( Node.prototype, prototypeAccessors$7 );


var Coupler = function Coupler(rootUrl, bridge, dispatcher, applySnapshot, prunePath) {
  this._rootUrl = rootUrl;
  this._bridge = bridge;
  this._dispatcher = dispatcher;
  this._applySnapshot = applySnapshot;
  this._pendingSnapshotCallbacks = [];
  this._throttled = {processPendingSnapshots: this._processPendingSnapshots};
  this._prunePath = prunePath;
  this._vue = new Vue({data: {root: undefined, queryHandlers: {}}});
  // Prevent Vue from instrumenting rendering since there's actually nothing to render, and the
  // warnings cause false positives from Lodash primitives when running tests.
  this._vue._renderProxy = this._vue;
  this._nodeIndex = Object.create(null);
  Object.freeze(this);
  // Set root node after freezing Coupler, otherwise it gets vue-ified too.
  this._vue.$data.root = new Node(this, '/');
  this._nodeIndex['/'] = this._root;
};

var prototypeAccessors$1$3 = { _root: { configurable: true },_queryHandlers: { configurable: true } };

prototypeAccessors$1$3._root.get = function () {
  return this._vue.$data.root;
};

prototypeAccessors$1$3._queryHandlers.get = function () {
  return this._vue.$data.queryHandlers;
};

Coupler.prototype.destroy = function destroy () {
  _.forEach(this._queryHandlers, function (queryHandler) {queryHandler.destroy();});
  this._root.unlisten();
  this._vue.$destroy();
};

Coupler.prototype.couple = function couple (path, operation) {
  return this._coupleSegments(splitPath(path, true), operation);
};

Coupler.prototype._coupleSegments = function _coupleSegments (segments, operation) {
  var node;
  var superseded = !operation;
  var ready = false;
  for (var i = 0, list = segments; i < list.length; i += 1) {
    var segment = list[i];

      var child = segment ? node.children && node.children[segment] : this._root;
    if (!child) {
      child = new Node(this, ((node.path === '/' ? '' : node.path) + "/" + segment), node);
      Vue.set(node.children, segment, child);
      this._nodeIndex[child.path] = child;
    }
    superseded = superseded || child.listening;
    ready = ready || child.ready;
    node = child;
  }
  if (operation) {
    node.operations.push(operation);
  } else {
    node.queryCount++;
  }
  if (superseded) {
    if (operation && ready) { this._dispatcher.markReady(operation); }
  } else {
    node.listen();// node will call unlisten() on descendants when ready
  }
};

Coupler.prototype.decouple = function decouple (path, operation) {
  return this._decoupleSegments(splitPath(path, true), operation);
};

Coupler.prototype._decoupleSegments = function _decoupleSegments (segments, operation) {
  var ancestors = [];
  var node;
  for (var i$1 = 0, list = segments; i$1 < list.length; i$1 += 1) {
    var segment = list[i$1];

      node = segment ? node.children && node.children[segment] : this._root;
    if (!node) { break; }
    ancestors.push(node);
  }
  if (!node || !(operation ? node.count : node.queryCount)) {
    throw new Error(("Path not coupled: " + (segments.join('/') || '/')));
  }
  if (operation) {
    _.pull(node.operations, operation);
  } else {
    node.queryCount--;
  }
  if (operation && !node.count) {
    // Ideally, we wouldn't resync the full values here since we probably already have the current
    // value for all children.But making sure that's true is tricky in an async system (what if
    // the node's value changes and the update crosses the 'off' call in transit?) and this
    // situation should be sufficiently rare that the optimization is probably not worth it right
    // now.
    node.listen();
    if (node.listening) { node.unlisten(); }
  }
  if (!node.active) {
    for (var i = ancestors.length - 1; i > 0; i--) {
      node = ancestors[i];
      if (node === this._root || node.active || !_.isEmpty(node.children)) { break; }
      Vue.delete(ancestors[i - 1].children, segments[i]);
      node.ready = undefined;
      delete this._nodeIndex[node.path];
    }
    var path = segments.join('/') || '/';
    this._prunePath(path, this.findCoupledDescendantPaths(path));
  }
};

Coupler.prototype.subscribe = function subscribe (query, operation, keysCallback) {
  var queryHandler = this._queryHandlers[query.toString()];
  if (!queryHandler) {
    queryHandler = new QueryHandler(this, query);
    Vue.set(this._queryHandlers, query.toString(), queryHandler);
  }
  queryHandler.attach(operation, keysCallback);
};

Coupler.prototype.unsubscribe = function unsubscribe (query, operation) {
  var queryHandler = this._queryHandlers[query.toString()];
  if (queryHandler && !queryHandler.detach(operation)) {
    queryHandler.destroy();
    Vue.delete(this._queryHandlers, query.toString());
  }
};

// Return whether the node at path or any ancestors are coupled.
Coupler.prototype.isTrunkCoupled = function isTrunkCoupled (path) {
  var segments = splitPath(path, true);
  var node;
  for (var i = 0, list = segments; i < list.length; i += 1) {
    var segment = list[i];

      node = segment ? node.children && node.children[segment] : this._root;
    if (!node) { return false; }
    if (node.active) { return true; }
  }
  return false;
};

Coupler.prototype.findCoupledDescendantPaths = function findCoupledDescendantPaths (path) {
    var obj;

  var node;
  for (var i = 0, list = splitPath(path, true); i < list.length; i += 1) {
    var segment = list[i];

      node = segment ? node.children && node.children[segment] : this._root;
    if (node && node.active) { return ( obj = {}, obj[path] = node.active, obj ); }
    if (!node) { break; }
  }
  return node && node.collectCoupledDescendantPaths();
};

Coupler.prototype.isSubtreeReady = function isSubtreeReady (path) {
  var node, childSegment;
  function extractChildSegment(match) {
    childSegment = match.slice(1);
    return '';
  }
  while (!(node = this._nodeIndex[path])) {
    path = path.replace(/\/[^/]*$/, extractChildSegment) || '/';
  }
  if (childSegment) { void node.children; }// state an interest in the closest ancestor's children
  while (node) {
    if (node.ready) { return true; }
    node = node.parent;
  }
  return false;
};

Coupler.prototype.isQueryReady = function isQueryReady (query) {
  var queryHandler = this._queryHandlers[query.toString()];
  return queryHandler && queryHandler.ready;
};

Coupler.prototype._queueSnapshotCallback = function _queueSnapshotCallback (callback) {
  this._pendingSnapshotCallbacks.push(callback);
  this._throttled.processPendingSnapshots.call(this);
};

Coupler.prototype._processPendingSnapshots = function _processPendingSnapshots () {
  for (var i = 0, list = this._pendingSnapshotCallbacks; i < list.length; i += 1) {
      var callback = list[i];

      callback();
    }
  // Property is frozen, so we need to splice to empty the array.
  this._pendingSnapshotCallbacks.splice(0, Infinity);
};

Coupler.prototype.throttleSnapshots = function throttleSnapshots (delay) {
  if (delay) {
    this._throttled.processPendingSnapshots = _.throttle(this._processPendingSnapshots, delay);
  } else {
    this._throttled.processPendingSnapshots = this._processPendingSnapshots;
  }
};

Object.defineProperties( Coupler.prototype, prototypeAccessors$1$3 );

var Transaction = function Transaction(ref) {
  this._ref = ref;
  this._outcome = undefined;
  this._values = undefined;
};

var prototypeAccessors$8 = { currentValue: { configurable: true },outcome: { configurable: true },values: { configurable: true } };

prototypeAccessors$8.currentValue.get = function () {return this._ref.value;};
prototypeAccessors$8.outcome.get = function () {return this._outcome;};
prototypeAccessors$8.values.get = function () {return this._values;};

Transaction.prototype._setOutcome = function _setOutcome (value) {
  if (this._outcome) { throw new Error('Transaction already resolved with ' + this._outcome); }
  this._outcome = value;
};

Transaction.prototype.abort = function abort () {
  this._setOutcome('abort');
};

Transaction.prototype.cancel = function cancel () {
  this._setOutcome('cancel');
};

Transaction.prototype.set = function set (value) {
  if (value === undefined) { throw new Error('Invalid argument: undefined'); }
  this._setOutcome('set');
  this._values = {'': value};
};

Transaction.prototype.update = function update (values) {
  if (values === undefined) { throw new Error('Invalid argument: undefined'); }
  if (_.isEmpty(values)) { return this.cancel(); }
  this._setOutcome('update');
  this._values = values;
};

Object.defineProperties( Transaction.prototype, prototypeAccessors$8 );


var Tree = function Tree(truss, rootUrl, bridge, dispatcher) {
  this._truss = truss;
  this._rootUrl = rootUrl;
  this._bridge = bridge;
  this._dispatcher = dispatcher;
  this._firebasePropertyEditAllowed = false;
  this._writeSerial = 0;
  this._localWrites = {};
  this._localWriteTimestamp = null;
  this._initialized = false;
  this._modeler = new Modeler(truss.constructor.VERSION === 'dev');
  this._coupler = new Coupler(
    rootUrl, bridge, dispatcher, this._integrateSnapshot.bind(this), this._prune.bind(this));
  this._vue = new Vue({data: {$root: undefined}});
  Object.seal(this);
  // Call this.init(classes) to complete initialization; we need two phases so that truss can bind
  // the tree into its own accessors prior to defining computed functions, which may try to
  // access the tree root via truss.
};

var prototypeAccessors$1$4 = { root: { configurable: true },truss: { configurable: true } };

prototypeAccessors$1$4.root.get = function () {
  if (!this._vue.$data.$root) {
    this._vue.$data.$root = this._createObject('/');
    this._fixObject(this._vue.$data.$root);
    this._completeCreateObject(this._vue.$data.$root);
    angularProxy.digest();
  }
  return this._vue.$data.$root;
};

prototypeAccessors$1$4.truss.get = function () {
  return this._truss;
};

Tree.prototype.init = function init (classes) {
  if (this._initialized) {
    throw new Error('Data objects already created, too late to mount classes');
  }
  this._initialized = true;
  this._modeler.init(classes, !this._vue.$data.$root);
  var createdObjects = [];
  this._plantPlaceholders(this.root, '/', undefined, createdObjects);
  for (var i = 0, list = createdObjects; i < list.length; i += 1) {
      var object = list[i];

      this._completeCreateObject(object);
    }
};

Tree.prototype.destroy = function destroy () {
  this._coupler.destroy();
  if (this._modeler) { this._modeler.destroy(); }
  this._vue.$destroy();
};

Tree.prototype.connectReference = function connectReference (ref, method) {
    var this$1 = this;

  this._checkHandle(ref);
  var operation = this._dispatcher.createOperation('read', method, ref);
  var unwatch;
  operation._disconnect = this._disconnectReference.bind(this, ref, operation, unwatch);
  this._dispatcher.begin(operation).then(function () {
    if (operation.running && !operation._disconnected) {
      this$1._coupler.couple(ref.path, operation);
      operation._coupled = true;
    }
  }).catch(_.noop);// ignore exception, let onFailure handlers deal with it
  return operation._disconnect;
};

Tree.prototype._disconnectReference = function _disconnectReference (ref, operation, unwatch, error) {
  if (operation._disconnected) { return; }
  operation._disconnected = true;
  if (unwatch) { unwatch(); }
  if (operation._coupled) {
    this._coupler.decouple(ref.path, operation);// will call back to _prune if necessary
    operation._coupled = false;
  }
  this._dispatcher.end(operation, error).catch(_.noop);
};

Tree.prototype.isReferenceReady = function isReferenceReady (ref) {
  this._checkHandle(ref);
  return this._coupler.isSubtreeReady(ref.path);
};

Tree.prototype.connectQuery = function connectQuery (query, keysCallback, method) {
    var this$1 = this;

  this._checkHandle(query);
  var operation = this._dispatcher.createOperation('read', method, query);
  operation._disconnect = this._disconnectQuery.bind(this, query, operation);
  this._dispatcher.begin(operation).then(function () {
    if (operation.running && !operation._disconnected) {
      this$1._coupler.subscribe(query, operation, keysCallback);
      operation._coupled = true;
    }
  }).catch(_.noop);// ignore exception, let onFailure handlers deal with it
  return operation._disconnect;
};

Tree.prototype._disconnectQuery = function _disconnectQuery (query, operation, error) {
  if (operation._disconnected) { return; }
  operation._disconnected = true;
  if (operation._coupled) {
    this._coupler.unsubscribe(query, operation);// will call back to _prune if necessary
    operation._coupled = false;
  }
  this._dispatcher.end(operation, error).catch(_.noop);
};

Tree.prototype.isQueryReady = function isQueryReady (query) {
  return this._coupler.isQueryReady(query);
};

Tree.prototype._checkHandle = function _checkHandle (handle) {
  if (!handle.belongsTo(this._truss)) {
    throw new Error('Reference belongs to another Truss instance');
  }
};

Tree.prototype.throttleRemoteDataUpdates = function throttleRemoteDataUpdates (delay) {
  this._coupler.throttleSnapshots(delay);
};

Tree.prototype.update = function update (ref, method, values) {
    var this$1 = this;

  values = _.mapValues(values, function (value) { return escapeKeys(value); });
  var numValues = _.size(values);
  if (!numValues) { return Promise.resolve(); }
  if (method === 'update' || method === 'override') {
    checkUpdateHasOnlyDescendantsWithNoOverlap(ref.path, values);
  }
  if (this._applyLocalWrite(values, method === 'override')) { return Promise.resolve(); }
  var pathPrefix = extractCommonPathPrefix(values);
  relativizePaths(pathPrefix, values);
  if (pathPrefix !== ref.path) { ref = new Reference(ref._tree, pathPrefix, ref._annotations); }
  var url = this._rootUrl + pathPrefix;
  var writeSerial = this._writeSerial;
  var set = numValues === 1;
  var operand = set ? values[''] : values;
  return this._dispatcher.execute('write', set ? 'set' : 'update', ref, operand, function () {
    var promise = this$1._bridge[set ? 'set' : 'update'](url, operand, writeSerial);
    return promise.catch(function (e) {
      if (!e.immediateFailure) { return Promise.reject(e); }
      return promiseFinally(this$1._repair(ref, values), function () { return Promise.reject(e); });
    });
  });
};

Tree.prototype.commit = function commit (ref, updateFunction) {
    var this$1 = this;

  var tries = 0;
  updateFunction = wrapPromiseCallback(updateFunction);

  var attemptTransaction = function () {
    if (tries++ >= 25) {
      return Promise.reject(new Error('Transaction needed too many retries, giving up'));
    }
    var txn = new Transaction(ref);
    var oldValue;
    // Ensure that Vue's watcher queue gets emptied and computed properties are up to date before
    // running the updateFunction.
    return Vue.nextTick().then(function () {
      oldValue = toFirebaseJson(txn.currentValue);
      return updateFunction(txn);
    }).then(function () {
        var obj;

      if (!_.isEqual(oldValue, toFirebaseJson(txn.currentValue))) { return attemptTransaction(); }
      if (txn.outcome === 'abort') { return txn; }// early return to save time
      var values = _.mapValues(txn.values, function (value) { return escapeKeys(value); });
      switch (txn.outcome) {
        case 'cancel':
          break;
        case 'set':
          if (this$1._applyLocalWrite(( obj = {}, obj[ref.path] = values[''], obj ))) { return Promise.resolve(); }
          break;
        case 'update':
          checkUpdateHasOnlyDescendantsWithNoOverlap(ref.path, values);
          if (this$1._applyLocalWrite(values)) { return Promise.resolve(); }
          relativizePaths(ref.path, values);
          break;
        default:
          throw new Error('Invalid transaction outcome: ' + (txn.outcome || 'none'));
      }
      return this$1._bridge.transaction(
        this$1._rootUrl + ref.path, oldValue, values, this$1._writeSerial
      ).then(function (result) {
        _.forEach(result.snapshots, function (snapshot) { return this$1._integrateSnapshot(snapshot); });
        return result.committed ? txn : attemptTransaction();
      }, function (e) {
        if (e.immediateFailure && (txn.outcome === 'set' || txn.outcome === 'update')) {
          return promiseFinally(this$1._repair(ref, values), function () { return Promise.reject(e); });
        }
        return Promise.reject(e);
      });
    });
  };

  return this._truss.peek(ref, function () {
    return this$1._dispatcher.execute('write', 'commit', ref, undefined, attemptTransaction);
  });
};

Tree.prototype._repair = function _repair (ref, values) {
    var this$1 = this;

  // If a write fails early -- that is, before it gets applied to the Firebase client's local
  // tree -- then we need to repair our own local tree manually since Firebase won't send events
  // to unwind the change.This should be very rare since it's always due to a developer mistake
  // so we don't need to be particularly efficient.
  var basePath = ref.path;
  var paths = _(values).keys().flatMap(function (key) {
    var path = basePath;
    if (key) { path = joinPath(path, key); }
    return _.keys(this$1._coupler.findCoupledDescendantPaths(path));
  }).value();
  return Promise.all(_.map(paths, function (path) {
    return this$1._bridge.once(this$1._rootUrl + path).then(function (snap) {
      this$1._integrateSnapshot(snap);
    });
  }));
};

Tree.prototype._applyLocalWrite = function _applyLocalWrite (values, override) {
    var this$1 = this;

  // TODO: correctly apply local writes that impact queries.Currently, a local write will update
  // any objects currently selected by a query, but won't add or remove results.
  this._writeSerial++;
  this._localWriteTimestamp = this._truss.now;
  var createdObjects = [];
  var numLocal = 0;
  _.forEach(values, function (value, path) {
      var obj;

    var local = this$1._modeler.isLocal(path, value);
    if (local) { numLocal++; }
    var coupledDescendantPaths =
      local ? ( obj = {}, obj[path] = true, obj ) : this$1._coupler.findCoupledDescendantPaths(path);
    if (_.isEmpty(coupledDescendantPaths)) { return; }
    var offset = (path === '/' ? 0 : path.length) + 1;
    for (var descendantPath in coupledDescendantPaths) {
      var subPath = descendantPath.slice(offset);
      var subValue = value;
      if (subPath && value !== null && value !== undefined) {
        for (var i = 0, list = splitPath(subPath); i < list.length; i += 1) {
          var segment = list[i];

            subValue = subValue.$data[segment];
          if (subValue === undefined) { break; }
        }
      }
      if (_.isNil(subValue)) {
        this$1._prune(descendantPath);
      } else {
        var key = _.last(splitPath(descendantPath));
        this$1._plantValue(
          descendantPath, key, subValue,
          this$1._scaffoldAncestors(descendantPath, false, createdObjects), false, override, local,
          createdObjects
        );
      }
      if (!override && !local) { this$1._localWrites[descendantPath] = this$1._writeSerial; }
    }
  });
  for (var i = 0, list = createdObjects; i < list.length; i += 1) {
      var object = list[i];

      this._completeCreateObject(object);
    }
  if (numLocal && numLocal < _.size(values)) {
    throw new Error('Write on a mix of local and remote tree paths.');
  }
  return override || !!numLocal;
};

/**
 * Creates a Truss object and sets all its basic properties: path segment variables, user-defined
 * properties, and computed properties.The latter two will be enumerable so that Vue will pick
 * them up and make the reactive, so you should call _completeCreateObject once it's done so and
 * before any Firebase properties are added.
 */
Tree.prototype._createObject = function _createObject (path, parent) {
  if (!this._initialized && path !== '/') { this.init(); }
  var properties = {
    // We want Vue to wrap this; we'll make it non-enumerable in _fixObject.
    $parent: {value: parent, configurable: true, enumerable: true},
    $path: {value: path}
  };
  if (path === '/') { properties.$truss = {value: this._truss}; }

  var object = this._modeler.createObject(path, properties);
  Object.defineProperties(object, properties);
  return object;
};

// To be called on the result of _createObject after it's been inserted into the _vue hierarchy
// and Vue has had a chance to initialize it.
Tree.prototype._fixObject = function _fixObject (object) {
  for (var i = 0, list = Object.getOwnPropertyNames(object); i < list.length; i += 1) {
    var name = list[i];

      var descriptor = Object.getOwnPropertyDescriptor(object, name);
    if (descriptor.configurable && descriptor.enumerable) {
      descriptor.enumerable = false;
      if (_.startsWith(name, '$')) { descriptor.configurable = false; }
      Object.defineProperty(object, name, descriptor);
    }
  }
};

// To be called on the result of _createObject after _fixObject, and after any additional Firebase
// properties have been set, to run initialiers.
Tree.prototype._completeCreateObject = function _completeCreateObject (object) {
  if (object.hasOwnProperty('$$initializers')) {
    for (var i = 0, list = object.$$initializers; i < list.length; i += 1) {
        var fn = list[i];

        fn(this._vue);
      }
    delete object.$$initializers;
  }
};

Tree.prototype._destroyObject = function _destroyObject (object) {
  if (!(object && object.$truss) || object.$destroyed) { return; }
  this._modeler.destroyObject(object);
  // Normally we'd only destroy enumerable children, which are the Firebase properties.However,
  // clients have the option of creating hidden placeholders, so we need to scan non-enumerable
  // properties as well.To distinguish such placeholders from the myriad other non-enumerable
  // properties (that lead all over tree, e.g. $parent), we check that the property's parent is
  // ourselves before destroying.
  for (var i = 0, list = Object.getOwnPropertyNames(object.$data); i < list.length; i += 1) {
    var key = list[i];

      var child = object.$data[key];
    if (child && child.$parent === object) { this._destroyObject(child); }
  }
};

Tree.prototype._integrateSnapshot = function _integrateSnapshot (snap) {
    var this$1 = this;

  _.forEach(this._localWrites, function (writeSerial, path) {
    if (snap.writeSerial >= writeSerial) { delete this$1._localWrites[path]; }
  });
  if (snap.exists) {
    var createdObjects = [];
    var parent = this._scaffoldAncestors(snap.path, true, createdObjects);
    if (parent) {
      this._plantValue(
        snap.path, snap.key, snap.value, parent, true, false, false, createdObjects);
    }
    for (var i = 0, list = createdObjects; i < list.length; i += 1) {
        var object = list[i];

        this._completeCreateObject(object);
      }
  } else {
    this._prune(snap.path, null, true);
  }
};

Tree.prototype._scaffoldAncestors = function _scaffoldAncestors (path, remoteWrite, createdObjects) {
  var object;
  var segments = _.dropRight(splitPath(path, true));
  var ancestorPath = '/';
  for (var i = 0; i < segments.length; i++) {
    var segment = segments[i];
    var key = unescapeKey(segment);
    var child = segment ? object.$data[key] : this.root;
    if (segment) { ancestorPath += (ancestorPath === '/' ? '' : '/') + segment; }
    if (child) {
      if (remoteWrite && this._localWrites[ancestorPath]) { return; }
    } else {
      child = this._plantValue(
        ancestorPath, key, {}, object, remoteWrite, false, false, createdObjects);
      if (!child) { return; }
    }
    object = child;
  }
  return object;
};

Tree.prototype._plantValue = function _plantValue (path, key, value, parent, remoteWrite, override, local, createdObjects) {
    var this$1 = this;

  if (remoteWrite && _.isNil(value)) {
    throw new Error(("Snapshot includes invalid value at " + path + ": " + value));
  }
  if (remoteWrite && this._localWrites[path || '/']) { return; }
  if (_.isEqual(value, SERVER_TIMESTAMP)) { value = this._localWriteTimestamp; }
  var object = parent.$data[key];
  if (!_.isArray(value) && !(local ? _.isPlainObject(value) : _.isObject(value))) {
    this._destroyObject(object);
    if (!local && _.isNil(value)) {
      this._deleteFirebaseProperty(parent, key);
    } else {
      this._setFirebaseProperty(parent, key, value);
    }
    return;
  }
  var objectCreated = false;
  if (!_.isObject(object)) {
    // Need to pre-set the property, so that if the child object attempts to watch any of its own
    // properties while being created the $$touchThis method has something to add a dependency on
    // as the object's own properties won't be made reactive until *after* it's been created.
    this._setFirebaseProperty(parent, key, null);
    object = this._createObject(path, parent);
    this._setFirebaseProperty(parent, key, object, object.$hidden);
    this._fixObject(object);
    createdObjects.push(object);
    objectCreated = true;
  }
  if (override) {
    Object.defineProperty(object, '$overridden', {get: _.constant(true), configurable: true});
  } else if (object.$overridden) {
    delete object.$overridden;
  }
  // Plant hidden placeholders first, so their computed watchers will have a similar precedence to
  // the parent object, and the parent object's other children will get computed first.This can
  // optimize updates when parts of a complex model are broken out into hidden sub-models, and
  // shouldn't risk being overwritten by actual Firebase data since that will rarely (never?) be
  // hidden.
  if (objectCreated) { this._plantPlaceholders(object, path, true, createdObjects); }
  _.forEach(value, function (item, escapedChildKey) {
    this$1._plantValue(
      joinPath(path, escapedChildKey), unescapeKey(escapedChildKey), item, object, remoteWrite,
      override, local, createdObjects
    );
  });
  if (objectCreated) {
    this._plantPlaceholders(object, path, false, createdObjects);
  } else {
    _.forEach(object.$data, function (item, childKey) {
      var escapedChildKey = escapeKey(childKey);
      if (!value.hasOwnProperty(escapedChildKey)) {
        this$1._prune(joinPath(path, escapedChildKey), null, remoteWrite);
      }
    });
  }
  return object;
};

Tree.prototype._plantPlaceholders = function _plantPlaceholders (object, path, hidden, createdObjects) {
    var this$1 = this;

  this._modeler.forEachPlaceholderChild(path, function (mount) {
    if (hidden !== undefined && hidden !== !!mount.hidden) { return; }
    var key = unescapeKey(mount.escapedKey);
    if (!object.$data.hasOwnProperty(key)) {
      this$1._plantValue(
        joinPath(path, mount.escapedKey), key, mount.placeholder, object, false, false, false,
        createdObjects);
    }
  });
};

Tree.prototype._prune = function _prune (path, lockedDescendantPaths, remoteWrite) {
  lockedDescendantPaths = lockedDescendantPaths || {};
  var object = this.getObject(path);
  if (object === undefined) { return; }
  if (remoteWrite && this._avoidLocalWritePaths(path, lockedDescendantPaths)) { return; }
  if (!(_.isEmpty(lockedDescendantPaths) && this._pruneAncestors(path, object)) &&
      _.isObject(object)) {
    // The target object is a placeholder, and all ancestors are placeholders or otherwise needed
    // as well, so we can't delete it.Instead, dive into its descendants to delete what we can.
    this._pruneDescendants(object, lockedDescendantPaths);
  }
};

Tree.prototype._avoidLocalWritePaths = function _avoidLocalWritePaths (path, lockedDescendantPaths) {
  for (var localWritePath in this._localWrites) {
    if (!this._localWrites.hasOwnProperty(localWritePath)) { continue; }
    if (path === localWritePath || localWritePath === '/' ||
        _.startsWith(path, localWritePath + '/')) { return true; }
    if (path === '/' || _.startsWith(localWritePath, path + '/')) {
      var segments = splitPath(localWritePath, true);
      for (var i = segments.length; i > 0; i--) {
        var subPath = segments.slice(0, i).join('/');
        var active = i === segments.length;
        if (lockedDescendantPaths[subPath] || lockedDescendantPaths[subPath] === active) { break; }
        lockedDescendantPaths[subPath] = active;
        if (subPath === path) { break; }
      }
    }
  }
};

Tree.prototype._pruneAncestors = function _pruneAncestors (targetPath, targetObject) {
  // Destroy the child (unless it's a placeholder that's still needed) and any ancestors that
  // are no longer needed to keep this child rooted, and have no other reason to exist.
  var deleted = false;
  var object = targetObject;
  // The target object may be a primitive, in which case it won't have $path, $parent and $key
  // properties.In that case, use the target path to figure those out instead.Note that all
  // ancestors of the target object will necessarily not be primitives and will have those
  // properties.
  var targetKey;
  var targetParentPath = targetPath.replace(/\/[^/]+$/, function (match) {
    targetKey = unescapeKey(match.slice(1));
    return '';
  });
  while (object !== undefined && object !== this.root) {
    var parent =
      object && object.$parent || object === targetObject && this.getObject(targetParentPath);
    if (!this._modeler.isPlaceholder(object && object.$path || targetPath)) {
      var ghostObjects = deleted ? null : [targetObject];
      if (!this._holdsConcreteData(object, ghostObjects)) {
        deleted = true;
        this._deleteFirebaseProperty(
          parent, object && object.$key || object === targetObject && targetKey);
      }
    }
    object = parent;
  }
  return deleted;
};

Tree.prototype._holdsConcreteData = function _holdsConcreteData (object, ghostObjects) {
    var this$1 = this;

  if (_.isNil(object)) { return false; }
  if (ghostObjects && _.includes(ghostObjects, object)) { return false; }
  if (!_.isObject(object) || !object.$truss) { return true; }
  return _.some(object.$data, function (value) { return this$1._holdsConcreteData(value, ghostObjects); });
};

Tree.prototype._pruneDescendants = function _pruneDescendants (object, lockedDescendantPaths) {
    var this$1 = this;

  if (lockedDescendantPaths[object.$path]) { return true; }
  if (object.$overridden) { delete object.$overridden; }
  var coupledDescendantFound = false;
  _.forEach(object.$data, function (value, key) {
    var shouldDelete = true;
    var valueLocked;
    if (lockedDescendantPaths[joinPath(object.$path, escapeKey(key))]) {
      shouldDelete = false;
      valueLocked = true;
    } else if (!_.isNil(value) && value.$truss) {
      var placeholder = this$1._modeler.isPlaceholder(value.$path);
      if (placeholder || _.has(lockedDescendantPaths, value.$path)) {
        valueLocked = this$1._pruneDescendants(value, lockedDescendantPaths);
        shouldDelete = !placeholder && !valueLocked;
      }
    }
    if (shouldDelete) { this$1._deleteFirebaseProperty(object, key); }
    coupledDescendantFound = coupledDescendantFound || valueLocked;
  });
  return coupledDescendantFound;
};

Tree.prototype.getObject = function getObject (path) {
  var segments = splitPath(path);
  var object;
  for (var i = 0, list = segments; i < list.length; i += 1) {
    var segment = list[i];

      object = segment ? object.$data[segment] : this.root;
    if (object === undefined) { return; }
  }
  return object;
};

Tree.prototype._getFirebasePropertyDescriptor = function _getFirebasePropertyDescriptor (object, data, key) {
  var descriptor = Object.getOwnPropertyDescriptor(data, key);
  if (descriptor) {
    if (!descriptor.enumerable) {
      var child = data[key];
      if (!child || child.$parent !== object) {
        throw new Error(
          "Key conflict between Firebase and instance or computed properties at " +
          (object.$path) + ": " + key);
      }
    }
    if (!descriptor.get || !descriptor.set) {
      throw new Error(("Unbound property at " + (object.$path) + ": " + key));
    }
  } else if (key in data) {
    throw new Error(
      ("Key conflict between Firebase and inherited property at " + (object.$path) + ": " + key));
  }
  return descriptor;
};

Tree.prototype._setFirebaseProperty = function _setFirebaseProperty (object, key, value, hidden) {
  var data = object.hasOwnProperty('$data') ? object.$data : object;
  var descriptor = this._getFirebasePropertyDescriptor(object, data, key);
  if (descriptor) {
    if (hidden) {
      // Redefine property as hidden after it's been created, since we usually don't know whether
      // it should be hidden until too late.This is a one-way deal -- you can't unhide a
      // property later, but that's fine for our purposes.
      Object.defineProperty(data, key, {
        get: descriptor.get, set: descriptor.set, configurable: true, enumerable: false
      });
    }
    if (data[key] === value) { return; }
    this._firebasePropertyEditAllowed = true;
    data[key] = value;
    this._firebasePropertyEditAllowed = false;
  } else {
    Vue.set(data, key, value);
    descriptor = Object.getOwnPropertyDescriptor(data, key);
    Object.defineProperty(data, key, {
      get: descriptor.get, set: this._overwriteFirebaseProperty.bind(this, descriptor, key),
      configurable: true, enumerable: !hidden
    });
  }
  angularProxy.digest();
};

Tree.prototype._overwriteFirebaseProperty = function _overwriteFirebaseProperty (descriptor, key, newValue) {
  if (!this._firebasePropertyEditAllowed) {
    var e = new Error(("Firebase data cannot be mutated directly: " + key));
    e.trussCode = 'firebase_overwrite';
    throw e;
  }
  descriptor.set.call(this, newValue);
};

Tree.prototype._deleteFirebaseProperty = function _deleteFirebaseProperty (object, key) {
  var data = object.hasOwnProperty('$data') ? object.$data : object;
  // Make sure it's actually a Firebase property.
  this._getFirebasePropertyDescriptor(object, data, key);
  this._destroyObject(data[key]);
  Vue.delete(data, key);
  angularProxy.digest();
};

Tree.prototype.checkVueObject = function checkVueObject (object, path) {
  this._modeler.checkVueObject(object, path);
};

Object.defineProperties( Tree.prototype, prototypeAccessors$1$4 );


function checkUpdateHasOnlyDescendantsWithNoOverlap(rootPath, values) {
  // First, check all paths for correctness and absolutize them, since there could be a mix of
  // absolute paths and relative keys.
  _.forEach(_.keys(values), function (path) {
    if (path.charAt(0) === '/') {
      if (!(path === rootPath || rootPath === '/' ||
            _.startsWith(path, rootPath + '/') && path.length > rootPath.length + 1)) {
        throw new Error(("Update item is not a descendant of target ref: " + path));
      }
    } else {
      if (_.includes(path, '/')) {
        throw new Error(("Update item deep path must be absolute, taken from a reference: " + path));
      }
      var absolutePath = joinPath(rootPath, escapeKey(path));
      if (values.hasOwnProperty(absolutePath)) {
        throw new Error(("Update items overlap: " + path + " and " + absolutePath));
      }
      values[absolutePath] = values[path];
      delete values[path];
    }
  });
  // Then check for overlaps;
  var allPaths = _(values).keys().map(function (path) { return joinPath(path, ''); }).sortBy('length').value();
  _.forEach(values, function (value, path) {
    for (var i = 0, list = allPaths; i < list.length; i += 1) {
      var otherPath = list[i];

      if (otherPath.length > path.length) { break; }
      if (path !== otherPath && _.startsWith(path, otherPath)) {
        throw new Error(("Update items overlap: " + otherPath + " and " + path));
      }
    }
  });
}

function extractCommonPathPrefix(values) {
  var prefixSegments;
  _.forEach(values, function (value, path) {
    var segments = path === '/' ? [''] : splitPath(path, true);
    if (prefixSegments) {
      var firstMismatchIndex = 0;
      var maxIndex = Math.min(prefixSegments.length, segments.length);
      while (firstMismatchIndex < maxIndex &&
             prefixSegments[firstMismatchIndex] === segments[firstMismatchIndex]) {
        firstMismatchIndex++;
      }
      prefixSegments = prefixSegments.slice(0, firstMismatchIndex);
      if (!prefixSegments.length) { return false; }
    } else {
      prefixSegments = segments;
    }
  });
  return prefixSegments.length === 1 ? '/' : prefixSegments.join('/');
}

function relativizePaths(rootPath, values) {
  var offset = rootPath === '/' ? 1 : rootPath.length + 1;
  _.forEach(_.keys(values), function (path) {
    values[path.slice(offset)] = values[path];
    delete values[path];
  });
}

function toFirebaseJson(object) {
  if (!_.isObject(object)) { return object; }
  var result = {};
  var data = object.$data;
  for (var key in data) {
    if (data.hasOwnProperty(key)) { result[escapeKey(key)] = toFirebaseJson(data[key]); }
  }
  return result;
}

var bridge, logging;
var workerFunctions = {};
// This version is filled in by the build, don't reformat the line.
var VERSION = '4.1.2';


var Truss = function Truss(rootUrl) {
  // TODO: allow rootUrl to be a test database object for testing
  if (!bridge) {
    throw new Error('Truss worker not connected, please call Truss.connectWorker first');
  }
  this._rootUrl = rootUrl.replace(/\/$/, '');
  this._keyGenerator = new KeyGenerator();
  this._dispatcher = new Dispatcher(bridge);
  this._vue = new Vue();

  bridge.trackServer(this._rootUrl);
  this._tree = new Tree(this, this._rootUrl, bridge, this._dispatcher);
  this._metaTree = new MetaTree(this._rootUrl, this._tree, bridge, this._dispatcher);

  Object.freeze(this);
};

var prototypeAccessors$9 = { meta: { configurable: true },store: { configurable: true },now: { configurable: true },SERVER_TIMESTAMP: { configurable: true },VERSION: { configurable: true },FIREBASE_SDK_VERSION: { configurable: true } };
var staticAccessors = { computedPropertyStats: { configurable: true },worker: { configurable: true } };

prototypeAccessors$9.meta.get = function () {return this._metaTree.root;};
prototypeAccessors$9.store.get = function () {return this._tree.root;};

/**
 * Mount a set of classes against the datastore structure.Must be called at most once, and
 * cannot be called once any data has been loaded into the tree.
 * @param classes {Array<Function> | Object<Function>} A list of the classes to map onto the
 *  datastore structure.Each class must have a static $trussMount property that is a
 *  (wildcarded) unescaped datastore path, or an options object
 *  {path: string, placeholder: object}, or an array of either.If the list is an object then
 *  the keys serve as default option-less $trussMount paths for classes that don't define an
 *  explicit $trussMount.
 */
Truss.prototype.mount = function mount (classes) {
  this._tree.init(classes);
};

Truss.prototype.destroy = function destroy () {
  this._vue.$destroy();
  this._tree.destroy();
  this._metaTree.destroy();
};

prototypeAccessors$9.now.get = function () {return Date.now() + this.meta.timeOffset;};
Truss.prototype.newKey = function newKey () {return this._keyGenerator.generateUniqueKey(this.now);};

Truss.prototype.authenticate = function authenticate (token) {
  return this._metaTree.authenticate(token);
};

Truss.prototype.unauthenticate = function unauthenticate () {
  return this._metaTree.unauthenticate();
};

Truss.prototype.intercept = function intercept (actionType, callbacks) {
  return this._dispatcher.intercept(actionType, callbacks);
};

// connections are {key: Query | Object | fn() -> (Query | Object)}
Truss.prototype.connect = function connect (scope, connections) {
  if (!connections) {
    connections = scope;
    scope = undefined;
  }
  if (connections instanceof Handle) { connections = {_: connections}; }
  return new Connector(scope, connections, this._tree, 'connect');
};

// target is Reference, Query, or connection Object like above
Truss.prototype.peek = function peek (target, callback) {
    var this$1 = this;

  callback = wrapPromiseCallback(callback || _.identity);
  var cleanup, cancel;
  var promise = Promise.resolve().then(function () { return new Promise(function (resolve, reject) {
    var scope = {};
    var callbackPromise;

    var connector = new Connector(scope, {result: target}, this$1._tree, 'peek');

    var unintercept = this$1.intercept('peek', {onFailure: function (op) {
      function match(descriptor) {
        if (!descriptor) { return; }
        if (descriptor instanceof Handle) { return op.target.isEqual(descriptor); }
        return _.some(descriptor, function (value) { return match(value); });
      }
      if (match(connector.at)) {
        reject(op.error);
        cleanup();
      }
    }});

    var unobserve = this$1.observe(function () { return connector.ready; }, function (ready) {
      if (!ready) { return; }
      unobserve();
      unobserve = null;
      callbackPromise = promiseFinally(
        callback(scope.result), function () {angularProxy.digest(); callbackPromise = null; cleanup();}
      ).then(function (result) {resolve(result);}, function (error) {reject(error);});
    });

    cleanup = function () {
      if (unobserve) {unobserve(); unobserve = null;}
      if (unintercept) {unintercept(); unintercept = null;}
      if (connector) {connector.destroy(); connector = null;}
      if (callbackPromise && callbackPromise.cancel) { callbackPromise.cancel(); }
    };

    cancel = function () {
      reject(new Error('Canceled'));
      cleanup();
    };
  }); });
  return promiseCancel(promise, cancel);
};

Truss.prototype.observe = function observe (subjectFn, callbackFn, options) {
  var usePreciseDefaults = _.isObject(options && options.precise);
  var numCallbacks = 0;
  var oldValueClone;
  if (usePreciseDefaults) {
    oldValueClone = options.deep ? _.cloneDeep(options.precise) : _.clone(options.precise);
  }

  var unwatch = this._vue.$watch(subjectFn, function (newValue, oldValue) {
    if (options && options.precise) {
      var newValueClone = usePreciseDefaults ?
        (options.deep ?
          _.defaultsDeep({}, newValue, options.precise) :
          _.defaults({}, newValue, options.precise)) :
        (options.deep ? _.cloneDeep(newValue) : _.clone(newValue));
      if (_.isEqual(newValueClone, oldValueClone)) { return; }
      oldValueClone = newValueClone;
    }
    numCallbacks++;
    if (!unwatch) {
      // Delay the immediate callback until we've had a chance to return the unwatch function.
      Promise.resolve().then(function () {
        if (numCallbacks > 1) { return; }
        callbackFn(newValue, oldValue);
        // No need to digest since under Angular we'll be using $q as Promise.
      });
    } else {
      callbackFn(newValue, oldValue);
      angularProxy.digest();
    }
  }, {immediate: true, deep: options && options.deep});

  if (options && options.scope) { options.scope.$on('$destroy', unwatch); }
  return unwatch;
};

Truss.prototype.when = function when (expression, options) {
    var this$1 = this;

  var cleanup, timeoutHandle;
  var promise = new Promise(function (resolve, reject) {
    var unobserve = this$1.observe(expression, function (value) {
      if (!value) { return; }
      // Wait for computed properties to settle and double-check.
      Vue.nextTick(function () {
        value = expression();
        if (!value) { return; }
        resolve(value);
        cleanup();
      });
    });
    if (_.has(options, 'timeout')) {
      timeoutHandle = setTimeout(function () {
        timeoutHandle = null;
        reject(new Error(options.timeoutMessage || 'Timeout'));
        cleanup();
      }, options.timeout);
    }
    cleanup = function () {
      if (unobserve) {unobserve(); unobserve = null;}
      if (timeoutHandle) {clearTimeout(timeoutHandle); timeoutHandle = null;}
      reject(new Error('Canceled'));
    };
  });
  promise = promiseCancel(promiseFinally(promise, cleanup), cleanup);
  if (options && options.scope) { options.scope.$on('$destroy', function () {promise.cancel();}); }
  return promise;
};

Truss.prototype.nextTick = function nextTick () {
  var cleanup;
  var promise = new Promise(function (resolve, reject) {
    Vue.nextTick(resolve);
    cleanup = function () {
      reject(new Error('Canceled'));
    };
  });
  promise = promiseCancel(promise, cleanup);
  return promise;
};

Truss.prototype.throttleRemoteDataUpdates = function throttleRemoteDataUpdates (delay) {
  this._tree.throttleRemoteDataUpdates(delay);
};

Truss.prototype.checkObjectsForRogueProperties = function checkObjectsForRogueProperties () {
  this._tree.checkVueObject(this._tree.root, '/');
};

staticAccessors.computedPropertyStats.get = function () {
  return stats;
};

Truss.connectWorker = function connectWorker (webWorker, config) {
  if (bridge) { throw new Error('Worker already connected'); }
  if (_.isString(webWorker)) {
    var Worker = window.SharedWorker || window.Worker;
    if (!Worker) { throw new Error('Browser does not implement Web Workers'); }
    webWorker = new Worker(webWorker);
  }
  bridge = new Bridge(webWorker);
  if (logging) { bridge.enableLogging(logging); }
  return bridge.init(webWorker, config).then(
    function (ref) {
        var exposedFunctionNames = ref.exposedFunctionNames;
        var firebaseSdkVersion = ref.firebaseSdkVersion;

      Object.defineProperty(Truss, 'FIREBASE_SDK_VERSION', {value: firebaseSdkVersion});
      for (var i = 0, list = exposedFunctionNames; i < list.length; i += 1) {
        var name = list[i];

          Truss.worker[name] = bridge.bindExposedFunction(name);
      }
    }
  );
};

staticAccessors.worker.get = function () {return workerFunctions;};
Truss.preExpose = function preExpose (functionName) {
  Truss.worker[functionName] = bridge.bindExposedFunction(functionName);
};

Truss.bounceConnection = function bounceConnection () {return bridge.bounceConnection();};
Truss.suspend = function suspend () {return bridge.suspend();};
Truss.debugPermissionDeniedErrors = function debugPermissionDeniedErrors (simulatedTokenGenerator, maxSimulationDuration, callFilter) {
  return bridge.debugPermissionDeniedErrors(
    simulatedTokenGenerator, maxSimulationDuration, callFilter);
};

Truss.debounceAngularDigest = function debounceAngularDigest (wait) {
  angularProxy.debounceDigest(wait);
};

Truss.escapeKey = function escapeKey$1 (key) {return escapeKey(key);};
Truss.unescapeKey = function unescapeKey$1 (escapedKey) {return unescapeKey(escapedKey);};

Truss.enableLogging = function enableLogging (fn) {
  logging = fn;
  if (bridge) { bridge.enableLogging(fn); }
};

// Duplicate static constants on instance for convenience.
prototypeAccessors$9.SERVER_TIMESTAMP.get = function () {return Truss.SERVER_TIMESTAMP;};
prototypeAccessors$9.VERSION.get = function () {return Truss.VERSION;};
prototypeAccessors$9.FIREBASE_SDK_VERSION.get = function () {return Truss.FIREBASE_SDK_VERSION;};

Object.defineProperties( Truss.prototype, prototypeAccessors$9 );
Object.defineProperties( Truss, staticAccessors );

Object.defineProperties(Truss, {
  SERVER_TIMESTAMP: {value: SERVER_TIMESTAMP},
  VERSION: {value: VERSION},

  ComponentPlugin: {value: {
    install: function install(Vue2, pluginOptions) {
      if (Vue !== Vue2) { throw new Error('Multiple versions of Vue detected'); }
      if (!pluginOptions.truss) {
        throw new Error('Need to pass `truss` instance as an option to use the ComponentPlugin');
      }
      var prototypeExtension = {
        $truss: {value: pluginOptions.truss},
        $destroyed: {get: function get() {return this._isBeingDestroyed || this._isDestroyed;}},
        $$touchThis: {value: function value() {if (this.__ob__) { this.__ob__.dep.depend(); }}}
      };
      var conflictingKeys = _(prototypeExtension).keys()
        .union(_.keys(BaseValue.prototype)).intersection(_.keys(Vue.prototype)).value();
      if (conflictingKeys.length) {
        throw new Error(
          'Truss extension properties conflict with Vue properties: ' + conflictingKeys.join(', '));
      }
      Object.defineProperties(Vue.prototype, prototypeExtension);
      copyPrototype(BaseValue, Vue);
      Vue.mixin({
        destroyed: function destroyed() {
          if (_.has(this, '$$finalizers')) {
            // Some finalizers remove themselves from the array, so clone it before iterating.
            for (var i = 0, list = _.clone(this.$$finalizers); i < list.length; i += 1) {
              var fn = list[i];

              fn();
            }
          }
        }
      });
    }
  }}
});

angularProxy.defineModule(Truss);

export default Truss;

//# sourceMappingURL=firetruss.es2015.js.map