text: 'use strict';
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var Websocket = require('faye-websocket');
  var util = require('@firebase/util');
  var tslib = require('tslib');
  var logger$1 = require('@firebase/logger');
  var app = require('@firebase/app');
  var component = require('@firebase/component');
  
  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
  
  var Websocket__default = /*#__PURE__*/_interopDefaultLegacy(Websocket);
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var PROTOCOL_VERSION = '5';
  var VERSION_PARAM = 'v';
  var TRANSPORT_SESSION_PARAM = 's';
  var REFERER_PARAM = 'r';
  var FORGE_REF = 'f';
  // Matches console.firebase.google.com, firebase-console-*.corp.google.com and
  // firebase.corp.google.com
  var FORGE_DOMAIN_RE = /(console\.firebase|firebase-console-\w+\.corp|firebase\.corp)\.google\.com/;
  var LAST_SESSION_PARAM = 'ls';
  var APPLICATION_ID_PARAM = 'p';
  var APP_CHECK_TOKEN_PARAM = 'ac';
  var WEBSOCKET = 'websocket';
  var LONG_POLLING = 'long_polling';
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Wraps a DOM Storage object and:
   * - automatically encode objects as JSON strings before storing them to allow us to store arbitrary types.
   * - prefixes names with "firebase:" to avoid collisions with app data.
   *
   * We automatically (see storage.js) create two such wrappers, one for sessionStorage,
   * and one for localStorage.
   *
   */
  var DOMStorageWrapper = /** @class */ (function () {
      /**
       * @param domStorage_ - The underlying storage object (e.g. localStorage or sessionStorage)
       */
      function DOMStorageWrapper(domStorage_) {
          this.domStorage_ = domStorage_;
          // Use a prefix to avoid collisions with other stuff saved by the app.
          this.prefix_ = 'firebase:';
      }
      /**
       * @param key - The key to save the value under
       * @param value - The value being stored, or null to remove the key.
       */
      DOMStorageWrapper.prototype.set = function (key, value) {
          if (value == null) {
              this.domStorage_.removeItem(this.prefixedName_(key));
          }
          else {
              this.domStorage_.setItem(this.prefixedName_(key), util.stringify(value));
          }
      };
      /**
       * @returns The value that was stored under this key, or null
       */
      DOMStorageWrapper.prototype.get = function (key) {
          var storedVal = this.domStorage_.getItem(this.prefixedName_(key));
          if (storedVal == null) {
              return null;
          }
          else {
              return util.jsonEval(storedVal);
          }
      };
      DOMStorageWrapper.prototype.remove = function (key) {
          this.domStorage_.removeItem(this.prefixedName_(key));
      };
      DOMStorageWrapper.prototype.prefixedName_ = function (name) {
          return this.prefix_ + name;
      };
      DOMStorageWrapper.prototype.toString = function () {
          return this.domStorage_.toString();
      };
      return DOMStorageWrapper;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * An in-memory storage implementation that matches the API of DOMStorageWrapper
   * (TODO: create interface for both to implement).
   */
  var MemoryStorage = /** @class */ (function () {
      function MemoryStorage() {
          this.cache_ = {};
          this.isInMemoryStorage = true;
      }
      MemoryStorage.prototype.set = function (key, value) {
          if (value == null) {
              delete this.cache_[key];
          }
          else {
              this.cache_[key] = value;
          }
      };
      MemoryStorage.prototype.get = function (key) {
          if (util.contains(this.cache_, key)) {
              return this.cache_[key];
          }
          return null;
      };
      MemoryStorage.prototype.remove = function (key) {
          delete this.cache_[key];
      };
      return MemoryStorage;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Helper to create a DOMStorageWrapper or else fall back to MemoryStorage.
   * TODO: Once MemoryStorage and DOMStorageWrapper have a shared interface this method annotation should change
   * to reflect this type
   *
   * @param domStorageName - Name of the underlying storage object
   *   (e.g. 'localStorage' or 'sessionStorage').
   * @returns Turning off type information until a common interface is defined.
   */
  var createStoragefor = function (domStorageName) {
      try {
          // NOTE: just accessing "localStorage" or "window['localStorage']" may throw a security exception,
          // so it must be inside the try/catch.
          if (typeof window !== 'undefined' &&
              typeof window[domStorageName] !== 'undefined') {
              // Need to test cache. Just because it's here doesn't mean it works
              var domStorage = window[domStorageName];
              domStorage.setItem('firebase:sentinel', 'cache');
              domStorage.removeItem('firebase:sentinel');
              return new DOMStorageWrapper(domStorage);
          }
      }
      catch (e) { }
      // Failed to create wrapper.  Just return in-memory storage.
      // TODO: log?
      return new MemoryStorage();
  };
  /** A storage object that lasts across sessions */
  var PersistentStorage = createStoragefor('localStorage');
  /** A storage object that only lasts one session */
  var SessionStorage = createStoragefor('sessionStorage');
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var logClient = new logger$1.Logger('@firebase/database');
  /**
   * Returns a locally-unique ID (generated by just incrementing up from 0 each time its called).
   */
  var LUIDGenerator = (function () {
      var id = 1;
      return function () {
          return id++;
      };
  })();
  /**
   * Sha1 hash of the input string
   * @param str - The string to hash
   * @returns {!string} The resulting hash
   */
  var sha1 = function (str) {
      var utf8Bytes = util.stringToByteArray(str);
      var sha1 = new util.Sha1();
      sha1.update(utf8Bytes);
      var sha1Bytes = sha1.digest();
      return util.base64.encodeByteArray(sha1Bytes);
  };
  var buildLogMessage_ = function () {
      var varArgs = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          varArgs[_i] = arguments[_i];
      }
      var message = '';
      for (var i = 0; i < varArgs.length; i++) {
          var arg = varArgs[i];
          if (Array.isArray(arg) ||
              (arg &&
                  typeof arg === 'object' &&
                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
                  typeof arg.length === 'number')) {
              message += buildLogMessage_.apply(null, arg);
          }
          else if (typeof arg === 'object') {
              message += util.stringify(arg);
          }
          else {
              message += arg;
          }
          message += ' ';
      }
      return message;
  };
  /**
   * Use this for all debug messages in Firebase.
   */
  var logger = null;
  /**
   * Flag to check for log availability on first log message
   */
  var firstLog_ = true;
  /**
   * The implementation of Firebase.enableLogging (defined here to break dependencies)
   * @param logger_ - A flag to turn on logging, or a custom logger
   * @param persistent - Whether or not to persist logging settings across refreshes
   */
  var enableLogging$1 = function (logger_, persistent) {
      util.assert(!persistent || logger_ === true || logger_ === false, "Can't turn on custom loggers persistently.");
      if (logger_ === true) {
          logClient.logLevel = logger$1.LogLevel.VERBOSE;
          logger = logClient.log.bind(logClient);
          if (persistent) {
              SessionStorage.set('logging_enabled', true);
          }
      }
      else if (typeof logger_ === 'function') {
          logger = logger_;
      }
      else {
          logger = null;
          SessionStorage.remove('logging_enabled');
      }
  };
  var log = function () {
      var varArgs = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          varArgs[_i] = arguments[_i];
      }
      if (firstLog_ === true) {
          firstLog_ = false;
          if (logger === null && SessionStorage.get('logging_enabled') === true) {
              enableLogging$1(true);
          }
      }
      if (logger) {
          var message = buildLogMessage_.apply(null, varArgs);
          logger(message);
      }
  };
  var logWrapper = function (prefix) {
      return function () {
          var varArgs = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              varArgs[_i] = arguments[_i];
          }
          log.apply(void 0, tslib.__spreadArray([prefix], tslib.__read(varArgs)));
      };
  };
  var error = function () {
      var varArgs = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          varArgs[_i] = arguments[_i];
      }
      var message = 'FIREBASE INTERNAL ERROR: ' + buildLogMessage_.apply(void 0, tslib.__spreadArray([], tslib.__read(varArgs)));
      logClient.error(message);
  };
  var fatal = function () {
      var varArgs = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          varArgs[_i] = arguments[_i];
      }
      var message = "FIREBASE FATAL ERROR: " + buildLogMessage_.apply(void 0, tslib.__spreadArray([], tslib.__read(varArgs)));
      logClient.error(message);
      throw new Error(message);
  };
  var warn = function () {
      var varArgs = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          varArgs[_i] = arguments[_i];
      }
      var message = 'FIREBASE WARNING: ' + buildLogMessage_.apply(void 0, tslib.__spreadArray([], tslib.__read(varArgs)));
      logClient.warn(message);
  };
  /**
   * Logs a warning if the containing page uses https. Called when a call to new Firebase
   * does not use https.
   */
  var warnIfPageIsSecure = function () {
      // Be very careful accessing browser globals. Who knows what may or may not exist.
      if (typeof window !== 'undefined' &&
          window.location &&
          window.location.protocol &&
          window.location.protocol.indexOf('https:') !== -1) {
          warn('Insecure Firebase access from a secure page. ' +
              'Please use https in calls to new Firebase().');
      }
  };
  /**
   * Returns true if data is NaN, or +/- Infinity.
   */
  var isInvalidJSONNumber = function (data) {
      return (typeof data === 'number' &&
          (data !== data || // NaN
              data === Number.POSITIVE_INFINITY ||
              data === Number.NEGATIVE_INFINITY));
  };
  var executeWhenDOMReady = function (fn) {
      if (util.isNodeSdk() || document.readyState === 'complete') {
          fn();
      }
      else {
          // Modeled after jQuery. Try DOMContentLoaded and onreadystatechange (which
          // fire before onload), but fall back to onload.
          var called_1 = false;
          var wrappedFn_1 = function () {
              if (!document.body) {
                  setTimeout(wrappedFn_1, Math.floor(10));
                  return;
              }
              if (!called_1) {
                  called_1 = true;
                  fn();
              }
          };
          if (document.addEventListener) {
              document.addEventListener('DOMContentLoaded', wrappedFn_1, false);
              // fallback to onload.
              window.addEventListener('load', wrappedFn_1, false);
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
          }
          else if (document.attachEvent) {
              // IE.
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              document.attachEvent('onreadystatechange', function () {
                  if (document.readyState === 'complete') {
                      wrappedFn_1();
                  }
              });
              // fallback to onload.
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              window.attachEvent('onload', wrappedFn_1);
              // jQuery has an extra hack for IE that we could employ (based on
              // http://javascript.nwbox.com/IEContentLoaded/) But it looks really old.
              // I'm hoping we don't need it.
          }
      }
  };
  /**
   * Minimum key name. Invalid for actual data, used as a marker to sort before any valid names
   */
  var MIN_NAME = '[MIN_NAME]';
  /**
   * Maximum key name. Invalid for actual data, used as a marker to sort above any valid names
   */
  var MAX_NAME = '[MAX_NAME]';
  /**
   * Compares valid Firebase key names, plus min and max name
   */
  var nameCompare = function (a, b) {
      if (a === b) {
          return 0;
      }
      else if (a === MIN_NAME || b === MAX_NAME) {
          return -1;
      }
      else if (b === MIN_NAME || a === MAX_NAME) {
          return 1;
      }
      else {
          var aAsInt = tryParseInt(a), bAsInt = tryParseInt(b);
          if (aAsInt !== null) {
              if (bAsInt !== null) {
                  return aAsInt - bAsInt === 0 ? a.length - b.length : aAsInt - bAsInt;
              }
              else {
                  return -1;
              }
          }
          else if (bAsInt !== null) {
              return 1;
          }
          else {
              return a < b ? -1 : 1;
          }
      }
  };
  /**
   * @returns {!number} comparison result.
   */
  var stringCompare = function (a, b) {
      if (a === b) {
          return 0;
      }
      else if (a < b) {
          return -1;
      }
      else {
          return 1;
      }
  };
  var requireKey = function (key, obj) {
      if (obj && key in obj) {
          return obj[key];
      }
      else {
          throw new Error('Missing required key (' + key + ') in object: ' + util.stringify(obj));
      }
  };
  var ObjectToUniqueKey = function (obj) {
      if (typeof obj !== 'object' || obj === null) {
          return util.stringify(obj);
      }
      var keys = [];
      // eslint-disable-next-line guard-for-in
      for (var k in obj) {
          keys.push(k);
      }
      // Export as json, but with the keys sorted.
      keys.sort();
      var key = '{';
      for (var i = 0; i < keys.length; i++) {
          if (i !== 0) {
              key += ',';
          }
          key += util.stringify(keys[i]);
          key += ':';
          key += ObjectToUniqueKey(obj[keys[i]]);
      }
      key += '}';
      return key;
  };
  /**
   * Splits a string into a number of smaller segments of maximum size
   * @param str - The string
   * @param segsize - The maximum number of chars in the string.
   * @returns The string, split into appropriately-sized chunks
   */
  var splitStringBySize = function (str, segsize) {
      var len = str.length;
      if (len <= segsize) {
          return [str];
      }
      var dataSegs = [];
      for (var c = 0; c < len; c += segsize) {
          if (c + segsize > len) {
              dataSegs.push(str.substring(c, len));
          }
          else {
              dataSegs.push(str.substring(c, c + segsize));
          }
      }
      return dataSegs;
  };
  /**
   * Apply a function to each (key, value) pair in an object or
   * apply a function to each (index, value) pair in an array
   * @param obj - The object or array to iterate over
   * @param fn - The function to apply
   */
  function each(obj, fn) {
      for (var key in obj) {
          if (obj.hasOwnProperty(key)) {
              fn(key, obj[key]);
          }
      }
  }
  /**
   * Borrowed from http://hg.secondlife.com/llsd/src/tip/js/typedarray.js (MIT License)
   * I made one modification at the end and removed the NaN / Infinity
   * handling (since it seemed broken [caused an overflow] and we don't need it).  See MJL comments.
   * @param v - A double
   *
   */
  var doubleToIEEE754String = function (v) {
      util.assert(!isInvalidJSONNumber(v), 'Invalid JSON number'); // MJL
      var ebits = 11, fbits = 52;
      var bias = (1 << (ebits - 1)) - 1;
      var s, e, f, ln, i;
      // Compute sign, exponent, fraction
      // Skip NaN / Infinity handling --MJL.
      if (v === 0) {
          e = 0;
          f = 0;
          s = 1 / v === -Infinity ? 1 : 0;
      }
      else {
          s = v < 0;
          v = Math.abs(v);
          if (v >= Math.pow(2, 1 - bias)) {
              // Normalized
              ln = Math.min(Math.floor(Math.log(v) / Math.LN2), bias);
              e = ln + bias;
              f = Math.round(v * Math.pow(2, fbits - ln) - Math.pow(2, fbits));
          }
          else {
              // Denormalized
              e = 0;
              f = Math.round(v / Math.pow(2, 1 - bias - fbits));
          }
      }
      // Pack sign, exponent, fraction
      var bits = [];
      for (i = fbits; i; i -= 1) {
          bits.push(f % 2 ? 1 : 0);
          f = Math.floor(f / 2);
      }
      for (i = ebits; i; i -= 1) {
          bits.push(e % 2 ? 1 : 0);
          e = Math.floor(e / 2);
      }
      bits.push(s ? 1 : 0);
      bits.reverse();
      var str = bits.join('');
      // Return the data as a hex string. --MJL
      var hexByteString = '';
      for (i = 0; i < 64; i += 8) {
          var hexByte = parseInt(str.substr(i, 8), 2).toString(16);
          if (hexByte.length === 1) {
              hexByte = '0' + hexByte;
          }
          hexByteString = hexByteString + hexByte;
      }
      return hexByteString.toLowerCase();
  };
  /**
   * Used to detect if we're in a Chrome content script (which executes in an
   * isolated environment where long-polling doesn't work).
   */
  var isChromeExtensionContentScript = function () {
      return !!(typeof window === 'object' &&
          window['chrome'] &&
          window['chrome']['extension'] &&
          !/^chrome/.test(window.location.href));
  };
  /**
   * Used to detect if we're in a Windows 8 Store app.
   */
  var isWindowsStoreApp = function () {
      // Check for the presence of a couple WinRT globals
      return typeof Windows === 'object' && typeof Windows.UI === 'object';
  };
  /**
   * Converts a server error code to a Javascript Error
   */
  function errorForServerCode(code, query) {
      var reason = 'Unknown Error';
      if (code === 'too_big') {
          reason =
              'The data requested exceeds the maximum size ' +
                  'that can be accessed with a single request.';
      }
      else if (code === 'permission_denied') {
          reason = "Client doesn't have permission to access the desired data.";
      }
      else if (code === 'unavailable') {
          reason = 'The service is unavailable';
      }
      var error = new Error(code + ' at ' + query._path.toString() + ': ' + reason);
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      error.code = code.toUpperCase();
      return error;
  }
  /**
   * Used to test for integer-looking strings
   */
  var INTEGER_REGEXP_ = new RegExp('^-?(0*)\\d{1,10}$');
  /**
   * For use in keys, the minimum possible 32-bit integer.
   */
  var INTEGER_32_MIN = -2147483648;
  /**
   * For use in kyes, the maximum possible 32-bit integer.
   */
  var INTEGER_32_MAX = 2147483647;
  /**
   * If the string contains a 32-bit integer, return it.  Else return null.
   */
  var tryParseInt = function (str) {
      if (INTEGER_REGEXP_.test(str)) {
          var intVal = Number(str);
          if (intVal >= INTEGER_32_MIN && intVal <= INTEGER_32_MAX) {
              return intVal;
          }
      }
      return null;
  };
  /**
   * Helper to run some code but catch any exceptions and re-throw them later.
   * Useful for preventing user callbacks from breaking internal code.
   *
   * Re-throwing the exception from a setTimeout is a little evil, but it's very
   * convenient (we don't have to try to figure out when is a safe point to
   * re-throw it), and the behavior seems reasonable:
   *
   * * If you aren't pausing on exceptions, you get an error in the console with
   *   the correct stack trace.
   * * If you're pausing on all exceptions, the debugger will pause on your
   *   exception and then again when we rethrow it.
   * * If you're only pausing on uncaught exceptions, the debugger will only pause
   *   on us re-throwing it.
   *
   * @param fn - The code to guard.
   */
  var exceptionGuard = function (fn) {
      try {
          fn();
      }
      catch (e) {
          // Re-throw exception when it's safe.
          setTimeout(function () {
              // It used to be that "throw e" would result in a good console error with
              // relevant context, but as of Chrome 39, you just get the firebase.js
              // file/line number where we re-throw it, which is useless. So we log
              // e.stack explicitly.
              var stack = e.stack || '';
              warn('Exception was thrown by user callback.', stack);
              throw e;
          }, Math.floor(0));
      }
  };
  /**
   * @returns {boolean} true if we think we're currently being crawled.
   */
  var beingCrawled = function () {
      var userAgent = (typeof window === 'object' &&
          window['navigator'] &&
          window['navigator']['userAgent']) ||
          '';
      // For now we whitelist the most popular crawlers.  We should refine this to be the set of crawlers we
      // believe to support JavaScript/AJAX rendering.
      // NOTE: Google Webmaster Tools doesn't really belong, but their "This is how a visitor to your website
      // would have seen the page" is flaky if we don't treat it as a crawler.
      return (userAgent.search(/googlebot|google webmaster tools|bingbot|yahoo! slurp|baiduspider|yandexbot|duckduckbot/i) >= 0);
  };
  /**
   * Same as setTimeout() except on Node.JS it will /not/ prevent the process from exiting.
   *
   * It is removed with clearTimeout() as normal.
   *
   * @param fn - Function to run.
   * @param time - Milliseconds to wait before running.
   * @returns The setTimeout() return value.
   */
  var setTimeoutNonBlocking = function (fn, time) {
      var timeout = setTimeout(fn, time);
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      if (typeof timeout === 'object' && timeout['unref']) {
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          timeout['unref']();
      }
      return timeout;
  };
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * A class that holds metadata about a Repo object
   */
  var RepoInfo = /** @class */ (function () {
      /**
       * @param host - Hostname portion of the url for the repo
       * @param secure - Whether or not this repo is accessed over ssl
       * @param namespace - The namespace represented by the repo
       * @param webSocketOnly - Whether to prefer websockets over all other transports (used by Nest).
       * @param nodeAdmin - Whether this instance uses Admin SDK credentials
       * @param persistenceKey - Override the default session persistence storage key
       */
      function RepoInfo(host, secure, namespace, webSocketOnly, nodeAdmin, persistenceKey, includeNamespaceInQueryParams) {
          if (nodeAdmin === void 0) { nodeAdmin = false; }
          if (persistenceKey === void 0) { persistenceKey = ''; }
          if (includeNamespaceInQueryParams === void 0) { includeNamespaceInQueryParams = false; }
          this.secure = secure;
          this.namespace = namespace;
          this.webSocketOnly = webSocketOnly;
          this.nodeAdmin = nodeAdmin;
          this.persistenceKey = persistenceKey;
          this.includeNamespaceInQueryParams = includeNamespaceInQueryParams;
          this._host = host.toLowerCase();
          this._domain = this._host.substr(this._host.indexOf('.') + 1);
          this.internalHost =
              PersistentStorage.get('host:' + host) || this._host;
      }
      RepoInfo.prototype.isCacheableHost = function () {
          return this.internalHost.substr(0, 2) === 's-';
      };
      RepoInfo.prototype.isCustomHost = function () {
          return (this._domain !== 'firebaseio.com' &&
              this._domain !== 'firebaseio-demo.com');
      };
      Object.defineProperty(RepoInfo.prototype, "host", {
          get: function () {
              return this._host;
          },
          set: function (newHost) {
              if (newHost !== this.internalHost) {
                  this.internalHost = newHost;
                  if (this.isCacheableHost()) {
                      PersistentStorage.set('host:' + this._host, this.internalHost);
                  }
              }
          },
          enumerable: false,
          configurable: true
      });
      RepoInfo.prototype.toString = function () {
          var str = this.toURLString();
          if (this.persistenceKey) {
              str += '<' + this.persistenceKey + '>';
          }
          return str;
      };
      RepoInfo.prototype.toURLString = function () {
          var protocol = this.secure ? 'https://' : 'http://';
          var query = this.includeNamespaceInQueryParams
              ? "?ns=" + this.namespace
              : '';
          return "" + protocol + this.host + "/" + query;
      };
      return RepoInfo;
  }());
  function repoInfoNeedsQueryParam(repoInfo) {
      return (repoInfo.host !== repoInfo.internalHost ||
          repoInfo.isCustomHost() ||
          repoInfo.includeNamespaceInQueryParams);
  }
  /**
   * Returns the websocket URL for this repo
   * @param repoInfo - RepoInfo object
   * @param type - of connection
   * @param params - list
   * @returns The URL for this repo
   */
  function repoInfoConnectionURL(repoInfo, type, params) {
      util.assert(typeof type === 'string', 'typeof type must == string');
      util.assert(typeof params === 'object', 'typeof params must == object');
      var connURL;
      if (type === WEBSOCKET) {
          connURL =
              (repoInfo.secure ? 'wss://' : 'ws://') + repoInfo.internalHost + '/.ws?';
      }
      else if (type === LONG_POLLING) {
          connURL =
              (repoInfo.secure ? 'https://' : 'http://') +
                  repoInfo.internalHost +
                  '/.lp?';
      }
      else {
          throw new Error('Unknown connection type: ' + type);
      }
      if (repoInfoNeedsQueryParam(repoInfo)) {
          params['ns'] = repoInfo.namespace;
      }
      var pairs = [];
      each(params, function (key, value) {
          pairs.push(key + '=' + value);
      });
      return connURL + pairs.join('&');
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Tracks a collection of stats.
   */
  var StatsCollection = /** @class */ (function () {
      function StatsCollection() {
          this.counters_ = {};
      }
      StatsCollection.prototype.incrementCounter = function (name, amount) {
          if (amount === void 0) { amount = 1; }
          if (!util.contains(this.counters_, name)) {
              this.counters_[name] = 0;
          }
          this.counters_[name] += amount;
      };
      StatsCollection.prototype.get = function () {
          return util.deepCopy(this.counters_);
      };
      return StatsCollection;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var collections = {};
  var reporters = {};
  function statsManagerGetCollection(repoInfo) {
      var hashString = repoInfo.toString();
      if (!collections[hashString]) {
          collections[hashString] = new StatsCollection();
      }
      return collections[hashString];
  }
  function statsManagerGetOrCreateReporter(repoInfo, creatorFunction) {
      var hashString = repoInfo.toString();
      if (!reporters[hashString]) {
          reporters[hashString] = creatorFunction();
      }
      return reporters[hashString];
  }
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /** The semver (www.semver.org) version of the SDK. */
  var SDK_VERSION = '';
  /**
   * SDK_VERSION should be set before any database instance is created
   * @internal
   */
  function setSDKVersion(version) {
      SDK_VERSION = version;
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var WEBSOCKET_MAX_FRAME_SIZE = 16384;
  var WEBSOCKET_KEEPALIVE_INTERVAL = 45000;
  var WebSocketImpl = null;
  if (typeof MozWebSocket !== 'undefined') {
      WebSocketImpl = MozWebSocket;
  }
  else if (typeof WebSocket !== 'undefined') {
      WebSocketImpl = WebSocket;
  }
  function setWebSocketImpl(impl) {
      WebSocketImpl = impl;
  }
  /**
   * Create a new websocket connection with the given callbacks.
   */
  var WebSocketConnection = /** @class */ (function () {
      /**
       * @param connId identifier for this transport
       * @param repoInfo The info for the websocket endpoint.
       * @param applicationId The Firebase App ID for this project.
       * @param appCheckToken The App Check Token for this client.
       * @param authToken The Auth Token for this client.
       * @param transportSessionId Optional transportSessionId if this is connecting
       * to an existing transport session
       * @param lastSessionId Optional lastSessionId if there was a previous
       * connection
       */
      function WebSocketConnection(connId, repoInfo, applicationId, appCheckToken, authToken, transportSessionId, lastSessionId) {
          this.connId = connId;
          this.applicationId = applicationId;
          this.appCheckToken = appCheckToken;
          this.authToken = authToken;
          this.keepaliveTimer = null;
          this.frames = null;
          this.totalFrames = 0;
          this.bytesSent = 0;
          this.bytesReceived = 0;
          this.log_ = logWrapper(this.connId);
          this.stats_ = statsManagerGetCollection(repoInfo);
          this.connURL = WebSocketConnection.connectionURL_(repoInfo, transportSessionId, lastSessionId, appCheckToken);
          this.nodeAdmin = repoInfo.nodeAdmin;
      }
      /**
       * @param repoInfo - The info for the websocket endpoint.
       * @param transportSessionId - Optional transportSessionId if this is connecting to an existing transport
       *                                         session
       * @param lastSessionId - Optional lastSessionId if there was a previous connection
       * @returns connection url
       */
      WebSocketConnection.connectionURL_ = function (repoInfo, transportSessionId, lastSessionId, appCheckToken) {
          var urlParams = {};
          urlParams[VERSION_PARAM] = PROTOCOL_VERSION;
          if (!util.isNodeSdk() &&
              typeof location !== 'undefined' &&
              location.hostname &&
              FORGE_DOMAIN_RE.test(location.hostname)) {
              urlParams[REFERER_PARAM] = FORGE_REF;
          }
          if (transportSessionId) {
              urlParams[TRANSPORT_SESSION_PARAM] = transportSessionId;
          }
          if (lastSessionId) {
              urlParams[LAST_SESSION_PARAM] = lastSessionId;
          }
          if (appCheckToken) {
              urlParams[APP_CHECK_TOKEN_PARAM] = appCheckToken;
          }
          return repoInfoConnectionURL(repoInfo, WEBSOCKET, urlParams);
      };
      /**
       * @param onMessage - Callback when messages arrive
       * @param onDisconnect - Callback with connection lost.
       */
      WebSocketConnection.prototype.open = function (onMessage, onDisconnect) {
          var _this = this;
          this.onDisconnect = onDisconnect;
          this.onMessage = onMessage;
          this.log_('Websocket connecting to ' + this.connURL);
          this.everConnected_ = false;
          // Assume failure until proven otherwise.
          PersistentStorage.set('previous_websocket_failure', true);
          try {
              if (util.isNodeSdk()) {
                  var device = this.nodeAdmin ? 'AdminNode' : 'Node';
                  // UA Format: Firebase/<wire_protocol>/<sdk_version>/<platform>/<device>
                  var options = {
                      headers: {
                          'User-Agent': "Firebase/" + PROTOCOL_VERSION + "/" + SDK_VERSION + "/" + process.platform + "/" + device,
                          'X-Firebase-GMPID': this.applicationId || ''
                      }
                  };
                  // If using Node with admin creds, AppCheck-related checks are unnecessary.
                  // Note that we send the credentials here even if they aren't admin credentials, which is
                  // not a problem.
                  // Note that this header is just used to bypass appcheck, and the token should still be sent
                  // through the websocket connection once it is established.
                  if (this.authToken) {
                      options.headers['Authorization'] = "Bearer " + this.authToken;
                  }
                  if (this.appCheckToken) {
                      options.headers['X-Firebase-AppCheck'] = this.appCheckToken;
                  }
                  // Plumb appropriate http_proxy environment variable into faye-websocket if it exists.
                  var env = process['env'];
                  var proxy = this.connURL.indexOf('wss://') === 0
                      ? env['HTTPS_PROXY'] || env['https_proxy']
                      : env['HTTP_PROXY'] || env['http_proxy'];
                  if (proxy) {
                      options['proxy'] = { origin: proxy };
                  }
                  this.mySock = new WebSocketImpl(this.connURL, [], options);
              }
              else {
                  var options = {
                      headers: {
                          'X-Firebase-GMPID': this.applicationId || '',
                          'X-Firebase-AppCheck': this.appCheckToken || ''
                      }
                  };
                  this.mySock = new WebSocketImpl(this.connURL, [], options);
              }
          }
          catch (e) {
              this.log_('Error instantiating WebSocket.');
              var error = e.message || e.data;
              if (error) {
                  this.log_(error);
              }
              this.onClosed_();
              return;
          }
          this.mySock.onopen = function () {
              _this.log_('Websocket connected.');
              _this.everConnected_ = true;
          };
          this.mySock.onclose = function () {
              _this.log_('Websocket connection was disconnected.');
              _this.mySock = null;
              _this.onClosed_();
          };
          this.mySock.onmessage = function (m) {
              _this.handleIncomingFrame(m);
          };
          this.mySock.onerror = function (e) {
              _this.log_('WebSocket error.  Closing connection.');
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              var error = e.message || e.data;
              if (error) {
                  _this.log_(error);
              }
              _this.onClosed_();
          };
      };
      /**
       * No-op for websockets, we don't need to do anything once the connection is confirmed as open
       */
      WebSocketConnection.prototype.start = function () { };
      WebSocketConnection.forceDisallow = function () {
          WebSocketConnection.forceDisallow_ = true;
      };
      WebSocketConnection.isAvailable = function () {
          var isOldAndroid = false;
          if (typeof navigator !== 'undefined' && navigator.userAgent) {
              var oldAndroidRegex = /Android ([0-9]{0,}\.[0-9]{0,})/;
              var oldAndroidMatch = navigator.userAgent.match(oldAndroidRegex);
              if (oldAndroidMatch && oldAndroidMatch.length > 1) {
                  if (parseFloat(oldAndroidMatch[1]) < 4.4) {
                      isOldAndroid = true;
                  }
              }
          }
          return (!isOldAndroid &&
              WebSocketImpl !== null &&
              !WebSocketConnection.forceDisallow_);
      };
      /**
       * Returns true if we previously failed to connect with this transport.
       */
      WebSocketConnection.previouslyFailed = function () {
          // If our persistent storage is actually only in-memory storage,
          // we default to assuming that it previously failed to be safe.
          return (PersistentStorage.isInMemoryStorage ||
              PersistentStorage.get('previous_websocket_failure') === true);
      };
      WebSocketConnection.prototype.markConnectionHealthy = function () {
          PersistentStorage.remove('previous_websocket_failure');
      };
      WebSocketConnection.prototype.appendFrame_ = function (data) {
          this.frames.push(data);
          if (this.frames.length === this.totalFrames) {
              var fullMess = this.frames.join('');
              this.frames = null;
              var jsonMess = util.jsonEval(fullMess);
              //handle the message
              this.onMessage(jsonMess);
          }
      };
      /**
       * @param frameCount - The number of frames we are expecting from the server
       */
      WebSocketConnection.prototype.handleNewFrameCount_ = function (frameCount) {
          this.totalFrames = frameCount;
          this.frames = [];
      };
      /**
       * Attempts to parse a frame count out of some text. If it can't, assumes a value of 1
       * @returns Any remaining data to be process, or null if there is none
       */
      WebSocketConnection.prototype.extractFrameCount_ = function (data) {
          util.assert(this.frames === null, 'We already have a frame buffer');
          // TODO: The server is only supposed to send up to 9999 frames (i.e. length <= 4), but that isn't being enforced
          // currently.  So allowing larger frame counts (length <= 6).  See https://app.asana.com/0/search/8688598998380/8237608042508
          if (data.length <= 6) {
              var frameCount = Number(data);
              if (!isNaN(frameCount)) {
                  this.handleNewFrameCount_(frameCount);
                  return null;
              }
          }
          this.handleNewFrameCount_(1);
          return data;
      };
      /**
       * Process a websocket frame that has arrived from the server.
       * @param mess - The frame data
       */
      WebSocketConnection.prototype.handleIncomingFrame = function (mess) {
          if (this.mySock === null) {
              return; // Chrome apparently delivers incoming packets even after we .close() the connection sometimes.
          }
          var data = mess['data'];
          this.bytesReceived += data.length;
          this.stats_.incrementCounter('bytes_received', data.length);
          this.resetKeepAlive();
          if (this.frames !== null) {
              // we're buffering
              this.appendFrame_(data);
          }
          else {
              // try to parse out a frame count, otherwise, assume 1 and process it
              var remainingData = this.extractFrameCount_(data);
              if (remainingData !== null) {
                  this.appendFrame_(remainingData);
              }
          }
      };
      /**
       * Send a message to the server
       * @param data - The JSON object to transmit
       */
      WebSocketConnection.prototype.send = function (data) {
          this.resetKeepAlive();
          var dataStr = util.stringify(data);
          this.bytesSent += dataStr.length;
          this.stats_.incrementCounter('bytes_sent', dataStr.length);
          //We can only fit a certain amount in each websocket frame, so we need to split this request
          //up into multiple pieces if it doesn't fit in one request.
          var dataSegs = splitStringBySize(dataStr, WEBSOCKET_MAX_FRAME_SIZE);
          //Send the length header
          if (dataSegs.length > 1) {
              this.sendString_(String(dataSegs.length));
          }
          //Send the actual data in segments.
          for (var i = 0; i < dataSegs.length; i++) {
              this.sendString_(dataSegs[i]);
          }
      };
      WebSocketConnection.prototype.shutdown_ = function () {
          this.isClosed_ = true;
          if (this.keepaliveTimer) {
              clearInterval(this.keepaliveTimer);
              this.keepaliveTimer = null;
          }
          if (this.mySock) {
              this.mySock.close();
              this.mySock = null;
          }
      };
      WebSocketConnection.prototype.onClosed_ = function () {
          if (!this.isClosed_) {
              this.log_('WebSocket is closing itself');
              this.shutdown_();
              // since this is an internal close, trigger the close listener
              if (this.onDisconnect) {
                  this.onDisconnect(this.everConnected_);
                  this.onDisconnect = null;
              }
          }
      };
      /**
       * External-facing close handler.
       * Close the websocket and kill the connection.
       */
      WebSocketConnection.prototype.close = function () {
          if (!this.isClosed_) {
              this.log_('WebSocket is being closed');
              this.shutdown_();
          }
      };
      /**
       * Kill the current keepalive timer and start a new one, to ensure that it always fires N seconds after
       * the last activity.
       */
      WebSocketConnection.prototype.resetKeepAlive = function () {
          var _this = this;
          clearInterval(this.keepaliveTimer);
          this.keepaliveTimer = setInterval(function () {
              //If there has been no websocket activity for a while, send a no-op
              if (_this.mySock) {
                  _this.sendString_('0');
              }
              _this.resetKeepAlive();
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
          }, Math.floor(WEBSOCKET_KEEPALIVE_INTERVAL));
      };
      /**
       * Send a string over the websocket.
       *
       * @param str - String to send.
       */
      WebSocketConnection.prototype.sendString_ = function (str) {
          // Firefox seems to sometimes throw exceptions (NS_ERROR_UNEXPECTED) from websocket .send()
          // calls for some unknown reason.  We treat these as an error and disconnect.
          // See https://app.asana.com/0/58926111402292/68021340250410
          try {
              this.mySock.send(str);
          }
          catch (e) {
              this.log_('Exception thrown from WebSocket.send():', e.message || e.data, 'Closing connection.');
              setTimeout(this.onClosed_.bind(this), 0);
          }
      };
      /**
       * Number of response before we consider the connection "healthy."
       */
      WebSocketConnection.responsesRequiredToBeHealthy = 2;
      /**
       * Time to wait for the connection te become healthy before giving up.
       */
      WebSocketConnection.healthyTimeout = 30000;
      return WebSocketConnection;
  }());
  
  var name = "@firebase/database";
  var version = "0.12.8";
  
  /**
   * @license
   * Copyright 2021 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Abstraction around AppCheck's token fetching capabilities.
   */
  var AppCheckTokenProvider = /** @class */ (function () {
      function AppCheckTokenProvider(appName_, appCheckProvider) {
          var _this = this;
          this.appName_ = appName_;
          this.appCheckProvider = appCheckProvider;
          this.appCheck = appCheckProvider === null || appCheckProvider === void 0 ? void 0 : appCheckProvider.getImmediate({ optional: true });
          if (!this.appCheck) {
              appCheckProvider === null || appCheckProvider === void 0 ? void 0 : appCheckProvider.get().then(function (appCheck) { return (_this.appCheck = appCheck); });
          }
      }
      AppCheckTokenProvider.prototype.getToken = function (forceRefresh) {
          var _this = this;
          if (!this.appCheck) {
              return new Promise(function (resolve, reject) {
                  // Support delayed initialization of FirebaseAppCheck. This allows our
                  // customers to initialize the RTDB SDK before initializing Firebase
                  // AppCheck and ensures that all requests are authenticated if a token
                  // becomes available before the timoeout below expires.
                  setTimeout(function () {
                      if (_this.appCheck) {
                          _this.getToken(forceRefresh).then(resolve, reject);
                      }
                      else {
                          resolve(null);
                      }
                  }, 0);
              });
          }
          return this.appCheck.getToken(forceRefresh);
      };
      AppCheckTokenProvider.prototype.addTokenChangeListener = function (listener) {
          var _a;
          (_a = this.appCheckProvider) === null || _a === void 0 ? void 0 : _a.get().then(function (appCheck) { return appCheck.addTokenListener(listener); });
      };
      AppCheckTokenProvider.prototype.notifyForInvalidToken = function () {
          warn("Provided AppCheck credentials for the app named \"" + this.appName_ + "\" " +
              'are invalid. This usually indicates your app was not initialized correctly.');
      };
      return AppCheckTokenProvider;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Abstraction around FirebaseApp's token fetching capabilities.
   */
  var FirebaseAuthTokenProvider = /** @class */ (function () {
      function FirebaseAuthTokenProvider(appName_, firebaseOptions_, authProvider_) {
          var _this = this;
          this.appName_ = appName_;
          this.firebaseOptions_ = firebaseOptions_;
          this.authProvider_ = authProvider_;
          this.auth_ = null;
          this.auth_ = authProvider_.getImmediate({ optional: true });
          if (!this.auth_) {
              authProvider_.onInit(function (auth) { return (_this.auth_ = auth); });
          }
      }
      FirebaseAuthTokenProvider.prototype.getToken = function (forceRefresh) {
          var _this = this;
          if (!this.auth_) {
              return new Promise(function (resolve, reject) {
                  // Support delayed initialization of FirebaseAuth. This allows our
                  // customers to initialize the RTDB SDK before initializing Firebase
                  // Auth and ensures that all requests are authenticated if a token
                  // becomes available before the timoeout below expires.
                  setTimeout(function () {
                      if (_this.auth_) {
                          _this.getToken(forceRefresh).then(resolve, reject);
                      }
                      else {
                          resolve(null);
                      }
                  }, 0);
              });
          }
          return this.auth_.getToken(forceRefresh).catch(function (error) {
              // TODO: Need to figure out all the cases this is raised and whether
              // this makes sense.
              if (error && error.code === 'auth/token-not-initialized') {
                  log('Got auth/token-not-initialized error.  Treating as null token.');
                  return null;
              }
              else {
                  return Promise.reject(error);
              }
          });
      };
      FirebaseAuthTokenProvider.prototype.addTokenChangeListener = function (listener) {
          // TODO: We might want to wrap the listener and call it with no args to
          // avoid a leaky abstraction, but that makes removing the listener harder.
          if (this.auth_) {
              this.auth_.addAuthTokenListener(listener);
          }
          else {
              this.authProvider_
                  .get()
                  .then(function (auth) { return auth.addAuthTokenListener(listener); });
          }
      };
      FirebaseAuthTokenProvider.prototype.removeTokenChangeListener = function (listener) {
          this.authProvider_
              .get()
              .then(function (auth) { return auth.removeAuthTokenListener(listener); });
      };
      FirebaseAuthTokenProvider.prototype.notifyForInvalidToken = function () {
          var errorMessage = 'Provided authentication credentials for the app named "' +
              this.appName_ +
              '" are invalid. This usually indicates your app was not ' +
              'initialized correctly. ';
          if ('credential' in this.firebaseOptions_) {
              errorMessage +=
                  'Make sure the "credential" property provided to initializeApp() ' +
                      'is authorized to access the specified "databaseURL" and is from the correct ' +
                      'project.';
          }
          else if ('serviceAccount' in this.firebaseOptions_) {
              errorMessage +=
                  'Make sure the "serviceAccount" property provided to initializeApp() ' +
                      'is authorized to access the specified "databaseURL" and is from the correct ' +
                      'project.';
          }
          else {
              errorMessage +=
                  'Make sure the "apiKey" and "databaseURL" properties provided to ' +
                      'initializeApp() match the values provided for your app at ' +
                      'https://console.firebase.google.com/.';
          }
          warn(errorMessage);
      };
      return FirebaseAuthTokenProvider;
  }());
  /* AuthTokenProvider that supplies a constant token. Used by Admin SDK or mockUserToken with emulators. */
  var EmulatorTokenProvider = /** @class */ (function () {
      function EmulatorTokenProvider(accessToken) {
          this.accessToken = accessToken;
      }
      EmulatorTokenProvider.prototype.getToken = function (forceRefresh) {
          return Promise.resolve({
              accessToken: this.accessToken
          });
      };
      EmulatorTokenProvider.prototype.addTokenChangeListener = function (listener) {
          // Invoke the listener immediately to match the behavior in Firebase Auth
          // (see packages/auth/src/auth.js#L1807)
          listener(this.accessToken);
      };
      EmulatorTokenProvider.prototype.removeTokenChangeListener = function (listener) { };
      EmulatorTokenProvider.prototype.notifyForInvalidToken = function () { };
      /** A string that is treated as an admin access token by the RTDB emulator. Used by Admin SDK. */
      EmulatorTokenProvider.OWNER = 'owner';
      return EmulatorTokenProvider;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * This class ensures the packets from the server arrive in order
   * This class takes data from the server and ensures it gets passed into the callbacks in order.
   */
  var PacketReceiver = /** @class */ (function () {
      /**
       * @param onMessage_
       */
      function PacketReceiver(onMessage_) {
          this.onMessage_ = onMessage_;
          this.pendingResponses = [];
          this.currentResponseNum = 0;
          this.closeAfterResponse = -1;
          this.onClose = null;
      }
      PacketReceiver.prototype.closeAfter = function (responseNum, callback) {
          this.closeAfterResponse = responseNum;
          this.onClose = callback;
          if (this.closeAfterResponse < this.currentResponseNum) {
              this.onClose();
              this.onClose = null;
          }
      };
      /**
       * Each message from the server comes with a response number, and an array of data. The responseNumber
       * allows us to ensure that we process them in the right order, since we can't be guaranteed that all
       * browsers will respond in the same order as the requests we sent
       */
      PacketReceiver.prototype.handleResponse = function (requestNum, data) {
          var _this = this;
          this.pendingResponses[requestNum] = data;
          var _loop_1 = function () {
              var toProcess = this_1.pendingResponses[this_1.currentResponseNum];
              delete this_1.pendingResponses[this_1.currentResponseNum];
              var _loop_2 = function (i) {
                  if (toProcess[i]) {
                      exceptionGuard(function () {
                          _this.onMessage_(toProcess[i]);
                      });
                  }
              };
              for (var i = 0; i < toProcess.length; ++i) {
                  _loop_2(i);
              }
              if (this_1.currentResponseNum === this_1.closeAfterResponse) {
                  if (this_1.onClose) {
                      this_1.onClose();
                      this_1.onClose = null;
                  }
                  return "break";
              }
              this_1.currentResponseNum++;
          };
          var this_1 = this;
          while (this.pendingResponses[this.currentResponseNum]) {
              var state_1 = _loop_1();
              if (state_1 === "break")
                  break;
          }
      };
      return PacketReceiver;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  // URL query parameters associated with longpolling
  var FIREBASE_LONGPOLL_START_PARAM = 'start';
  var FIREBASE_LONGPOLL_CLOSE_COMMAND = 'close';
  var FIREBASE_LONGPOLL_COMMAND_CB_NAME = 'pLPCommand';
  var FIREBASE_LONGPOLL_DATA_CB_NAME = 'pRTLPCB';
  var FIREBASE_LONGPOLL_ID_PARAM = 'id';
  var FIREBASE_LONGPOLL_PW_PARAM = 'pw';
  var FIREBASE_LONGPOLL_SERIAL_PARAM = 'ser';
  var FIREBASE_LONGPOLL_CALLBACK_ID_PARAM = 'cb';
  var FIREBASE_LONGPOLL_SEGMENT_NUM_PARAM = 'seg';
  var FIREBASE_LONGPOLL_SEGMENTS_IN_PACKET = 'ts';
  var FIREBASE_LONGPOLL_DATA_PARAM = 'd';
  var FIREBASE_LONGPOLL_DISCONN_FRAME_REQUEST_PARAM = 'dframe';
  //Data size constants.
  //TODO: Perf: the maximum length actually differs from browser to browser.
  // We should check what browser we're on and set accordingly.
  var MAX_URL_DATA_SIZE = 1870;
  var SEG_HEADER_SIZE = 30; //ie: &seg=8299234&ts=982389123&d=
  var MAX_PAYLOAD_SIZE = MAX_URL_DATA_SIZE - SEG_HEADER_SIZE;
  /**
   * Keepalive period
   * send a fresh request at minimum every 25 seconds. Opera has a maximum request
   * length of 30 seconds that we can't exceed.
   */
  var KEEPALIVE_REQUEST_INTERVAL = 25000;
  /**
   * How long to wait before aborting a long-polling connection attempt.
   */
  var LP_CONNECT_TIMEOUT = 30000;
  /**
   * This class manages a single long-polling connection.
   */
  var BrowserPollConnection = /** @class */ (function () {
      /**
       * @param connId An identifier for this connection, used for logging
       * @param repoInfo The info for the endpoint to send data to.
       * @param applicationId The Firebase App ID for this project.
       * @param appCheckToken The AppCheck token for this client.
       * @param authToken The AuthToken to use for this connection.
       * @param transportSessionId Optional transportSessionid if we are
       * reconnecting for an existing transport session
       * @param lastSessionId Optional lastSessionId if the PersistentConnection has
       * already created a connection previously
       */
      function BrowserPollConnection(connId, repoInfo, applicationId, appCheckToken, authToken, transportSessionId, lastSessionId) {
          var _this = this;
          this.connId = connId;
          this.repoInfo = repoInfo;
          this.applicationId = applicationId;
          this.appCheckToken = appCheckToken;
          this.authToken = authToken;
          this.transportSessionId = transportSessionId;
          this.lastSessionId = lastSessionId;
          this.bytesSent = 0;
          this.bytesReceived = 0;
          this.everConnected_ = false;
          this.log_ = logWrapper(connId);
          this.stats_ = statsManagerGetCollection(repoInfo);
          this.urlFn = function (params) {
              // Always add the token if we have one.
              if (_this.appCheckToken) {
                  params[APP_CHECK_TOKEN_PARAM] = _this.appCheckToken;
              }
              return repoInfoConnectionURL(repoInfo, LONG_POLLING, params);
          };
      }
      /**
       * @param onMessage - Callback when messages arrive
       * @param onDisconnect - Callback with connection lost.
       */
      BrowserPollConnection.prototype.open = function (onMessage, onDisconnect) {
          var _this = this;
          this.curSegmentNum = 0;
          this.onDisconnect_ = onDisconnect;
          this.myPacketOrderer = new PacketReceiver(onMessage);
          this.isClosed_ = false;
          this.connectTimeoutTimer_ = setTimeout(function () {
              _this.log_('Timed out trying to connect.');
              // Make sure we clear the host cache
              _this.onClosed_();
              _this.connectTimeoutTimer_ = null;
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
          }, Math.floor(LP_CONNECT_TIMEOUT));
          // Ensure we delay the creation of the iframe until the DOM is loaded.
          executeWhenDOMReady(function () {
              if (_this.isClosed_) {
                  return;
              }
              //Set up a callback that gets triggered once a connection is set up.
              _this.scriptTagHolder = new FirebaseIFrameScriptHolder(function () {
                  var args = [];
                  for (var _i = 0; _i < arguments.length; _i++) {
                      args[_i] = arguments[_i];
                  }
                  var _a = tslib.__read(args, 5), command = _a[0], arg1 = _a[1], arg2 = _a[2]; _a[3]; _a[4];
                  _this.incrementIncomingBytes_(args);
                  if (!_this.scriptTagHolder) {
                      return; // we closed the connection.
                  }
                  if (_this.connectTimeoutTimer_) {
                      clearTimeout(_this.connectTimeoutTimer_);
                      _this.connectTimeoutTimer_ = null;
                  }
                  _this.everConnected_ = true;
                  if (command === FIREBASE_LONGPOLL_START_PARAM) {
                      _this.id = arg1;
                      _this.password = arg2;
                  }
                  else if (command === FIREBASE_LONGPOLL_CLOSE_COMMAND) {
                      // Don't clear the host cache. We got a response from the server, so we know it's reachable
                      if (arg1) {
                          // We aren't expecting any more data (other than what the server's already in the process of sending us
                          // through our already open polls), so don't send any more.
                          _this.scriptTagHolder.sendNewPolls = false;
                          // arg1 in this case is the last response number sent by the server. We should try to receive
                          // all of the responses up to this one before closing
                          _this.myPacketOrderer.closeAfter(arg1, function () {
                              _this.onClosed_();
                          });
                      }
                      else {
                          _this.onClosed_();
                      }
                  }
                  else {
                      throw new Error('Unrecognized command received: ' + command);
                  }
              }, function () {
                  var args = [];
                  for (var _i = 0; _i < arguments.length; _i++) {
                      args[_i] = arguments[_i];
                  }
                  var _a = tslib.__read(args, 2), pN = _a[0], data = _a[1];
                  _this.incrementIncomingBytes_(args);
                  _this.myPacketOrderer.handleResponse(pN, data);
              }, function () {
                  _this.onClosed_();
              }, _this.urlFn);
              //Send the initial request to connect. The serial number is simply to keep the browser from pulling previous results
              //from cache.
              var urlParams = {};
              urlParams[FIREBASE_LONGPOLL_START_PARAM] = 't';
              urlParams[FIREBASE_LONGPOLL_SERIAL_PARAM] = Math.floor(Math.random() * 100000000);
              if (_this.scriptTagHolder.uniqueCallbackIdentifier) {
                  urlParams[FIREBASE_LONGPOLL_CALLBACK_ID_PARAM] =
                      _this.scriptTagHolder.uniqueCallbackIdentifier;
              }
              urlParams[VERSION_PARAM] = PROTOCOL_VERSION;
              if (_this.transportSessionId) {
                  urlParams[TRANSPORT_SESSION_PARAM] = _this.transportSessionId;
              }
              if (_this.lastSessionId) {
                  urlParams[LAST_SESSION_PARAM] = _this.lastSessionId;
              }
              if (_this.applicationId) {
                  urlParams[APPLICATION_ID_PARAM] = _this.applicationId;
              }
              if (_this.appCheckToken) {
                  urlParams[APP_CHECK_TOKEN_PARAM] = _this.appCheckToken;
              }
              if (typeof location !== 'undefined' &&
                  location.hostname &&
                  FORGE_DOMAIN_RE.test(location.hostname)) {
                  urlParams[REFERER_PARAM] = FORGE_REF;
              }
              var connectURL = _this.urlFn(urlParams);
              _this.log_('Connecting via long-poll to ' + connectURL);
              _this.scriptTagHolder.addTag(connectURL, function () {
                  /* do nothing */
              });
          });
      };
      /**
       * Call this when a handshake has completed successfully and we want to consider the connection established
       */
      BrowserPollConnection.prototype.start = function () {
          this.scriptTagHolder.startLongPoll(this.id, this.password);
          this.addDisconnectPingFrame(this.id, this.password);
      };
      /**
       * Forces long polling to be considered as a potential transport
       */
      BrowserPollConnection.forceAllow = function () {
          BrowserPollConnection.forceAllow_ = true;
      };
      /**
       * Forces longpolling to not be considered as a potential transport
       */
      BrowserPollConnection.forceDisallow = function () {
          BrowserPollConnection.forceDisallow_ = true;
      };
      // Static method, use string literal so it can be accessed in a generic way
      BrowserPollConnection.isAvailable = function () {
          if (util.isNodeSdk()) {
              return false;
          }
          else if (BrowserPollConnection.forceAllow_) {
              return true;
          }
          else {
              // NOTE: In React-Native there's normally no 'document', but if you debug a React-Native app in
              // the Chrome debugger, 'document' is defined, but document.createElement is null (2015/06/08).
              return (!BrowserPollConnection.forceDisallow_ &&
                  typeof document !== 'undefined' &&
                  document.createElement != null &&
                  !isChromeExtensionContentScript() &&
                  !isWindowsStoreApp());
          }
      };
      /**
       * No-op for polling
       */
      BrowserPollConnection.prototype.markConnectionHealthy = function () { };
      /**
       * Stops polling and cleans up the iframe
       */
      BrowserPollConnection.prototype.shutdown_ = function () {
          this.isClosed_ = true;
          if (this.scriptTagHolder) {
              this.scriptTagHolder.close();
              this.scriptTagHolder = null;
          }
          //remove the disconnect frame, which will trigger an XHR call to the server to tell it we're leaving.
          if (this.myDisconnFrame) {
              document.body.removeChild(this.myDisconnFrame);
              this.myDisconnFrame = null;
          }
          if (this.connectTimeoutTimer_) {
              clearTimeout(this.connectTimeoutTimer_);
              this.connectTimeoutTimer_ = null;
          }
      };
      /**
       * Triggered when this transport is closed
       */
      BrowserPollConnection.prototype.onClosed_ = function () {
          if (!this.isClosed_) {
              this.log_('Longpoll is closing itself');
              this.shutdown_();
              if (this.onDisconnect_) {
                  this.onDisconnect_(this.everConnected_);
                  this.onDisconnect_ = null;
              }
          }
      };
      /**
       * External-facing close handler. RealTime has requested we shut down. Kill our connection and tell the server
       * that we've left.
       */
      BrowserPollConnection.prototype.close = function () {
          if (!this.isClosed_) {
              this.log_('Longpoll is being closed.');
              this.shutdown_();
          }
      };
      /**
       * Send the JSON object down to the server. It will need to be stringified, base64 encoded, and then
       * broken into chunks (since URLs have a small maximum length).
       * @param data - The JSON data to transmit.
       */
      BrowserPollConnection.prototype.send = function (data) {
          var dataStr = util.stringify(data);
          this.bytesSent += dataStr.length;
          this.stats_.incrementCounter('bytes_sent', dataStr.length);
          //first, lets get the base64-encoded data
          var base64data = util.base64Encode(dataStr);
          //We can only fit a certain amount in each URL, so we need to split this request
          //up into multiple pieces if it doesn't fit in one request.
          var dataSegs = splitStringBySize(base64data, MAX_PAYLOAD_SIZE);
          //Enqueue each segment for transmission. We assign each chunk a sequential ID and a total number
          //of segments so that we can reassemble the packet on the server.
          for (var i = 0; i < dataSegs.length; i++) {
              this.scriptTagHolder.enqueueSegment(this.curSegmentNum, dataSegs.length, dataSegs[i]);
              this.curSegmentNum++;
          }
      };
      /**
       * This is how we notify the server that we're leaving.
       * We aren't able to send requests with DHTML on a window close event, but we can
       * trigger XHR requests in some browsers (everything but Opera basically).
       */
      BrowserPollConnection.prototype.addDisconnectPingFrame = function (id, pw) {
          if (util.isNodeSdk()) {
              return;
          }
          this.myDisconnFrame = document.createElement('iframe');
          var urlParams = {};
          urlParams[FIREBASE_LONGPOLL_DISCONN_FRAME_REQUEST_PARAM] = 't';
          urlParams[FIREBASE_LONGPOLL_ID_PARAM] = id;
          urlParams[FIREBASE_LONGPOLL_PW_PARAM] = pw;
          this.myDisconnFrame.src = this.urlFn(urlParams);
          this.myDisconnFrame.style.display = 'none';
          document.body.appendChild(this.myDisconnFrame);
      };
      /**
       * Used to track the bytes received by this client
       */
      BrowserPollConnection.prototype.incrementIncomingBytes_ = function (args) {
          // TODO: This is an annoying perf hit just to track the number of incoming bytes.  Maybe it should be opt-in.
          var bytesReceived = util.stringify(args).length;
          this.bytesReceived += bytesReceived;
          this.stats_.incrementCounter('bytes_received', bytesReceived);
      };
      return BrowserPollConnection;
  }());
  /*********************************************************************************************
   * A wrapper around an iframe that is used as a long-polling script holder.
   *********************************************************************************************/
  var FirebaseIFrameScriptHolder = /** @class */ (function () {
      /**
       * @param commandCB - The callback to be called when control commands are recevied from the server.
       * @param onMessageCB - The callback to be triggered when responses arrive from the server.
       * @param onDisconnect - The callback to be triggered when this tag holder is closed
       * @param urlFn - A function that provides the URL of the endpoint to send data to.
       */
      function FirebaseIFrameScriptHolder(commandCB, onMessageCB, onDisconnect, urlFn) {
          this.onDisconnect = onDisconnect;
          this.urlFn = urlFn;
          //We maintain a count of all of the outstanding requests, because if we have too many active at once it can cause
          //problems in some browsers.
          this.outstandingRequests = new Set();
          //A queue of the pending segments waiting for transmission to the server.
          this.pendingSegs = [];
          //A serial number. We use this for two things:
          // 1) A way to ensure the browser doesn't cache responses to polls
          // 2) A way to make the server aware when long-polls arrive in a different order than we started them. The
          //    server needs to release both polls in this case or it will cause problems in Opera since Opera can only execute
          //    JSONP code in the order it was added to the iframe.
          this.currentSerial = Math.floor(Math.random() * 100000000);
          // This gets set to false when we're "closing down" the connection (e.g. we're switching transports but there's still
          // incoming data from the server that we're waiting for).
          this.sendNewPolls = true;
          if (!util.isNodeSdk()) {
              //Each script holder registers a couple of uniquely named callbacks with the window. These are called from the
              //iframes where we put the long-polling script tags. We have two callbacks:
              //   1) Command Callback - Triggered for control issues, like starting a connection.
              //   2) Message Callback - Triggered when new data arrives.
              this.uniqueCallbackIdentifier = LUIDGenerator();
              window[FIREBASE_LONGPOLL_COMMAND_CB_NAME + this.uniqueCallbackIdentifier] = commandCB;
              window[FIREBASE_LONGPOLL_DATA_CB_NAME + this.uniqueCallbackIdentifier] =
                  onMessageCB;
              //Create an iframe for us to add script tags to.
              this.myIFrame = FirebaseIFrameScriptHolder.createIFrame_();
              // Set the iframe's contents.
              var script = '';
              // if we set a javascript url, it's IE and we need to set the document domain. The javascript url is sufficient
              // for ie9, but ie8 needs to do it again in the document itself.
              if (this.myIFrame.src &&
                  this.myIFrame.src.substr(0, 'javascript:'.length) === 'javascript:') {
                  var currentDomain = document.domain;
                  script = '<script>document.domain="' + currentDomain + '";</script>';
              }
              var iframeContents = '<html><body>' + script + '</body></html>';
              try {
                  this.myIFrame.doc.open();
                  this.myIFrame.doc.write(iframeContents);
                  this.myIFrame.doc.close();
              }
              catch (e) {
                  log('frame writing exception');
                  if (e.stack) {
                      log(e.stack);
                  }
                  log(e);
              }
          }
          else {
              this.commandCB = commandCB;
              this.onMessageCB = onMessageCB;
          }
      }
      /**
       * Each browser has its own funny way to handle iframes. Here we mush them all together into one object that I can
       * actually use.
       */
      FirebaseIFrameScriptHolder.createIFrame_ = function () {
          var iframe = document.createElement('iframe');
          iframe.style.display = 'none';
          // This is necessary in order to initialize the document inside the iframe
          if (document.body) {
              document.body.appendChild(iframe);
              try {
                  // If document.domain has been modified in IE, this will throw an error, and we need to set the
                  // domain of the iframe's document manually. We can do this via a javascript: url as the src attribute
                  // Also note that we must do this *after* the iframe has been appended to the page. Otherwise it doesn't work.
                  var a = iframe.contentWindow.document;
                  if (!a) {
                      // Apologies for the log-spam, I need to do something to keep closure from optimizing out the assignment above.
                      log('No IE domain setting required');
                  }
              }
              catch (e) {
                  var domain = document.domain;
                  iframe.src =
                      "javascript:void((function(){document.open();document.domain='" +
                          domain +
                          "';document.close();})())";
              }
          }
          else {
              // LongPollConnection attempts to delay initialization until the document is ready, so hopefully this
              // never gets hit.
              throw 'Document body has not initialized. Wait to initialize Firebase until after the document is ready.';
          }
          // Get the document of the iframe in a browser-specific way.
          if (iframe.contentDocument) {
              iframe.doc = iframe.contentDocument; // Firefox, Opera, Safari
          }
          else if (iframe.contentWindow) {
              iframe.doc = iframe.contentWindow.document; // Internet Explorer
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
          }
          else if (iframe.document) {
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              iframe.doc = iframe.document; //others?
          }
          return iframe;
      };
      /**
       * Cancel all outstanding queries and remove the frame.
       */
      FirebaseIFrameScriptHolder.prototype.close = function () {
          var _this = this;
          //Mark this iframe as dead, so no new requests are sent.
          this.alive = false;
          if (this.myIFrame) {
              //We have to actually remove all of the html inside this iframe before removing it from the
              //window, or IE will continue loading and executing the script tags we've already added, which
              //can lead to some errors being thrown. Setting innerHTML seems to be the easiest way to do this.
              this.myIFrame.doc.body.innerHTML = '';
              setTimeout(function () {
                  if (_this.myIFrame !== null) {
                      document.body.removeChild(_this.myIFrame);
                      _this.myIFrame = null;
                  }
              }, Math.floor(0));
          }
          // Protect from being called recursively.
          var onDisconnect = this.onDisconnect;
          if (onDisconnect) {
              this.onDisconnect = null;
              onDisconnect();
          }
      };
      /**
       * Actually start the long-polling session by adding the first script tag(s) to the iframe.
       * @param id - The ID of this connection
       * @param pw - The password for this connection
       */
      FirebaseIFrameScriptHolder.prototype.startLongPoll = function (id, pw) {
          this.myID = id;
          this.myPW = pw;
          this.alive = true;
          //send the initial request. If there are requests queued, make sure that we transmit as many as we are currently able to.
          while (this.newRequest_()) { }
      };
      /**
       * This is called any time someone might want a script tag to be added. It adds a script tag when there aren't
       * too many outstanding requests and we are still alive.
       *
       * If there are outstanding packet segments to send, it sends one. If there aren't, it sends a long-poll anyways if
       * needed.
       */
      FirebaseIFrameScriptHolder.prototype.newRequest_ = function () {
          // We keep one outstanding request open all the time to receive data, but if we need to send data
          // (pendingSegs.length > 0) then we create a new request to send the data.  The server will automatically
          // close the old request.
          if (this.alive &&
              this.sendNewPolls &&
              this.outstandingRequests.size < (this.pendingSegs.length > 0 ? 2 : 1)) {
              //construct our url
              this.currentSerial++;
              var urlParams = {};
              urlParams[FIREBASE_LONGPOLL_ID_PARAM] = this.myID;
              urlParams[FIREBASE_LONGPOLL_PW_PARAM] = this.myPW;
              urlParams[FIREBASE_LONGPOLL_SERIAL_PARAM] = this.currentSerial;
              var theURL = this.urlFn(urlParams);
              //Now add as much data as we can.
              var curDataString = '';
              var i = 0;
              while (this.pendingSegs.length > 0) {
                  //first, lets see if the next segment will fit.
                  var nextSeg = this.pendingSegs[0];
                  if (nextSeg.d.length +
                      SEG_HEADER_SIZE +
                      curDataString.length <=
                      MAX_URL_DATA_SIZE) {
                      //great, the segment will fit. Lets append it.
                      var theSeg = this.pendingSegs.shift();
                      curDataString =
                          curDataString +
                              '&' +
                              FIREBASE_LONGPOLL_SEGMENT_NUM_PARAM +
                              i +
                              '=' +
                              theSeg.seg +
                              '&' +
                              FIREBASE_LONGPOLL_SEGMENTS_IN_PACKET +
                              i +
                              '=' +
                              theSeg.ts +
                              '&' +
                              FIREBASE_LONGPOLL_DATA_PARAM +
                              i +
                              '=' +
                              theSeg.d;
                      i++;
                  }
                  else {
                      break;
                  }
              }
              theURL = theURL + curDataString;
              this.addLongPollTag_(theURL, this.currentSerial);
              return true;
          }
          else {
              return false;
          }
      };
      /**
       * Queue a packet for transmission to the server.
       * @param segnum - A sequential id for this packet segment used for reassembly
       * @param totalsegs - The total number of segments in this packet
       * @param data - The data for this segment.
       */
      FirebaseIFrameScriptHolder.prototype.enqueueSegment = function (segnum, totalsegs, data) {
          //add this to the queue of segments to send.
          this.pendingSegs.push({ seg: segnum, ts: totalsegs, d: data });
          //send the data immediately if there isn't already data being transmitted, unless
          //startLongPoll hasn't been called yet.
          if (this.alive) {
              this.newRequest_();
          }
      };
      /**
       * Add a script tag for a regular long-poll request.
       * @param url - The URL of the script tag.
       * @param serial - The serial number of the request.
       */
      FirebaseIFrameScriptHolder.prototype.addLongPollTag_ = function (url, serial) {
          var _this = this;
          //remember that we sent this request.
          this.outstandingRequests.add(serial);
          var doNewRequest = function () {
              _this.outstandingRequests.delete(serial);
              _this.newRequest_();
          };
          // If this request doesn't return on its own accord (by the server sending us some data), we'll
          // create a new one after the KEEPALIVE interval to make sure we always keep a fresh request open.
          var keepaliveTimeout = setTimeout(doNewRequest, Math.floor(KEEPALIVE_REQUEST_INTERVAL));
          var readyStateCB = function () {
              // Request completed.  Cancel the keepalive.
              clearTimeout(keepaliveTimeout);
              // Trigger a new request so we can continue receiving data.
              doNewRequest();
          };
          this.addTag(url, readyStateCB);
      };
      /**
       * Add an arbitrary script tag to the iframe.
       * @param url - The URL for the script tag source.
       * @param loadCB - A callback to be triggered once the script has loaded.
       */
      FirebaseIFrameScriptHolder.prototype.addTag = function (url, loadCB) {
          var _this = this;
          if (util.isNodeSdk()) {
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              this.doNodeLongPoll(url, loadCB);
          }
          else {
              setTimeout(function () {
                  try {
                      // if we're already closed, don't add this poll
                      if (!_this.sendNewPolls) {
                          return;
                      }
                      var newScript_1 = _this.myIFrame.doc.createElement('script');
                      newScript_1.type = 'text/javascript';
                      newScript_1.async = true;
                      newScript_1.src = url;
                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
                      newScript_1.onload = newScript_1.onreadystatechange =
                          function () {
                              // eslint-disable-next-line @typescript-eslint/no-explicit-any
                              var rstate = newScript_1.readyState;
                              if (!rstate || rstate === 'loaded' || rstate === 'complete') {
                                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                  newScript_1.onload = newScript_1.onreadystatechange = null;
                                  if (newScript_1.parentNode) {
                                      newScript_1.parentNode.removeChild(newScript_1);
                                  }
                                  loadCB();
                              }
                          };
                      newScript_1.onerror = function () {
                          log('Long-poll script failed to load: ' + url);
                          _this.sendNewPolls = false;
                          _this.close();
                      };
                      _this.myIFrame.doc.body.appendChild(newScript_1);
                  }
                  catch (e) {
                      // TODO: we should make this error visible somehow
                  }
              }, Math.floor(1));
          }
      };
      return FirebaseIFrameScriptHolder;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Currently simplistic, this class manages what transport a Connection should use at various stages of its
   * lifecycle.
   *
   * It starts with longpolling in a browser, and httppolling on node. It then upgrades to websockets if
   * they are available.
   */
  var TransportManager = /** @class */ (function () {
      /**
       * @param repoInfo - Metadata around the namespace we're connecting to
       */
      function TransportManager(repoInfo) {
          this.initTransports_(repoInfo);
      }
      Object.defineProperty(TransportManager, "ALL_TRANSPORTS", {
          get: function () {
              return [BrowserPollConnection, WebSocketConnection];
          },
          enumerable: false,
          configurable: true
      });
      TransportManager.prototype.initTransports_ = function (repoInfo) {
          var e_1, _a;
          var isWebSocketsAvailable = WebSocketConnection && WebSocketConnection['isAvailable']();
          var isSkipPollConnection = isWebSocketsAvailable && !WebSocketConnection.previouslyFailed();
          if (repoInfo.webSocketOnly) {
              if (!isWebSocketsAvailable) {
                  warn("wss:// URL used, but browser isn't known to support websockets.  Trying anyway.");
              }
              isSkipPollConnection = true;
          }
          if (isSkipPollConnection) {
              this.transports_ = [WebSocketConnection];
          }
          else {
              var transports = (this.transports_ = []);
              try {
                  for (var _b = tslib.__values(TransportManager.ALL_TRANSPORTS), _c = _b.next(); !_c.done; _c = _b.next()) {
                      var transport = _c.value;
                      if (transport && transport['isAvailable']()) {
                          transports.push(transport);
                      }
                  }
              }
              catch (e_1_1) { e_1 = { error: e_1_1 }; }
              finally {
                  try {
                      if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                  }
                  finally { if (e_1) throw e_1.error; }
              }
          }
      };
      /**
       * @returns The constructor for the initial transport to use
       */
      TransportManager.prototype.initialTransport = function () {
          if (this.transports_.length > 0) {
              return this.transports_[0];
          }
          else {
              throw new Error('No transports available');
          }
      };
      /**
       * @returns The constructor for the next transport, or null
       */
      TransportManager.prototype.upgradeTransport = function () {
          if (this.transports_.length > 1) {
              return this.transports_[1];
          }
          else {
              return null;
          }
      };
      return TransportManager;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  // Abort upgrade attempt if it takes longer than 60s.
  var UPGRADE_TIMEOUT = 60000;
  // For some transports (WebSockets), we need to "validate" the transport by exchanging a few requests and responses.
  // If we haven't sent enough requests within 5s, we'll start sending noop ping requests.
  var DELAY_BEFORE_SENDING_EXTRA_REQUESTS = 5000;
  // If the initial data sent triggers a lot of bandwidth (i.e. it's a large put or a listen for a large amount of data)
  // then we may not be able to exchange our ping/pong requests within the healthy timeout.  So if we reach the timeout
  // but we've sent/received enough bytes, we don't cancel the connection.
  var BYTES_SENT_HEALTHY_OVERRIDE = 10 * 1024;
  var BYTES_RECEIVED_HEALTHY_OVERRIDE = 100 * 1024;
  var MESSAGE_TYPE = 't';
  var MESSAGE_DATA = 'd';
  var CONTROL_SHUTDOWN = 's';
  var CONTROL_RESET = 'r';
  var CONTROL_ERROR = 'e';
  var CONTROL_PONG = 'o';
  var SWITCH_ACK = 'a';
  var END_TRANSMISSION = 'n';
  var PING = 'p';
  var SERVER_HELLO = 'h';
  /**
   * Creates a new real-time connection to the server using whichever method works
   * best in the current browser.
   */
  var Connection = /** @class */ (function () {
      /**
       * @param id - an id for this connection
       * @param repoInfo_ - the info for the endpoint to connect to
       * @param applicationId_ - the Firebase App ID for this project
       * @param appCheckToken_ - The App Check Token for this device.
       * @param authToken_ - The auth token for this session.
       * @param onMessage_ - the callback to be triggered when a server-push message arrives
       * @param onReady_ - the callback to be triggered when this connection is ready to send messages.
       * @param onDisconnect_ - the callback to be triggered when a connection was lost
       * @param onKill_ - the callback to be triggered when this connection has permanently shut down.
       * @param lastSessionId - last session id in persistent connection. is used to clean up old session in real-time server
       */
      function Connection(id, repoInfo_, applicationId_, appCheckToken_, authToken_, onMessage_, onReady_, onDisconnect_, onKill_, lastSessionId) {
          this.id = id;
          this.repoInfo_ = repoInfo_;
          this.applicationId_ = applicationId_;
          this.appCheckToken_ = appCheckToken_;
          this.authToken_ = authToken_;
          this.onMessage_ = onMessage_;
          this.onReady_ = onReady_;
          this.onDisconnect_ = onDisconnect_;
          this.onKill_ = onKill_;
          this.lastSessionId = lastSessionId;
          this.connectionCount = 0;
          this.pendingDataMessages = [];
          this.state_ = 0 /* CONNECTING */;
          this.log_ = logWrapper('c:' + this.id + ':');
          this.transportManager_ = new TransportManager(repoInfo_);
          this.log_('Connection created');
          this.start_();
      }
      /**
       * Starts a connection attempt
       */
      Connection.prototype.start_ = function () {
          var _this = this;
          var conn = this.transportManager_.initialTransport();
          this.conn_ = new conn(this.nextTransportId_(), this.repoInfo_, this.applicationId_, this.appCheckToken_, this.authToken_, null, this.lastSessionId);
          // For certain transports (WebSockets), we need to send and receive several messages back and forth before we
          // can consider the transport healthy.
          this.primaryResponsesRequired_ = conn['responsesRequiredToBeHealthy'] || 0;
          var onMessageReceived = this.connReceiver_(this.conn_);
          var onConnectionLost = this.disconnReceiver_(this.conn_);
          this.tx_ = this.conn_;
          this.rx_ = this.conn_;
          this.secondaryConn_ = null;
          this.isHealthy_ = false;
          /*
           * Firefox doesn't like when code from one iframe tries to create another iframe by way of the parent frame.
           * This can occur in the case of a redirect, i.e. we guessed wrong on what server to connect to and received a reset.
           * Somehow, setTimeout seems to make this ok. That doesn't make sense from a security perspective, since you should
           * still have the context of your originating frame.
           */
          setTimeout(function () {
              // this.conn_ gets set to null in some of the tests. Check to make sure it still exists before using it
              _this.conn_ && _this.conn_.open(onMessageReceived, onConnectionLost);
          }, Math.floor(0));
          var healthyTimeoutMS = conn['healthyTimeout'] || 0;
          if (healthyTimeoutMS > 0) {
              this.healthyTimeout_ = setTimeoutNonBlocking(function () {
                  _this.healthyTimeout_ = null;
                  if (!_this.isHealthy_) {
                      if (_this.conn_ &&
                          _this.conn_.bytesReceived > BYTES_RECEIVED_HEALTHY_OVERRIDE) {
                          _this.log_('Connection exceeded healthy timeout but has received ' +
                              _this.conn_.bytesReceived +
                              ' bytes.  Marking connection healthy.');
                          _this.isHealthy_ = true;
                          _this.conn_.markConnectionHealthy();
                      }
                      else if (_this.conn_ &&
                          _this.conn_.bytesSent > BYTES_SENT_HEALTHY_OVERRIDE) {
                          _this.log_('Connection exceeded healthy timeout but has sent ' +
                              _this.conn_.bytesSent +
                              ' bytes.  Leaving connection alive.');
                          // NOTE: We don't want to mark it healthy, since we have no guarantee that the bytes have made it to
                          // the server.
                      }
                      else {
                          _this.log_('Closing unhealthy connection after timeout.');
                          _this.close();
                      }
                  }
                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
              }, Math.floor(healthyTimeoutMS));
          }
      };
      Connection.prototype.nextTransportId_ = function () {
          return 'c:' + this.id + ':' + this.connectionCount++;
      };
      Connection.prototype.disconnReceiver_ = function (conn) {
          var _this = this;
          return function (everConnected) {
              if (conn === _this.conn_) {
                  _this.onConnectionLost_(everConnected);
              }
              else if (conn === _this.secondaryConn_) {
                  _this.log_('Secondary connection lost.');
                  _this.onSecondaryConnectionLost_();
              }
              else {
                  _this.log_('closing an old connection');
              }
          };
      };
      Connection.prototype.connReceiver_ = function (conn) {
          var _this = this;
          return function (message) {
              if (_this.state_ !== 2 /* DISCONNECTED */) {
                  if (conn === _this.rx_) {
                      _this.onPrimaryMessageReceived_(message);
                  }
                  else if (conn === _this.secondaryConn_) {
                      _this.onSecondaryMessageReceived_(message);
                  }
                  else {
                      _this.log_('message on old connection');
                  }
              }
          };
      };
      /**
       * @param dataMsg - An arbitrary data message to be sent to the server
       */
      Connection.prototype.sendRequest = function (dataMsg) {
          // wrap in a data message envelope and send it on
          var msg = { t: 'd', d: dataMsg };
          this.sendData_(msg);
      };
      Connection.prototype.tryCleanupConnection = function () {
          if (this.tx_ === this.secondaryConn_ && this.rx_ === this.secondaryConn_) {
              this.log_('cleaning up and promoting a connection: ' + this.secondaryConn_.connId);
              this.conn_ = this.secondaryConn_;
              this.secondaryConn_ = null;
              // the server will shutdown the old connection
          }
      };
      Connection.prototype.onSecondaryControl_ = function (controlData) {
          if (MESSAGE_TYPE in controlData) {
              var cmd = controlData[MESSAGE_TYPE];
              if (cmd === SWITCH_ACK) {
                  this.upgradeIfSecondaryHealthy_();
              }
              else if (cmd === CONTROL_RESET) {
                  // Most likely the session wasn't valid. Abandon the switch attempt
                  this.log_('Got a reset on secondary, closing it');
                  this.secondaryConn_.close();
                  // If we were already using this connection for something, than we need to fully close
                  if (this.tx_ === this.secondaryConn_ ||
                      this.rx_ === this.secondaryConn_) {
                      this.close();
                  }
              }
              else if (cmd === CONTROL_PONG) {
                  this.log_('got pong on secondary.');
                  this.secondaryResponsesRequired_--;
                  this.upgradeIfSecondaryHealthy_();
              }
          }
      };
      Connection.prototype.onSecondaryMessageReceived_ = function (parsedData) {
          var layer = requireKey('t', parsedData);
          var data = requireKey('d', parsedData);
          if (layer === 'c') {
              this.onSecondaryControl_(data);
          }
          else if (layer === 'd') {
              // got a data message, but we're still second connection. Need to buffer it up
              this.pendingDataMessages.push(data);
          }
          else {
              throw new Error('Unknown protocol layer: ' + layer);
          }
      };
      Connection.prototype.upgradeIfSecondaryHealthy_ = function () {
          if (this.secondaryResponsesRequired_ <= 0) {
              this.log_('Secondary connection is healthy.');
              this.isHealthy_ = true;
              this.secondaryConn_.markConnectionHealthy();
              this.proceedWithUpgrade_();
          }
          else {
              // Send a ping to make sure the connection is healthy.
              this.log_('sending ping on secondary.');
              this.secondaryConn_.send({ t: 'c', d: { t: PING, d: {} } });
          }
      };
      Connection.prototype.proceedWithUpgrade_ = function () {
          // tell this connection to consider itself open
          this.secondaryConn_.start();
          // send ack
          this.log_('sending client ack on secondary');
          this.secondaryConn_.send({ t: 'c', d: { t: SWITCH_ACK, d: {} } });
          // send end packet on primary transport, switch to sending on this one
          // can receive on this one, buffer responses until end received on primary transport
          this.log_('Ending transmission on primary');
          this.conn_.send({ t: 'c', d: { t: END_TRANSMISSION, d: {} } });
          this.tx_ = this.secondaryConn_;
          this.tryCleanupConnection();
      };
      Connection.prototype.onPrimaryMessageReceived_ = function (parsedData) {
          // Must refer to parsedData properties in quotes, so closure doesn't touch them.
          var layer = requireKey('t', parsedData);
          var data = requireKey('d', parsedData);
          if (layer === 'c') {
              this.onControl_(data);
          }
          else if (layer === 'd') {
              this.onDataMessage_(data);
          }
      };
      Connection.prototype.onDataMessage_ = function (message) {
          this.onPrimaryResponse_();
          // We don't do anything with data messages, just kick them up a level
          this.onMessage_(message);
      };
      Connection.prototype.onPrimaryResponse_ = function () {
          if (!this.isHealthy_) {
              this.primaryResponsesRequired_--;
              if (this.primaryResponsesRequired_ <= 0) {
                  this.log_('Primary connection is healthy.');
                  this.isHealthy_ = true;
                  this.conn_.markConnectionHealthy();
              }
          }
      };
      Connection.prototype.onControl_ = function (controlData) {
          var cmd = requireKey(MESSAGE_TYPE, controlData);
          if (MESSAGE_DATA in controlData) {
              var payload = controlData[MESSAGE_DATA];
              if (cmd === SERVER_HELLO) {
                  this.onHandshake_(payload);
              }
              else if (cmd === END_TRANSMISSION) {
                  this.log_('recvd end transmission on primary');
                  this.rx_ = this.secondaryConn_;
                  for (var i = 0; i < this.pendingDataMessages.length; ++i) {
                      this.onDataMessage_(this.pendingDataMessages[i]);
                  }
                  this.pendingDataMessages = [];
                  this.tryCleanupConnection();
              }
              else if (cmd === CONTROL_SHUTDOWN) {
                  // This was previously the 'onKill' callback passed to the lower-level connection
                  // payload in this case is the reason for the shutdown. Generally a human-readable error
                  this.onConnectionShutdown_(payload);
              }
              else if (cmd === CONTROL_RESET) {
                  // payload in this case is the host we should contact
                  this.onReset_(payload);
              }
              else if (cmd === CONTROL_ERROR) {
                  error('Server Error: ' + payload);
              }
              else if (cmd === CONTROL_PONG) {
                  this.log_('got pong on primary.');
                  this.onPrimaryResponse_();
                  this.sendPingOnPrimaryIfNecessary_();
              }
              else {
                  error('Unknown control packet command: ' + cmd);
              }
          }
      };
      /**
       * @param handshake - The handshake data returned from the server
       */
      Connection.prototype.onHandshake_ = function (handshake) {
          var timestamp = handshake.ts;
          var version = handshake.v;
          var host = handshake.h;
          this.sessionId = handshake.s;
          this.repoInfo_.host = host;
          // if we've already closed the connection, then don't bother trying to progress further
          if (this.state_ === 0 /* CONNECTING */) {
              this.conn_.start();
              this.onConnectionEstablished_(this.conn_, timestamp);
              if (PROTOCOL_VERSION !== version) {
                  warn('Protocol version mismatch detected');
              }
              // TODO: do we want to upgrade? when? maybe a delay?
              this.tryStartUpgrade_();
          }
      };
      Connection.prototype.tryStartUpgrade_ = function () {
          var conn = this.transportManager_.upgradeTransport();
          if (conn) {
              this.startUpgrade_(conn);
          }
      };
      Connection.prototype.startUpgrade_ = function (conn) {
          var _this = this;
          this.secondaryConn_ = new conn(this.nextTransportId_(), this.repoInfo_, this.applicationId_, this.appCheckToken_, this.authToken_, this.sessionId);
          // For certain transports (WebSockets), we need to send and receive several messages back and forth before we
          // can consider the transport healthy.
          this.secondaryResponsesRequired_ =
              conn['responsesRequiredToBeHealthy'] || 0;
          var onMessage = this.connReceiver_(this.secondaryConn_);
          var onDisconnect = this.disconnReceiver_(this.secondaryConn_);
          this.secondaryConn_.open(onMessage, onDisconnect);
          // If we haven't successfully upgraded after UPGRADE_TIMEOUT, give up and kill the secondary.
          setTimeoutNonBlocking(function () {
              if (_this.secondaryConn_) {
                  _this.log_('Timed out trying to upgrade.');
                  _this.secondaryConn_.close();
              }
          }, Math.floor(UPGRADE_TIMEOUT));
      };
      Connection.prototype.onReset_ = function (host) {
          this.log_('Reset packet received.  New host: ' + host);
          this.repoInfo_.host = host;
          // TODO: if we're already "connected", we need to trigger a disconnect at the next layer up.
          // We don't currently support resets after the connection has already been established
          if (this.state_ === 1 /* CONNECTED */) {
              this.close();
          }
          else {
              // Close whatever connections we have open and start again.
              this.closeConnections_();
              this.start_();
          }
      };
      Connection.prototype.onConnectionEstablished_ = function (conn, timestamp) {
          var _this = this;
          this.log_('Realtime connection established.');
          this.conn_ = conn;
          this.state_ = 1 /* CONNECTED */;
          if (this.onReady_) {
              this.onReady_(timestamp, this.sessionId);
              this.onReady_ = null;
          }
          // If after 5 seconds we haven't sent enough requests to the server to get the connection healthy,
          // send some pings.
          if (this.primaryResponsesRequired_ === 0) {
              this.log_('Primary connection is healthy.');
              this.isHealthy_ = true;
          }
          else {
              setTimeoutNonBlocking(function () {
                  _this.sendPingOnPrimaryIfNecessary_();
              }, Math.floor(DELAY_BEFORE_SENDING_EXTRA_REQUESTS));
          }
      };
      Connection.prototype.sendPingOnPrimaryIfNecessary_ = function () {
          // If the connection isn't considered healthy yet, we'll send a noop ping packet request.
          if (!this.isHealthy_ && this.state_ === 1 /* CONNECTED */) {
              this.log_('sending ping on primary.');
              this.sendData_({ t: 'c', d: { t: PING, d: {} } });
          }
      };
      Connection.prototype.onSecondaryConnectionLost_ = function () {
          var conn = this.secondaryConn_;
          this.secondaryConn_ = null;
          if (this.tx_ === conn || this.rx_ === conn) {
              // we are relying on this connection already in some capacity. Therefore, a failure is real
              this.close();
          }
      };
      /**
       * @param everConnected - Whether or not the connection ever reached a server. Used to determine if
       * we should flush the host cache
       */
      Connection.prototype.onConnectionLost_ = function (everConnected) {
          this.conn_ = null;
          // NOTE: IF you're seeing a Firefox error for this line, I think it might be because it's getting
          // called on window close and RealtimeState.CONNECTING is no longer defined.  Just a guess.
          if (!everConnected && this.state_ === 0 /* CONNECTING */) {
              this.log_('Realtime connection failed.');
              // Since we failed to connect at all, clear any cached entry for this namespace in case the machine went away
              if (this.repoInfo_.isCacheableHost()) {
                  PersistentStorage.remove('host:' + this.repoInfo_.host);
                  // reset the internal host to what we would show the user, i.e. <ns>.firebaseio.com
                  this.repoInfo_.internalHost = this.repoInfo_.host;
              }
          }
          else if (this.state_ === 1 /* CONNECTED */) {
              this.log_('Realtime connection lost.');
          }
          this.close();
      };
      Connection.prototype.onConnectionShutdown_ = function (reason) {
          this.log_('Connection shutdown command received. Shutting down...');
          if (this.onKill_) {
              this.onKill_(reason);
              this.onKill_ = null;
          }
          // We intentionally don't want to fire onDisconnect (kill is a different case),
          // so clear the callback.
          this.onDisconnect_ = null;
          this.close();
      };
      Connection.prototype.sendData_ = function (data) {
          if (this.state_ !== 1 /* CONNECTED */) {
              throw 'Connection is not connected';
          }
          else {
              this.tx_.send(data);
          }
      };
      /**
       * Cleans up this connection, calling the appropriate callbacks
       */
      Connection.prototype.close = function () {
          if (this.state_ !== 2 /* DISCONNECTED */) {
              this.log_('Closing realtime connection.');
              this.state_ = 2 /* DISCONNECTED */;
              this.closeConnections_();
              if (this.onDisconnect_) {
                  this.onDisconnect_();
                  this.onDisconnect_ = null;
              }
          }
      };
      Connection.prototype.closeConnections_ = function () {
          this.log_('Shutting down all connections');
          if (this.conn_) {
              this.conn_.close();
              this.conn_ = null;
          }
          if (this.secondaryConn_) {
              this.secondaryConn_.close();
              this.secondaryConn_ = null;
          }
          if (this.healthyTimeout_) {
              clearTimeout(this.healthyTimeout_);
              this.healthyTimeout_ = null;
          }
      };
      return Connection;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Interface defining the set of actions that can be performed against the Firebase server
   * (basically corresponds to our wire protocol).
   *
   * @interface
   */
  var ServerActions = /** @class */ (function () {
      function ServerActions() {
      }
      ServerActions.prototype.put = function (pathString, data, onComplete, hash) { };
      ServerActions.prototype.merge = function (pathString, data, onComplete, hash) { };
      /**
       * Refreshes the auth token for the current connection.
       * @param token - The authentication token
       */
      ServerActions.prototype.refreshAuthToken = function (token) { };
      /**
       * Refreshes the app check token for the current connection.
       * @param token The app check token
       */
      ServerActions.prototype.refreshAppCheckToken = function (token) { };
      ServerActions.prototype.onDisconnectPut = function (pathString, data, onComplete) { };
      ServerActions.prototype.onDisconnectMerge = function (pathString, data, onComplete) { };
      ServerActions.prototype.onDisconnectCancel = function (pathString, onComplete) { };
      ServerActions.prototype.reportStats = function (stats) { };
      return ServerActions;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Base class to be used if you want to emit events. Call the constructor with
   * the set of allowed event names.
   */
  var EventEmitter = /** @class */ (function () {
      function EventEmitter(allowedEvents_) {
          this.allowedEvents_ = allowedEvents_;
          this.listeners_ = {};
          util.assert(Array.isArray(allowedEvents_) && allowedEvents_.length > 0, 'Requires a non-empty array');
      }
      /**
       * To be called by derived classes to trigger events.
       */
      EventEmitter.prototype.trigger = function (eventType) {
          var varArgs = [];
          for (var _i = 1; _i < arguments.length; _i++) {
              varArgs[_i - 1] = arguments[_i];
          }
          if (Array.isArray(this.listeners_[eventType])) {
              // Clone the list, since callbacks could add/remove listeners.
              var listeners = tslib.__spreadArray([], tslib.__read(this.listeners_[eventType]));
              for (var i = 0; i < listeners.length; i++) {
                  listeners[i].callback.apply(listeners[i].context, varArgs);
              }
          }
      };
      EventEmitter.prototype.on = function (eventType, callback, context) {
          this.validateEventType_(eventType);
          this.listeners_[eventType] = this.listeners_[eventType] || [];
          this.listeners_[eventType].push({ callback: callback, context: context });
          var eventData = this.getInitialEvent(eventType);
          if (eventData) {
              callback.apply(context, eventData);
          }
      };
      EventEmitter.prototype.off = function (eventType, callback, context) {
          this.validateEventType_(eventType);
          var listeners = this.listeners_[eventType] || [];
          for (var i = 0; i < listeners.length; i++) {
              if (listeners[i].callback === callback &&
                  (!context || context === listeners[i].context)) {
                  listeners.splice(i, 1);
                  return;
              }
          }
      };
      EventEmitter.prototype.validateEventType_ = function (eventType) {
          util.assert(this.allowedEvents_.find(function (et) {
              return et === eventType;
          }), 'Unknown event: ' + eventType);
      };
      return EventEmitter;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Monitors online state (as reported by window.online/offline events).
   *
   * The expectation is that this could have many false positives (thinks we are online
   * when we're not), but no false negatives.  So we can safely use it to determine when
   * we definitely cannot reach the internet.
   */
  var OnlineMonitor = /** @class */ (function (_super) {
      tslib.__extends(OnlineMonitor, _super);
      function OnlineMonitor() {
          var _this = _super.call(this, ['online']) || this;
          _this.online_ = true;
          // We've had repeated complaints that Cordova apps can get stuck "offline", e.g.
          // https://forum.ionicframework.com/t/firebase-connection-is-lost-and-never-come-back/43810
          // It would seem that the 'online' event does not always fire consistently. So we disable it
          // for Cordova.
          if (typeof window !== 'undefined' &&
              typeof window.addEventListener !== 'undefined' &&
              !util.isMobileCordova()) {
              window.addEventListener('online', function () {
                  if (!_this.online_) {
                      _this.online_ = true;
                      _this.trigger('online', true);
                  }
              }, false);
              window.addEventListener('offline', function () {
                  if (_this.online_) {
                      _this.online_ = false;
                      _this.trigger('online', false);
                  }
              }, false);
          }
          return _this;
      }
      OnlineMonitor.getInstance = function () {
          return new OnlineMonitor();
      };
      OnlineMonitor.prototype.getInitialEvent = function (eventType) {
          util.assert(eventType === 'online', 'Unknown event type: ' + eventType);
          return [this.online_];
      };
      OnlineMonitor.prototype.currentlyOnline = function () {
          return this.online_;
      };
      return OnlineMonitor;
  }(EventEmitter));
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /** Maximum key depth. */
  var MAX_PATH_DEPTH = 32;
  /** Maximum number of (UTF8) bytes in a Firebase path. */
  var MAX_PATH_LENGTH_BYTES = 768;
  /**
   * An immutable object representing a parsed path.  It's immutable so that you
   * can pass them around to other functions without worrying about them changing
   * it.
   */
  var Path = /** @class */ (function () {
      /**
       * @param pathOrString - Path string to parse, or another path, or the raw
       * tokens array
       */
      function Path(pathOrString, pieceNum) {
          if (pieceNum === void 0) {
              this.pieces_ = pathOrString.split('/');
              // Remove empty pieces.
              var copyTo = 0;
              for (var i = 0; i < this.pieces_.length; i++) {
                  if (this.pieces_[i].length > 0) {
                      this.pieces_[copyTo] = this.pieces_[i];
                      copyTo++;
                  }
              }
              this.pieces_.length = copyTo;
              this.pieceNum_ = 0;
          }
          else {
              this.pieces_ = pathOrString;
              this.pieceNum_ = pieceNum;
          }
      }
      Path.prototype.toString = function () {
          var pathString = '';
          for (var i = this.pieceNum_; i < this.pieces_.length; i++) {
              if (this.pieces_[i] !== '') {
                  pathString += '/' + this.pieces_[i];
              }
          }
          return pathString || '/';
      };
      return Path;
  }());
  function newEmptyPath() {
      return new Path('');
  }
  function pathGetFront(path) {
      if (path.pieceNum_ >= path.pieces_.length) {
          return null;
      }
      return path.pieces_[path.pieceNum_];
  }
  /**
   * @returns The number of segments in this path
   */
  function pathGetLength(path) {
      return path.pieces_.length - path.pieceNum_;
  }
  function pathPopFront(path) {
      var pieceNum = path.pieceNum_;
      if (pieceNum < path.pieces_.length) {
          pieceNum++;
      }
      return new Path(path.pieces_, pieceNum);
  }
  function pathGetBack(path) {
      if (path.pieceNum_ < path.pieces_.length) {
          return path.pieces_[path.pieces_.length - 1];
      }
      return null;
  }
  function pathToUrlEncodedString(path) {
      var pathString = '';
      for (var i = path.pieceNum_; i < path.pieces_.length; i++) {
          if (path.pieces_[i] !== '') {
              pathString += '/' + encodeURIComponent(String(path.pieces_[i]));
          }
      }
      return pathString || '/';
  }
  /**
   * Shallow copy of the parts of the path.
   *
   */
  function pathSlice(path, begin) {
      if (begin === void 0) { begin = 0; }
      return path.pieces_.slice(path.pieceNum_ + begin);
  }
  function pathParent(path) {
      if (path.pieceNum_ >= path.pieces_.length) {
          return null;
      }
      var pieces = [];
      for (var i = path.pieceNum_; i < path.pieces_.length - 1; i++) {
          pieces.push(path.pieces_[i]);
      }
      return new Path(pieces, 0);
  }
  function pathChild(path, childPathObj) {
      var pieces = [];
      for (var i = path.pieceNum_; i < path.pieces_.length; i++) {
          pieces.push(path.pieces_[i]);
      }
      if (childPathObj instanceof Path) {
          for (var i = childPathObj.pieceNum_; i < childPathObj.pieces_.length; i++) {
              pieces.push(childPathObj.pieces_[i]);
          }
      }
      else {
          var childPieces = childPathObj.split('/');
          for (var i = 0; i < childPieces.length; i++) {
              if (childPieces[i].length > 0) {
                  pieces.push(childPieces[i]);
              }
          }
      }
      return new Path(pieces, 0);
  }
  /**
   * @returns True if there are no segments in this path
   */
  function pathIsEmpty(path) {
      return path.pieceNum_ >= path.pieces_.length;
  }
  /**
   * @returns The path from outerPath to innerPath
   */
  function newRelativePath(outerPath, innerPath) {
      var outer = pathGetFront(outerPath), inner = pathGetFront(innerPath);
      if (outer === null) {
          return innerPath;
      }
      else if (outer === inner) {
          return newRelativePath(pathPopFront(outerPath), pathPopFront(innerPath));
      }
      else {
          throw new Error('INTERNAL ERROR: innerPath (' +
              innerPath +
              ') is not within ' +
              'outerPath (' +
              outerPath +
              ')');
      }
  }
  /**
   * @returns -1, 0, 1 if left is less, equal, or greater than the right.
   */
  function pathCompare(left, right) {
      var leftKeys = pathSlice(left, 0);
      var rightKeys = pathSlice(right, 0);
      for (var i = 0; i < leftKeys.length && i < rightKeys.length; i++) {
          var cmp = nameCompare(leftKeys[i], rightKeys[i]);
          if (cmp !== 0) {
              return cmp;
          }
      }
      if (leftKeys.length === rightKeys.length) {
          return 0;
      }
      return leftKeys.length < rightKeys.length ? -1 : 1;
  }
  /**
   * @returns true if paths are the same.
   */
  function pathEquals(path, other) {
      if (pathGetLength(path) !== pathGetLength(other)) {
          return false;
      }
      for (var i = path.pieceNum_, j = other.pieceNum_; i <= path.pieces_.length; i++, j++) {
          if (path.pieces_[i] !== other.pieces_[j]) {
              return false;
          }
      }
      return true;
  }
  /**
   * @returns True if this path is a parent (or the same as) other
   */
  function pathContains(path, other) {
      var i = path.pieceNum_;
      var j = other.pieceNum_;
      if (pathGetLength(path) > pathGetLength(other)) {
          return false;
      }
      while (i < path.pieces_.length) {
          if (path.pieces_[i] !== other.pieces_[j]) {
              return false;
          }
          ++i;
          ++j;
      }
      return true;
  }
  /**
   * Dynamic (mutable) path used to count path lengths.
   *
   * This class is used to efficiently check paths for valid
   * length (in UTF8 bytes) and depth (used in path validation).
   *
   * Throws Error exception if path is ever invalid.
   *
   * The definition of a path always begins with '/'.
   */
  var ValidationPath = /** @class */ (function () {
      /**
       * @param path - Initial Path.
       * @param errorPrefix_ - Prefix for any error messages.
       */
      function ValidationPath(path, errorPrefix_) {
          this.errorPrefix_ = errorPrefix_;
          this.parts_ = pathSlice(path, 0);
          /** Initialize to number of '/' chars needed in path. */
          this.byteLength_ = Math.max(1, this.parts_.length);
          for (var i = 0; i < this.parts_.length; i++) {
              this.byteLength_ += util.stringLength(this.parts_[i]);
          }
          validationPathCheckValid(this);
      }
      return ValidationPath;
  }());
  function validationPathPush(validationPath, child) {
      // Count the needed '/'
      if (validationPath.parts_.length > 0) {
          validationPath.byteLength_ += 1;
      }
      validationPath.parts_.push(child);
      validationPath.byteLength_ += util.stringLength(child);
      validationPathCheckValid(validationPath);
  }
  function validationPathPop(validationPath) {
      var last = validationPath.parts_.pop();
      validationPath.byteLength_ -= util.stringLength(last);
      // Un-count the previous '/'
      if (validationPath.parts_.length > 0) {
          validationPath.byteLength_ -= 1;
      }
  }
  function validationPathCheckValid(validationPath) {
      if (validationPath.byteLength_ > MAX_PATH_LENGTH_BYTES) {
          throw new Error(validationPath.errorPrefix_ +
              'has a key path longer than ' +
              MAX_PATH_LENGTH_BYTES +
              ' bytes (' +
              validationPath.byteLength_ +
              ').');
      }
      if (validationPath.parts_.length > MAX_PATH_DEPTH) {
          throw new Error(validationPath.errorPrefix_ +
              'path specified exceeds the maximum depth that can be written (' +
              MAX_PATH_DEPTH +
              ') or object contains a cycle ' +
              validationPathToErrorString(validationPath));
      }
  }
  /**
   * String for use in error messages - uses '.' notation for path.
   */
  function validationPathToErrorString(validationPath) {
      if (validationPath.parts_.length === 0) {
          return '';
      }
      return "in property '" + validationPath.parts_.join('.') + "'";
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var VisibilityMonitor = /** @class */ (function (_super) {
      tslib.__extends(VisibilityMonitor, _super);
      function VisibilityMonitor() {
          var _this = _super.call(this, ['visible']) || this;
          var hidden;
          var visibilityChange;
          if (typeof document !== 'undefined' &&
              typeof document.addEventListener !== 'undefined') {
              if (typeof document['hidden'] !== 'undefined') {
                  // Opera 12.10 and Firefox 18 and later support
                  visibilityChange = 'visibilitychange';
                  hidden = 'hidden';
              }
              else if (typeof document['mozHidden'] !== 'undefined') {
                  visibilityChange = 'mozvisibilitychange';
                  hidden = 'mozHidden';
              }
              else if (typeof document['msHidden'] !== 'undefined') {
                  visibilityChange = 'msvisibilitychange';
                  hidden = 'msHidden';
              }
              else if (typeof document['webkitHidden'] !== 'undefined') {
                  visibilityChange = 'webkitvisibilitychange';
                  hidden = 'webkitHidden';
              }
          }
          // Initially, we always assume we are visible. This ensures that in browsers
          // without page visibility support or in cases where we are never visible
          // (e.g. chrome extension), we act as if we are visible, i.e. don't delay
          // reconnects
          _this.visible_ = true;
          if (visibilityChange) {
              document.addEventListener(visibilityChange, function () {
                  var visible = !document[hidden];
                  if (visible !== _this.visible_) {
                      _this.visible_ = visible;
                      _this.trigger('visible', visible);
                  }
              }, false);
          }
          return _this;
      }
      VisibilityMonitor.getInstance = function () {
          return new VisibilityMonitor();
      };
      VisibilityMonitor.prototype.getInitialEvent = function (eventType) {
          util.assert(eventType === 'visible', 'Unknown event type: ' + eventType);
          return [this.visible_];
      };
      return VisibilityMonitor;
  }(EventEmitter));
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var RECONNECT_MIN_DELAY = 1000;
  var RECONNECT_MAX_DELAY_DEFAULT = 60 * 5 * 1000; // 5 minutes in milliseconds (Case: 1858)
  var GET_CONNECT_TIMEOUT = 3 * 1000;
  var RECONNECT_MAX_DELAY_FOR_ADMINS = 30 * 1000; // 30 seconds for admin clients (likely to be a backend server)
  var RECONNECT_DELAY_MULTIPLIER = 1.3;
  var RECONNECT_DELAY_RESET_TIMEOUT = 30000; // Reset delay back to MIN_DELAY after being connected for 30sec.
  var SERVER_KILL_INTERRUPT_REASON = 'server_kill';
  // If auth fails repeatedly, we'll assume something is wrong and log a warning / back off.
  var INVALID_TOKEN_THRESHOLD = 3;
  /**
   * Firebase connection.  Abstracts wire protocol and handles reconnecting.
   *
   * NOTE: All JSON objects sent to the realtime connection must have property names enclosed
   * in quotes to make sure the closure compiler does not minify them.
   */
  var PersistentConnection = /** @class */ (function (_super) {
      tslib.__extends(PersistentConnection, _super);
      /**
       * @param repoInfo_ - Data about the namespace we are connecting to
       * @param applicationId_ - The Firebase App ID for this project
       * @param onDataUpdate_ - A callback for new data from the server
       */
      function PersistentConnection(repoInfo_, applicationId_, onDataUpdate_, onConnectStatus_, onServerInfoUpdate_, authTokenProvider_, appCheckTokenProvider_, authOverride_) {
          var _this = _super.call(this) || this;
          _this.repoInfo_ = repoInfo_;
          _this.applicationId_ = applicationId_;
          _this.onDataUpdate_ = onDataUpdate_;
          _this.onConnectStatus_ = onConnectStatus_;
          _this.onServerInfoUpdate_ = onServerInfoUpdate_;
          _this.authTokenProvider_ = authTokenProvider_;
          _this.appCheckTokenProvider_ = appCheckTokenProvider_;
          _this.authOverride_ = authOverride_;
          // Used for diagnostic logging.
          _this.id = PersistentConnection.nextPersistentConnectionId_++;
          _this.log_ = logWrapper('p:' + _this.id + ':');
          _this.interruptReasons_ = {};
          _this.listens = new Map();
          _this.outstandingPuts_ = [];
          _this.outstandingGets_ = [];
          _this.outstandingPutCount_ = 0;
          _this.outstandingGetCount_ = 0;
          _this.onDisconnectRequestQueue_ = [];
          _this.connected_ = false;
          _this.reconnectDelay_ = RECONNECT_MIN_DELAY;
          _this.maxReconnectDelay_ = RECONNECT_MAX_DELAY_DEFAULT;
          _this.securityDebugCallback_ = null;
          _this.lastSessionId = null;
          _this.establishConnectionTimer_ = null;
          _this.visible_ = false;
          // Before we get connected, we keep a queue of pending messages to send.
          _this.requestCBHash_ = {};
          _this.requestNumber_ = 0;
          _this.realtime_ = null;
          _this.authToken_ = null;
          _this.appCheckToken_ = null;
          _this.forceTokenRefresh_ = false;
          _this.invalidAuthTokenCount_ = 0;
          _this.invalidAppCheckTokenCount_ = 0;
          _this.firstConnection_ = true;
          _this.lastConnectionAttemptTime_ = null;
          _this.lastConnectionEstablishedTime_ = null;
          if (authOverride_ && !util.isNodeSdk()) {
              throw new Error('Auth override specified in options, but not supported on non Node.js platforms');
          }
          VisibilityMonitor.getInstance().on('visible', _this.onVisible_, _this);
          if (repoInfo_.host.indexOf('fblocal') === -1) {
              OnlineMonitor.getInstance().on('online', _this.onOnline_, _this);
          }
          return _this;
      }
      PersistentConnection.prototype.sendRequest = function (action, body, onResponse) {
          var curReqNum = ++this.requestNumber_;
          var msg = { r: curReqNum, a: action, b: body };
          this.log_(util.stringify(msg));
          util.assert(this.connected_, "sendRequest call when we're not connected not allowed.");
          this.realtime_.sendRequest(msg);
          if (onResponse) {
              this.requestCBHash_[curReqNum] = onResponse;
          }
      };
      PersistentConnection.prototype.get = function (query) {
          var _this = this;
          this.initConnection_();
          var deferred = new util.Deferred();
          var request = {
              p: query._path.toString(),
              q: query._queryObject
          };
          var outstandingGet = {
              action: 'g',
              request: request,
              onComplete: function (message) {
                  var payload = message['d'];
                  if (message['s'] === 'ok') {
                      _this.onDataUpdate_(request['p'], payload, 
                      /*isMerge*/ false, 
                      /*tag*/ null);
                      deferred.resolve(payload);
                  }
                  else {
                      deferred.reject(payload);
                  }
              }
          };
          this.outstandingGets_.push(outstandingGet);
          this.outstandingGetCount_++;
          var index = this.outstandingGets_.length - 1;
          if (!this.connected_) {
              setTimeout(function () {
                  var get = _this.outstandingGets_[index];
                  if (get === undefined || outstandingGet !== get) {
                      return;
                  }
                  delete _this.outstandingGets_[index];
                  _this.outstandingGetCount_--;
                  if (_this.outstandingGetCount_ === 0) {
                      _this.outstandingGets_ = [];
                  }
                  _this.log_('get ' + index + ' timed out on connection');
                  deferred.reject(new Error('Client is offline.'));
              }, GET_CONNECT_TIMEOUT);
          }
          if (this.connected_) {
              this.sendGet_(index);
          }
          return deferred.promise;
      };
      PersistentConnection.prototype.listen = function (query, currentHashFn, tag, onComplete) {
          this.initConnection_();
          var queryId = query._queryIdentifier;
          var pathString = query._path.toString();
          this.log_('Listen called for ' + pathString + ' ' + queryId);
          if (!this.listens.has(pathString)) {
              this.listens.set(pathString, new Map());
          }
          util.assert(query._queryParams.isDefault() || !query._queryParams.loadsAllData(), 'listen() called for non-default but complete query');
          util.assert(!this.listens.get(pathString).has(queryId), 'listen() called twice for same path/queryId.');
          var listenSpec = {
              onComplete: onComplete,
              hashFn: currentHashFn,
              query: query,
              tag: tag
          };
          this.listens.get(pathString).set(queryId, listenSpec);
          if (this.connected_) {
              this.sendListen_(listenSpec);
          }
      };
      PersistentConnection.prototype.sendGet_ = function (index) {
          var _this = this;
          var get = this.outstandingGets_[index];
          this.sendRequest('g', get.request, function (message) {
              delete _this.outstandingGets_[index];
              _this.outstandingGetCount_--;
              if (_this.outstandingGetCount_ === 0) {
                  _this.outstandingGets_ = [];
              }
              if (get.onComplete) {
                  get.onComplete(message);
              }
          });
      };
      PersistentConnection.prototype.sendListen_ = function (listenSpec) {
          var _this = this;
          var query = listenSpec.query;
          var pathString = query._path.toString();
          var queryId = query._queryIdentifier;
          this.log_('Listen on ' + pathString + ' for ' + queryId);
          var req = { /*path*/ p: pathString };
          var action = 'q';
          // Only bother to send query if it's non-default.
          if (listenSpec.tag) {
              req['q'] = query._queryObject;
              req['t'] = listenSpec.tag;
          }
          req[ /*hash*/'h'] = listenSpec.hashFn();
          this.sendRequest(action, req, function (message) {
              var payload = message[ /*data*/'d'];
              var status = message[ /*status*/'s'];
              // print warnings in any case...
              PersistentConnection.warnOnListenWarnings_(payload, query);
              var currentListenSpec = _this.listens.get(pathString) &&
                  _this.listens.get(pathString).get(queryId);
              // only trigger actions if the listen hasn't been removed and readded
              if (currentListenSpec === listenSpec) {
                  _this.log_('listen response', message);
                  if (status !== 'ok') {
                      _this.removeListen_(pathString, queryId);
                  }
                  if (listenSpec.onComplete) {
                      listenSpec.onComplete(status, payload);
                  }
              }
          });
      };
      PersistentConnection.warnOnListenWarnings_ = function (payload, query) {
          if (payload && typeof payload === 'object' && util.contains(payload, 'w')) {
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              var warnings = util.safeGet(payload, 'w');
              if (Array.isArray(warnings) && ~warnings.indexOf('no_index')) {
                  var indexSpec = '".indexOn": "' + query._queryParams.getIndex().toString() + '"';
                  var indexPath = query._path.toString();
                  warn("Using an unspecified index. Your data will be downloaded and " +
                      ("filtered on the client. Consider adding " + indexSpec + " at ") +
                      (indexPath + " to your security rules for better performance."));
              }
          }
      };
      PersistentConnection.prototype.refreshAuthToken = function (token) {
          this.authToken_ = token;
          this.log_('Auth token refreshed');
          if (this.authToken_) {
              this.tryAuth();
          }
          else {
              //If we're connected we want to let the server know to unauthenticate us. If we're not connected, simply delete
              //the credential so we dont become authenticated next time we connect.
              if (this.connected_) {
                  this.sendRequest('unauth', {}, function () { });
              }
          }
          this.reduceReconnectDelayIfAdminCredential_(token);
      };
      PersistentConnection.prototype.reduceReconnectDelayIfAdminCredential_ = function (credential) {
          // NOTE: This isn't intended to be bulletproof (a malicious developer can always just modify the client).
          // Additionally, we don't bother resetting the max delay back to the default if auth fails / expires.
          var isFirebaseSecret = credential && credential.length === 40;
          if (isFirebaseSecret || util.isAdmin(credential)) {
              this.log_('Admin auth credential detected.  Reducing max reconnect time.');
              this.maxReconnectDelay_ = RECONNECT_MAX_DELAY_FOR_ADMINS;
          }
      };
      PersistentConnection.prototype.refreshAppCheckToken = function (token) {
          this.appCheckToken_ = token;
          this.log_('App check token refreshed');
          if (this.appCheckToken_) {
              this.tryAppCheck();
          }
          else {
              //If we're connected we want to let the server know to unauthenticate us.
              //If we're not connected, simply delete the credential so we dont become
              // authenticated next time we connect.
              if (this.connected_) {
                  this.sendRequest('unappeck', {}, function () { });
              }
          }
      };
      /**
       * Attempts to authenticate with the given credentials. If the authentication attempt fails, it's triggered like
       * a auth revoked (the connection is closed).
       */
      PersistentConnection.prototype.tryAuth = function () {
          var _this = this;
          if (this.connected_ && this.authToken_) {
              var token_1 = this.authToken_;
              var authMethod = util.isValidFormat(token_1) ? 'auth' : 'gauth';
              var requestData = { cred: token_1 };
              if (this.authOverride_ === null) {
                  requestData['noauth'] = true;
              }
              else if (typeof this.authOverride_ === 'object') {
                  requestData['authvar'] = this.authOverride_;
              }
              this.sendRequest(authMethod, requestData, function (res) {
                  var status = res[ /*status*/'s'];
                  var data = res[ /*data*/'d'] || 'error';
                  if (_this.authToken_ === token_1) {
                      if (status === 'ok') {
                          _this.invalidAuthTokenCount_ = 0;
                      }
                      else {
                          // Triggers reconnect and force refresh for auth token
                          _this.onAuthRevoked_(status, data);
                      }
                  }
              });
          }
      };
      /**
       * Attempts to authenticate with the given token. If the authentication
       * attempt fails, it's triggered like the token was revoked (the connection is
       * closed).
       */
      PersistentConnection.prototype.tryAppCheck = function () {
          var _this = this;
          if (this.connected_ && this.appCheckToken_) {
              this.sendRequest('appcheck', { 'token': this.appCheckToken_ }, function (res) {
                  var status = res[ /*status*/'s'];
                  var data = res[ /*data*/'d'] || 'error';
                  if (status === 'ok') {
                      _this.invalidAppCheckTokenCount_ = 0;
                  }
                  else {
                      _this.onAppCheckRevoked_(status, data);
                  }
              });
          }
      };
      /**
       * @inheritDoc
       */
      PersistentConnection.prototype.unlisten = function (query, tag) {
          var pathString = query._path.toString();
          var queryId = query._queryIdentifier;
          this.log_('Unlisten called for ' + pathString + ' ' + queryId);
          util.assert(query._queryParams.isDefault() || !query._queryParams.loadsAllData(), 'unlisten() called for non-default but complete query');
          var listen = this.removeListen_(pathString, queryId);
          if (listen && this.connected_) {
              this.sendUnlisten_(pathString, queryId, query._queryObject, tag);
          }
      };
      PersistentConnection.prototype.sendUnlisten_ = function (pathString, queryId, queryObj, tag) {
          this.log_('Unlisten on ' + pathString + ' for ' + queryId);
          var req = { /*path*/ p: pathString };
          var action = 'n';
          // Only bother sending queryId if it's non-default.
          if (tag) {
              req['q'] = queryObj;
              req['t'] = tag;
          }
          this.sendRequest(action, req);
      };
      PersistentConnection.prototype.onDisconnectPut = function (pathString, data, onComplete) {
          this.initConnection_();
          if (this.connected_) {
              this.sendOnDisconnect_('o', pathString, data, onComplete);
          }
          else {
              this.onDisconnectRequestQueue_.push({
                  pathString: pathString,
                  action: 'o',
                  data: data,
                  onComplete: onComplete
              });
          }
      };
      PersistentConnection.prototype.onDisconnectMerge = function (pathString, data, onComplete) {
          this.initConnection_();
          if (this.connected_) {
              this.sendOnDisconnect_('om', pathString, data, onComplete);
          }
          else {
              this.onDisconnectRequestQueue_.push({
                  pathString: pathString,
                  action: 'om',
                  data: data,
                  onComplete: onComplete
              });
          }
      };
      PersistentConnection.prototype.onDisconnectCancel = function (pathString, onComplete) {
          this.initConnection_();
          if (this.connected_) {
              this.sendOnDisconnect_('oc', pathString, null, onComplete);
          }
          else {
              this.onDisconnectRequestQueue_.push({
                  pathString: pathString,
                  action: 'oc',
                  data: null,
                  onComplete: onComplete
              });
          }
      };
      PersistentConnection.prototype.sendOnDisconnect_ = function (action, pathString, data, onComplete) {
          var request = { /*path*/ p: pathString, /*data*/ d: data };
          this.log_('onDisconnect ' + action, request);
          this.sendRequest(action, request, function (response) {
              if (onComplete) {
                  setTimeout(function () {
                      onComplete(response[ /*status*/'s'], response[ /* data */'d']);
                  }, Math.floor(0));
              }
          });
      };
      PersistentConnection.prototype.put = function (pathString, data, onComplete, hash) {
          this.putInternal('p', pathString, data, onComplete, hash);
      };
      PersistentConnection.prototype.merge = function (pathString, data, onComplete, hash) {
          this.putInternal('m', pathString, data, onComplete, hash);
      };
      PersistentConnection.prototype.putInternal = function (action, pathString, data, onComplete, hash) {
          this.initConnection_();
          var request = {
              /*path*/ p: pathString,
              /*data*/ d: data
          };
          if (hash !== undefined) {
              request[ /*hash*/'h'] = hash;
          }
          // TODO: Only keep track of the most recent put for a given path?
          this.outstandingPuts_.push({
              action: action,
              request: request,
              onComplete: onComplete
          });
          this.outstandingPutCount_++;
          var index = this.outstandingPuts_.length - 1;
          if (this.connected_) {
              this.sendPut_(index);
          }
          else {
              this.log_('Buffering put: ' + pathString);
          }
      };
      PersistentConnection.prototype.sendPut_ = function (index) {
          var _this = this;
          var action = this.outstandingPuts_[index].action;
          var request = this.outstandingPuts_[index].request;
          var onComplete = this.outstandingPuts_[index].onComplete;
          this.outstandingPuts_[index].queued = this.connected_;
          this.sendRequest(action, request, function (message) {
              _this.log_(action + ' response', message);
              delete _this.outstandingPuts_[index];
              _this.outstandingPutCount_--;
              // Clean up array occasionally.
              if (_this.outstandingPutCount_ === 0) {
                  _this.outstandingPuts_ = [];
              }
              if (onComplete) {
                  onComplete(message[ /*status*/'s'], message[ /* data */'d']);
              }
          });
      };
      PersistentConnection.prototype.reportStats = function (stats) {
          var _this = this;
          // If we're not connected, we just drop the stats.
          if (this.connected_) {
              var request = { /*counters*/ c: stats };
              this.log_('reportStats', request);
              this.sendRequest(/*stats*/ 's', request, function (result) {
                  var status = result[ /*status*/'s'];
                  if (status !== 'ok') {
                      var errorReason = result[ /* data */'d'];
                      _this.log_('reportStats', 'Error sending stats: ' + errorReason);
                  }
              });
          }
      };
      PersistentConnection.prototype.onDataMessage_ = function (message) {
          if ('r' in message) {
              // this is a response
              this.log_('from server: ' + util.stringify(message));
              var reqNum = message['r'];
              var onResponse = this.requestCBHash_[reqNum];
              if (onResponse) {
                  delete this.requestCBHash_[reqNum];
                  onResponse(message[ /*body*/'b']);
              }
          }
          else if ('error' in message) {
              throw 'A server-side error has occurred: ' + message['error'];
          }
          else if ('a' in message) {
              // a and b are action and body, respectively
              this.onDataPush_(message['a'], message['b']);
          }
      };
      PersistentConnection.prototype.onDataPush_ = function (action, body) {
          this.log_('handleServerMessage', action, body);
          if (action === 'd') {
              this.onDataUpdate_(body[ /*path*/'p'], body[ /*data*/'d'], 
              /*isMerge*/ false, body['t']);
          }
          else if (action === 'm') {
              this.onDataUpdate_(body[ /*path*/'p'], body[ /*data*/'d'], 
              /*isMerge=*/ true, body['t']);
          }
          else if (action === 'c') {
              this.onListenRevoked_(body[ /*path*/'p'], body[ /*query*/'q']);
          }
          else if (action === 'ac') {
              this.onAuthRevoked_(body[ /*status code*/'s'], body[ /* explanation */'d']);
          }
          else if (action === 'apc') {
              this.onAppCheckRevoked_(body[ /*status code*/'s'], body[ /* explanation */'d']);
          }
          else if (action === 'sd') {
              this.onSecurityDebugPacket_(body);
          }
          else {
              error('Unrecognized action received from server: ' +
                  util.stringify(action) +
                  '\nAre you using the latest client?');
          }
      };
      PersistentConnection.prototype.onReady_ = function (timestamp, sessionId) {
          this.log_('connection ready');
          this.connected_ = true;
          this.lastConnectionEstablishedTime_ = new Date().getTime();
          this.handleTimestamp_(timestamp);
          this.lastSessionId = sessionId;
          if (this.firstConnection_) {
              this.sendConnectStats_();
          }
          this.restoreState_();
          this.firstConnection_ = false;
          this.onConnectStatus_(true);
      };
      PersistentConnection.prototype.scheduleConnect_ = function (timeout) {
          var _this = this;
          util.assert(!this.realtime_, "Scheduling a connect when we're already connected/ing?");
          if (this.establishConnectionTimer_) {
              clearTimeout(this.establishConnectionTimer_);
          }
          // NOTE: Even when timeout is 0, it's important to do a setTimeout to work around an infuriating "Security Error" in
          // Firefox when trying to write to our long-polling iframe in some scenarios (e.g. Forge or our unit tests).
          this.establishConnectionTimer_ = setTimeout(function () {
              _this.establishConnectionTimer_ = null;
              _this.establishConnection_();
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
          }, Math.floor(timeout));
      };
      PersistentConnection.prototype.initConnection_ = function () {
          if (!this.realtime_ && this.firstConnection_) {
              this.scheduleConnect_(0);
          }
      };
      PersistentConnection.prototype.onVisible_ = function (visible) {
          // NOTE: Tabbing away and back to a window will defeat our reconnect backoff, but I think that's fine.
          if (visible &&
              !this.visible_ &&
              this.reconnectDelay_ === this.maxReconnectDelay_) {
              this.log_('Window became visible.  Reducing delay.');
              this.reconnectDelay_ = RECONNECT_MIN_DELAY;
              if (!this.realtime_) {
                  this.scheduleConnect_(0);
              }
          }
          this.visible_ = visible;
      };
      PersistentConnection.prototype.onOnline_ = function (online) {
          if (online) {
              this.log_('Browser went online.');
              this.reconnectDelay_ = RECONNECT_MIN_DELAY;
              if (!this.realtime_) {
                  this.scheduleConnect_(0);
              }
          }
          else {
              this.log_('Browser went offline.  Killing connection.');
              if (this.realtime_) {
                  this.realtime_.close();
              }
          }
      };
      PersistentConnection.prototype.onRealtimeDisconnect_ = function () {
          this.log_('data client disconnected');
          this.connected_ = false;
          this.realtime_ = null;
          // Since we don't know if our sent transactions succeeded or not, we need to cancel them.
          this.cancelSentTransactions_();
          // Clear out the pending requests.
          this.requestCBHash_ = {};
          if (this.shouldReconnect_()) {
              if (!this.visible_) {
                  this.log_("Window isn't visible.  Delaying reconnect.");
                  this.reconnectDelay_ = this.maxReconnectDelay_;
                  this.lastConnectionAttemptTime_ = new Date().getTime();
              }
              else if (this.lastConnectionEstablishedTime_) {
                  // If we've been connected long enough, reset reconnect delay to minimum.
                  var timeSinceLastConnectSucceeded = new Date().getTime() - this.lastConnectionEstablishedTime_;
                  if (timeSinceLastConnectSucceeded > RECONNECT_DELAY_RESET_TIMEOUT) {
                      this.reconnectDelay_ = RECONNECT_MIN_DELAY;
                  }
                  this.lastConnectionEstablishedTime_ = null;
              }
              var timeSinceLastConnectAttempt = new Date().getTime() - this.lastConnectionAttemptTime_;
              var reconnectDelay = Math.max(0, this.reconnectDelay_ - timeSinceLastConnectAttempt);
              reconnectDelay = Math.random() * reconnectDelay;
              this.log_('Trying to reconnect in ' + reconnectDelay + 'ms');
              this.scheduleConnect_(reconnectDelay);
              // Adjust reconnect delay for next time.
              this.reconnectDelay_ = Math.min(this.maxReconnectDelay_, this.reconnectDelay_ * RECONNECT_DELAY_MULTIPLIER);
          }
          this.onConnectStatus_(false);
      };
      PersistentConnection.prototype.establishConnection_ = function () {
          return tslib.__awaiter(this, void 0, void 0, function () {
              var onDataMessage, onReady, onDisconnect_1, connId, lastSessionId, canceled_1, connection_1, closeFn, sendRequestFn, forceRefresh, _a, authToken, appCheckToken, error_1;
              var _this = this;
              return tslib.__generator(this, function (_b) {
                  switch (_b.label) {
                      case 0:
                          if (!this.shouldReconnect_()) return [3 /*break*/, 4];
                          this.log_('Making a connection attempt');
                          this.lastConnectionAttemptTime_ = new Date().getTime();
                          this.lastConnectionEstablishedTime_ = null;
                          onDataMessage = this.onDataMessage_.bind(this);
                          onReady = this.onReady_.bind(this);
                          onDisconnect_1 = this.onRealtimeDisconnect_.bind(this);
                          connId = this.id + ':' + PersistentConnection.nextConnectionId_++;
                          lastSessionId = this.lastSessionId;
                          canceled_1 = false;
                          connection_1 = null;
                          closeFn = function () {
                              if (connection_1) {
                                  connection_1.close();
                              }
                              else {
                                  canceled_1 = true;
                                  onDisconnect_1();
                              }
                          };
                          sendRequestFn = function (msg) {
                              util.assert(connection_1, "sendRequest call when we're not connected not allowed.");
                              connection_1.sendRequest(msg);
                          };
                          this.realtime_ = {
                              close: closeFn,
                              sendRequest: sendRequestFn
                          };
                          forceRefresh = this.forceTokenRefresh_;
                          this.forceTokenRefresh_ = false;
                          _b.label = 1;
                      case 1:
                          _b.trys.push([1, 3, , 4]);
                          return [4 /*yield*/, Promise.all([
                                  this.authTokenProvider_.getToken(forceRefresh),
                                  this.appCheckTokenProvider_.getToken(forceRefresh)
                              ])];
                      case 2:
                          _a = tslib.__read.apply(void 0, [_b.sent(), 2]), authToken = _a[0], appCheckToken = _a[1];
                          if (!canceled_1) {
                              log('getToken() completed. Creating connection.');
                              this.authToken_ = authToken && authToken.accessToken;
                              this.appCheckToken_ = appCheckToken && appCheckToken.token;
                              connection_1 = new Connection(connId, this.repoInfo_, this.applicationId_, this.appCheckToken_, this.authToken_, onDataMessage, onReady, onDisconnect_1, 
                              /* onKill= */ function (reason) {
                                  warn(reason + ' (' + _this.repoInfo_.toString() + ')');
                                  _this.interrupt(SERVER_KILL_INTERRUPT_REASON);
                              }, lastSessionId);
                          }
                          else {
                              log('getToken() completed but was canceled');
                          }
                          return [3 /*break*/, 4];
                      case 3:
                          error_1 = _b.sent();
                          this.log_('Failed to get token: ' + error_1);
                          if (!canceled_1) {
                              if (this.repoInfo_.nodeAdmin) {
                                  // This may be a critical error for the Admin Node.js SDK, so log a warning.
                                  // But getToken() may also just have temporarily failed, so we still want to
                                  // continue retrying.
                                  warn(error_1);
                              }
                              closeFn();
                          }
                          return [3 /*break*/, 4];
                      case 4: return [2 /*return*/];
                  }
              });
          });
      };
      PersistentConnection.prototype.interrupt = function (reason) {
          log('Interrupting connection for reason: ' + reason);
          this.interruptReasons_[reason] = true;
          if (this.realtime_) {
              this.realtime_.close();
          }
          else {
              if (this.establishConnectionTimer_) {
                  clearTimeout(this.establishConnectionTimer_);
                  this.establishConnectionTimer_ = null;
              }
              if (this.connected_) {
                  this.onRealtimeDisconnect_();
              }
          }
      };
      PersistentConnection.prototype.resume = function (reason) {
          log('Resuming connection for reason: ' + reason);
          delete this.interruptReasons_[reason];
          if (util.isEmpty(this.interruptReasons_)) {
              this.reconnectDelay_ = RECONNECT_MIN_DELAY;
              if (!this.realtime_) {
                  this.scheduleConnect_(0);
              }
          }
      };
      PersistentConnection.prototype.handleTimestamp_ = function (timestamp) {
          var delta = timestamp - new Date().getTime();
          this.onServerInfoUpdate_({ serverTimeOffset: delta });
      };
      PersistentConnection.prototype.cancelSentTransactions_ = function () {
          for (var i = 0; i < this.outstandingPuts_.length; i++) {
              var put = this.outstandingPuts_[i];
              if (put && /*hash*/ 'h' in put.request && put.queued) {
                  if (put.onComplete) {
                      put.onComplete('disconnect');
                  }
                  delete this.outstandingPuts_[i];
                  this.outstandingPutCount_--;
              }
          }
          // Clean up array occasionally.
          if (this.outstandingPutCount_ === 0) {
              this.outstandingPuts_ = [];
          }
      };
      PersistentConnection.prototype.onListenRevoked_ = function (pathString, query) {
          // Remove the listen and manufacture a "permission_denied" error for the failed listen.
          var queryId;
          if (!query) {
              queryId = 'default';
          }
          else {
              queryId = query.map(function (q) { return ObjectToUniqueKey(q); }).join('$');
          }
          var listen = this.removeListen_(pathString, queryId);
          if (listen && listen.onComplete) {
              listen.onComplete('permission_denied');
          }
      };
      PersistentConnection.prototype.removeListen_ = function (pathString, queryId) {
          var normalizedPathString = new Path(pathString).toString(); // normalize path.
          var listen;
          if (this.listens.has(normalizedPathString)) {
              var map = this.listens.get(normalizedPathString);
              listen = map.get(queryId);
              map.delete(queryId);
              if (map.size === 0) {
                  this.listens.delete(normalizedPathString);
              }
          }
          else {
              // all listens for this path has already been removed
              listen = undefined;
          }
          return listen;
      };
      PersistentConnection.prototype.onAuthRevoked_ = function (statusCode, explanation) {
          log('Auth token revoked: ' + statusCode + '/' + explanation);
          this.authToken_ = null;
          this.forceTokenRefresh_ = true;
          this.realtime_.close();
          if (statusCode === 'invalid_token' || statusCode === 'permission_denied') {
              // We'll wait a couple times before logging the warning / increasing the
              // retry period since oauth tokens will report as "invalid" if they're
              // just expired. Plus there may be transient issues that resolve themselves.
              this.invalidAuthTokenCount_++;
              if (this.invalidAuthTokenCount_ >= INVALID_TOKEN_THRESHOLD) {
                  // Set a long reconnect delay because recovery is unlikely
                  this.reconnectDelay_ = RECONNECT_MAX_DELAY_FOR_ADMINS;
                  // Notify the auth token provider that the token is invalid, which will log
                  // a warning
                  this.authTokenProvider_.notifyForInvalidToken();
              }
          }
      };
      PersistentConnection.prototype.onAppCheckRevoked_ = function (statusCode, explanation) {
          log('App check token revoked: ' + statusCode + '/' + explanation);
          this.appCheckToken_ = null;
          this.forceTokenRefresh_ = true;
          // Note: We don't close the connection as the developer may not have
          // enforcement enabled. The backend closes connections with enforcements.
          if (statusCode === 'invalid_token' || statusCode === 'permission_denied') {
              // We'll wait a couple times before logging the warning / increasing the
              // retry period since oauth tokens will report as "invalid" if they're
              // just expired. Plus there may be transient issues that resolve themselves.
              this.invalidAppCheckTokenCount_++;
              if (this.invalidAppCheckTokenCount_ >= INVALID_TOKEN_THRESHOLD) {
                  this.appCheckTokenProvider_.notifyForInvalidToken();
              }
          }
      };
      PersistentConnection.prototype.onSecurityDebugPacket_ = function (body) {
          if (this.securityDebugCallback_) {
              this.securityDebugCallback_(body);
          }
          else {
              if ('msg' in body) {
                  console.log('FIREBASE: ' + body['msg'].replace('\n', '\nFIREBASE: '));
              }
          }
      };
      PersistentConnection.prototype.restoreState_ = function () {
          var e_1, _a, e_2, _b;
          //Re-authenticate ourselves if we have a credential stored.
          this.tryAuth();
          this.tryAppCheck();
          try {
              // Puts depend on having received the corresponding data update from the server before they complete, so we must
              // make sure to send listens before puts.
              for (var _c = tslib.__values(this.listens.values()), _d = _c.next(); !_d.done; _d = _c.next()) {
                  var queries = _d.value;
                  try {
                      for (var _e = (e_2 = void 0, tslib.__values(queries.values())), _f = _e.next(); !_f.done; _f = _e.next()) {
                          var listenSpec = _f.value;
                          this.sendListen_(listenSpec);
                      }
                  }
                  catch (e_2_1) { e_2 = { error: e_2_1 }; }
                  finally {
                      try {
                          if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                      }
                      finally { if (e_2) throw e_2.error; }
                  }
              }
          }
          catch (e_1_1) { e_1 = { error: e_1_1 }; }
          finally {
              try {
                  if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
              }
              finally { if (e_1) throw e_1.error; }
          }
          for (var i = 0; i < this.outstandingPuts_.length; i++) {
              if (this.outstandingPuts_[i]) {
                  this.sendPut_(i);
              }
          }
          while (this.onDisconnectRequestQueue_.length) {
              var request = this.onDisconnectRequestQueue_.shift();
              this.sendOnDisconnect_(request.action, request.pathString, request.data, request.onComplete);
          }
          for (var i = 0; i < this.outstandingGets_.length; i++) {
              if (this.outstandingGets_[i]) {
                  this.sendGet_(i);
              }
          }
      };
      /**
       * Sends client stats for first connection
       */
      PersistentConnection.prototype.sendConnectStats_ = function () {
          var stats = {};
          var clientName = 'js';
          if (util.isNodeSdk()) {
              if (this.repoInfo_.nodeAdmin) {
                  clientName = 'admin_node';
              }
              else {
                  clientName = 'node';
              }
          }
          stats['sdk.' + clientName + '.' + SDK_VERSION.replace(/\./g, '-')] = 1;
          if (util.isMobileCordova()) {
              stats['framework.cordova'] = 1;
          }
          else if (util.isReactNative()) {
              stats['framework.reactnative'] = 1;
          }
          this.reportStats(stats);
      };
      PersistentConnection.prototype.shouldReconnect_ = function () {
          var online = OnlineMonitor.getInstance().currentlyOnline();
          return util.isEmpty(this.interruptReasons_) && online;
      };
      PersistentConnection.nextPersistentConnectionId_ = 0;
      /**
       * Counter for number of connections created. Mainly used for tagging in the logs
       */
      PersistentConnection.nextConnectionId_ = 0;
      return PersistentConnection;
  }(ServerActions));
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var NamedNode = /** @class */ (function () {
      function NamedNode(name, node) {
          this.name = name;
          this.node = node;
      }
      NamedNode.Wrap = function (name, node) {
          return new NamedNode(name, node);
      };
      return NamedNode;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var Index = /** @class */ (function () {
      function Index() {
      }
      /**
       * @returns A standalone comparison function for
       * this index
       */
      Index.prototype.getCompare = function () {
          return this.compare.bind(this);
      };
      /**
       * Given a before and after value for a node, determine if the indexed value has changed. Even if they are different,
       * it's possible that the changes are isolated to parts of the snapshot that are not indexed.
       *
       *
       * @returns True if the portion of the snapshot being indexed changed between oldNode and newNode
       */
      Index.prototype.indexedValueChanged = function (oldNode, newNode) {
          var oldWrapped = new NamedNode(MIN_NAME, oldNode);
          var newWrapped = new NamedNode(MIN_NAME, newNode);
          return this.compare(oldWrapped, newWrapped) !== 0;
      };
      /**
       * @returns a node wrapper that will sort equal to or less than
       * any other node wrapper, using this index
       */
      Index.prototype.minPost = function () {
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          return NamedNode.MIN;
      };
      return Index;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var __EMPTY_NODE;
  var KeyIndex = /** @class */ (function (_super) {
      tslib.__extends(KeyIndex, _super);
      function KeyIndex() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      Object.defineProperty(KeyIndex, "__EMPTY_NODE", {
          get: function () {
              return __EMPTY_NODE;
          },
          set: function (val) {
              __EMPTY_NODE = val;
          },
          enumerable: false,
          configurable: true
      });
      KeyIndex.prototype.compare = function (a, b) {
          return nameCompare(a.name, b.name);
      };
      KeyIndex.prototype.isDefinedOn = function (node) {
          // We could probably return true here (since every node has a key), but it's never called
          // so just leaving unimplemented for now.
          throw util.assertionError('KeyIndex.isDefinedOn not expected to be called.');
      };
      KeyIndex.prototype.indexedValueChanged = function (oldNode, newNode) {
          return false; // The key for a node never changes.
      };
      KeyIndex.prototype.minPost = function () {
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          return NamedNode.MIN;
      };
      KeyIndex.prototype.maxPost = function () {
          // TODO: This should really be created once and cached in a static property, but
          // NamedNode isn't defined yet, so I can't use it in a static.  Bleh.
          return new NamedNode(MAX_NAME, __EMPTY_NODE);
      };
      KeyIndex.prototype.makePost = function (indexValue, name) {
          util.assert(typeof indexValue === 'string', 'KeyIndex indexValue must always be a string.');
          // We just use empty node, but it'll never be compared, since our comparator only looks at name.
          return new NamedNode(indexValue, __EMPTY_NODE);
      };
      /**
       * @returns String representation for inclusion in a query spec
       */
      KeyIndex.prototype.toString = function () {
          return '.key';
      };
      return KeyIndex;
  }(Index));
  var KEY_INDEX = new KeyIndex();
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * An iterator over an LLRBNode.
   */
  var SortedMapIterator = /** @class */ (function () {
      /**
       * @param node - Node to iterate.
       * @param isReverse_ - Whether or not to iterate in reverse
       */
      function SortedMapIterator(node, startKey, comparator, isReverse_, resultGenerator_) {
          if (resultGenerator_ === void 0) { resultGenerator_ = null; }
          this.isReverse_ = isReverse_;
          this.resultGenerator_ = resultGenerator_;
          this.nodeStack_ = [];
          var cmp = 1;
          while (!node.isEmpty()) {
              node = node;
              cmp = startKey ? comparator(node.key, startKey) : 1;
              // flip the comparison if we're going in reverse
              if (isReverse_) {
                  cmp *= -1;
              }
              if (cmp < 0) {
                  // This node is less than our start key. ignore it
                  if (this.isReverse_) {
                      node = node.left;
                  }
                  else {
                      node = node.right;
                  }
              }
              else if (cmp === 0) {
                  // This node is exactly equal to our start key. Push it on the stack, but stop iterating;
                  this.nodeStack_.push(node);
                  break;
              }
              else {
                  // This node is greater than our start key, add it to the stack and move to the next one
                  this.nodeStack_.push(node);
                  if (this.isReverse_) {
                      node = node.right;
                  }
                  else {
                      node = node.left;
                  }
              }
          }
      }
      SortedMapIterator.prototype.getNext = function () {
          if (this.nodeStack_.length === 0) {
              return null;
          }
          var node = this.nodeStack_.pop();
          var result;
          if (this.resultGenerator_) {
              result = this.resultGenerator_(node.key, node.value);
          }
          else {
              result = { key: node.key, value: node.value };
          }
          if (this.isReverse_) {
              node = node.left;
              while (!node.isEmpty()) {
                  this.nodeStack_.push(node);
                  node = node.right;
              }
          }
          else {
              node = node.right;
              while (!node.isEmpty()) {
                  this.nodeStack_.push(node);
                  node = node.left;
              }
          }
          return result;
      };
      SortedMapIterator.prototype.hasNext = function () {
          return this.nodeStack_.length > 0;
      };
      SortedMapIterator.prototype.peek = function () {
          if (this.nodeStack_.length === 0) {
              return null;
          }
          var node = this.nodeStack_[this.nodeStack_.length - 1];
          if (this.resultGenerator_) {
              return this.resultGenerator_(node.key, node.value);
          }
          else {
              return { key: node.key, value: node.value };
          }
      };
      return SortedMapIterator;
  }());
  /**
   * Represents a node in a Left-leaning Red-Black tree.
   */
  var LLRBNode = /** @class */ (function () {
      /**
       * @param key - Key associated with this node.
       * @param value - Value associated with this node.
       * @param color - Whether this node is red.
       * @param left - Left child.
       * @param right - Right child.
       */
      function LLRBNode(key, value, color, left, right) {
          this.key = key;
          this.value = value;
          this.color = color != null ? color : LLRBNode.RED;
          this.left =
              left != null ? left : SortedMap.EMPTY_NODE;
          this.right =
              right != null ? right : SortedMap.EMPTY_NODE;
      }
      /**
       * Returns a copy of the current node, optionally replacing pieces of it.
       *
       * @param key - New key for the node, or null.
       * @param value - New value for the node, or null.
       * @param color - New color for the node, or null.
       * @param left - New left child for the node, or null.
       * @param right - New right child for the node, or null.
       * @returns The node copy.
       */
      LLRBNode.prototype.copy = function (key, value, color, left, right) {
          return new LLRBNode(key != null ? key : this.key, value != null ? value : this.value, color != null ? color : this.color, left != null ? left : this.left, right != null ? right : this.right);
      };
      /**
       * @returns The total number of nodes in the tree.
       */
      LLRBNode.prototype.count = function () {
          return this.left.count() + 1 + this.right.count();
      };
      /**
       * @returns True if the tree is empty.
       */
      LLRBNode.prototype.isEmpty = function () {
          return false;
      };
      /**
       * Traverses the tree in key order and calls the specified action function
       * for each node.
       *
       * @param action - Callback function to be called for each
       *   node.  If it returns true, traversal is aborted.
       * @returns The first truthy value returned by action, or the last falsey
       *   value returned by action
       */
      LLRBNode.prototype.inorderTraversal = function (action) {
          return (this.left.inorderTraversal(action) ||
              !!action(this.key, this.value) ||
              this.right.inorderTraversal(action));
      };
      /**
       * Traverses the tree in reverse key order and calls the specified action function
       * for each node.
       *
       * @param action - Callback function to be called for each
       * node.  If it returns true, traversal is aborted.
       * @returns True if traversal was aborted.
       */
      LLRBNode.prototype.reverseTraversal = function (action) {
          return (this.right.reverseTraversal(action) ||
              action(this.key, this.value) ||
              this.left.reverseTraversal(action));
      };
      /**
       * @returns The minimum node in the tree.
       */
      LLRBNode.prototype.min_ = function () {
          if (this.left.isEmpty()) {
              return this;
          }
          else {
              return this.left.min_();
          }
      };
      /**
       * @returns The maximum key in the tree.
       */
      LLRBNode.prototype.minKey = function () {
          return this.min_().key;
      };
      /**
       * @returns The maximum key in the tree.
       */
      LLRBNode.prototype.maxKey = function () {
          if (this.right.isEmpty()) {
              return this.key;
          }
          else {
              return this.right.maxKey();
          }
      };
      /**
       * @param key - Key to insert.
       * @param value - Value to insert.
       * @param comparator - Comparator.
       * @returns New tree, with the key/value added.
       */
      LLRBNode.prototype.insert = function (key, value, comparator) {
          var n = this;
          var cmp = comparator(key, n.key);
          if (cmp < 0) {
              n = n.copy(null, null, null, n.left.insert(key, value, comparator), null);
          }
          else if (cmp === 0) {
              n = n.copy(null, value, null, null, null);
          }
          else {
              n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));
          }
          return n.fixUp_();
      };
      /**
       * @returns New tree, with the minimum key removed.
       */
      LLRBNode.prototype.removeMin_ = function () {
          if (this.left.isEmpty()) {
              return SortedMap.EMPTY_NODE;
          }
          var n = this;
          if (!n.left.isRed_() && !n.left.left.isRed_()) {
              n = n.moveRedLeft_();
          }
          n = n.copy(null, null, null, n.left.removeMin_(), null);
          return n.fixUp_();
      };
      /**
       * @param key - The key of the item to remove.
       * @param comparator - Comparator.
       * @returns New tree, with the specified item removed.
       */
      LLRBNode.prototype.remove = function (key, comparator) {
          var n, smallest;
          n = this;
          if (comparator(key, n.key) < 0) {
              if (!n.left.isEmpty() && !n.left.isRed_() && !n.left.left.isRed_()) {
                  n = n.moveRedLeft_();
              }
              n = n.copy(null, null, null, n.left.remove(key, comparator), null);
          }
          else {
              if (n.left.isRed_()) {
                  n = n.rotateRight_();
              }
              if (!n.right.isEmpty() && !n.right.isRed_() && !n.right.left.isRed_()) {
                  n = n.moveRedRight_();
              }
              if (comparator(key, n.key) === 0) {
                  if (n.right.isEmpty()) {
                      return SortedMap.EMPTY_NODE;
                  }
                  else {
                      smallest = n.right.min_();
                      n = n.copy(smallest.key, smallest.value, null, null, n.right.removeMin_());
                  }
              }
              n = n.copy(null, null, null, null, n.right.remove(key, comparator));
          }
          return n.fixUp_();
      };
      /**
       * @returns Whether this is a RED node.
       */
      LLRBNode.prototype.isRed_ = function () {
          return this.color;
      };
      /**
       * @returns New tree after performing any needed rotations.
       */
      LLRBNode.prototype.fixUp_ = function () {
          var n = this;
          if (n.right.isRed_() && !n.left.isRed_()) {
              n = n.rotateLeft_();
          }
          if (n.left.isRed_() && n.left.left.isRed_()) {
              n = n.rotateRight_();
          }
          if (n.left.isRed_() && n.right.isRed_()) {
              n = n.colorFlip_();
          }
          return n;
      };
      /**
       * @returns New tree, after moveRedLeft.
       */
      LLRBNode.prototype.moveRedLeft_ = function () {
          var n = this.colorFlip_();
          if (n.right.left.isRed_()) {
              n = n.copy(null, null, null, null, n.right.rotateRight_());
              n = n.rotateLeft_();
              n = n.colorFlip_();
          }
          return n;
      };
      /**
       * @returns New tree, after moveRedRight.
       */
      LLRBNode.prototype.moveRedRight_ = function () {
          var n = this.colorFlip_();
          if (n.left.left.isRed_()) {
              n = n.rotateRight_();
              n = n.colorFlip_();
          }
          return n;
      };
      /**
       * @returns New tree, after rotateLeft.
       */
      LLRBNode.prototype.rotateLeft_ = function () {
          var nl = this.copy(null, null, LLRBNode.RED, null, this.right.left);
          return this.right.copy(null, null, this.color, nl, null);
      };
      /**
       * @returns New tree, after rotateRight.
       */
      LLRBNode.prototype.rotateRight_ = function () {
          var nr = this.copy(null, null, LLRBNode.RED, this.left.right, null);
          return this.left.copy(null, null, this.color, null, nr);
      };
      /**
       * @returns Newt ree, after colorFlip.
       */
      LLRBNode.prototype.colorFlip_ = function () {
          var left = this.left.copy(null, null, !this.left.color, null, null);
          var right = this.right.copy(null, null, !this.right.color, null, null);
          return this.copy(null, null, !this.color, left, right);
      };
      /**
       * For testing.
       *
       * @returns True if all is well.
       */
      LLRBNode.prototype.checkMaxDepth_ = function () {
          var blackDepth = this.check_();
          return Math.pow(2.0, blackDepth) <= this.count() + 1;
      };
      LLRBNode.prototype.check_ = function () {
          if (this.isRed_() && this.left.isRed_()) {
              throw new Error('Red node has red child(' + this.key + ',' + this.value + ')');
          }
          if (this.right.isRed_()) {
              throw new Error('Right child of (' + this.key + ',' + this.value + ') is red');
          }
          var blackDepth = this.left.check_();
          if (blackDepth !== this.right.check_()) {
              throw new Error('Black depths differ');
          }
          else {
              return blackDepth + (this.isRed_() ? 0 : 1);
          }
      };
      LLRBNode.RED = true;
      LLRBNode.BLACK = false;
      return LLRBNode;
  }());
  /**
   * Represents an empty node (a leaf node in the Red-Black Tree).
   */
  var LLRBEmptyNode = /** @class */ (function () {
      function LLRBEmptyNode() {
      }
      /**
       * Returns a copy of the current node.
       *
       * @returns The node copy.
       */
      LLRBEmptyNode.prototype.copy = function (key, value, color, left, right) {
          return this;
      };
      /**
       * Returns a copy of the tree, with the specified key/value added.
       *
       * @param key - Key to be added.
       * @param value - Value to be added.
       * @param comparator - Comparator.
       * @returns New tree, with item added.
       */
      LLRBEmptyNode.prototype.insert = function (key, value, comparator) {
          return new LLRBNode(key, value, null);
      };
      /**
       * Returns a copy of the tree, with the specified key removed.
       *
       * @param key - The key to remove.
       * @param comparator - Comparator.
       * @returns New tree, with item removed.
       */
      LLRBEmptyNode.prototype.remove = function (key, comparator) {
          return this;
      };
      /**
       * @returns The total number of nodes in the tree.
       */
      LLRBEmptyNode.prototype.count = function () {
          return 0;
      };
      /**
       * @returns True if the tree is empty.
       */
      LLRBEmptyNode.prototype.isEmpty = function () {
          return true;
      };
      /**
       * Traverses the tree in key order and calls the specified action function
       * for each node.
       *
       * @param action - Callback function to be called for each
       * node.  If it returns true, traversal is aborted.
       * @returns True if traversal was aborted.
       */
      LLRBEmptyNode.prototype.inorderTraversal = function (action) {
          return false;
      };
      /**
       * Traverses the tree in reverse key order and calls the specified action function
       * for each node.
       *
       * @param action - Callback function to be called for each
       * node.  If it returns true, traversal is aborted.
       * @returns True if traversal was aborted.
       */
      LLRBEmptyNode.prototype.reverseTraversal = function (action) {
          return false;
      };
      LLRBEmptyNode.prototype.minKey = function () {
          return null;
      };
      LLRBEmptyNode.prototype.maxKey = function () {
          return null;
      };
      LLRBEmptyNode.prototype.check_ = function () {
          return 0;
      };
      /**
       * @returns Whether this node is red.
       */
      LLRBEmptyNode.prototype.isRed_ = function () {
          return false;
      };
      return LLRBEmptyNode;
  }());
  /**
   * An immutable sorted map implementation, based on a Left-leaning Red-Black
   * tree.
   */
  var SortedMap = /** @class */ (function () {
      /**
       * @param comparator_ - Key comparator.
       * @param root_ - Optional root node for the map.
       */
      function SortedMap(comparator_, root_) {
          if (root_ === void 0) { root_ = SortedMap.EMPTY_NODE; }
          this.comparator_ = comparator_;
          this.root_ = root_;
      }
      /**
       * Returns a copy of the map, with the specified key/value added or replaced.
       * (TODO: We should perhaps rename this method to 'put')
       *
       * @param key - Key to be added.
       * @param value - Value to be added.
       * @returns New map, with item added.
       */
      SortedMap.prototype.insert = function (key, value) {
          return new SortedMap(this.comparator_, this.root_
              .insert(key, value, this.comparator_)
              .copy(null, null, LLRBNode.BLACK, null, null));
      };
      /**
       * Returns a copy of the map, with the specified key removed.
       *
       * @param key - The key to remove.
       * @returns New map, with item removed.
       */
      SortedMap.prototype.remove = function (key) {
          return new SortedMap(this.comparator_, this.root_
              .remove(key, this.comparator_)
              .copy(null, null, LLRBNode.BLACK, null, null));
      };
      /**
       * Returns the value of the node with the given key, or null.
       *
       * @param key - The key to look up.
       * @returns The value of the node with the given key, or null if the
       * key doesn't exist.
       */
      SortedMap.prototype.get = function (key) {
          var cmp;
          var node = this.root_;
          while (!node.isEmpty()) {
              cmp = this.comparator_(key, node.key);
              if (cmp === 0) {
                  return node.value;
              }
              else if (cmp < 0) {
                  node = node.left;
              }
              else if (cmp > 0) {
                  node = node.right;
              }
          }
          return null;
      };
      /**
       * Returns the key of the item *before* the specified key, or null if key is the first item.
       * @param key - The key to find the predecessor of
       * @returns The predecessor key.
       */
      SortedMap.prototype.getPredecessorKey = function (key) {
          var cmp, node = this.root_, rightParent = null;
          while (!node.isEmpty()) {
              cmp = this.comparator_(key, node.key);
              if (cmp === 0) {
                  if (!node.left.isEmpty()) {
                      node = node.left;
                      while (!node.right.isEmpty()) {
                          node = node.right;
                      }
                      return node.key;
                  }
                  else if (rightParent) {
                      return rightParent.key;
                  }
                  else {
                      return null; // first item.
                  }
              }
              else if (cmp < 0) {
                  node = node.left;
              }
              else if (cmp > 0) {
                  rightParent = node;
                  node = node.right;
              }
          }
          throw new Error('Attempted to find predecessor key for a nonexistent key.  What gives?');
      };
      /**
       * @returns True if the map is empty.
       */
      SortedMap.prototype.isEmpty = function () {
          return this.root_.isEmpty();
      };
      /**
       * @returns The total number of nodes in the map.
       */
      SortedMap.prototype.count = function () {
          return this.root_.count();
      };
      /**
       * @returns The minimum key in the map.
       */
      SortedMap.prototype.minKey = function () {
          return this.root_.minKey();
      };
      /**
       * @returns The maximum key in the map.
       */
      SortedMap.prototype.maxKey = function () {
          return this.root_.maxKey();
      };
      /**
       * Traverses the map in key order and calls the specified action function
       * for each key/value pair.
       *
       * @param action - Callback function to be called
       * for each key/value pair.  If action returns true, traversal is aborted.
       * @returns The first truthy value returned by action, or the last falsey
       *   value returned by action
       */
      SortedMap.prototype.inorderTraversal = function (action) {
          return this.root_.inorderTraversal(action);
      };
      /**
       * Traverses the map in reverse key order and calls the specified action function
       * for each key/value pair.
       *
       * @param action - Callback function to be called
       * for each key/value pair.  If action returns true, traversal is aborted.
       * @returns True if the traversal was aborted.
       */
      SortedMap.prototype.reverseTraversal = function (action) {
          return this.root_.reverseTraversal(action);
      };
      /**
       * Returns an iterator over the SortedMap.
       * @returns The iterator.
       */
      SortedMap.prototype.getIterator = function (resultGenerator) {
          return new SortedMapIterator(this.root_, null, this.comparator_, false, resultGenerator);
      };
      SortedMap.prototype.getIteratorFrom = function (key, resultGenerator) {
          return new SortedMapIterator(this.root_, key, this.comparator_, false, resultGenerator);
      };
      SortedMap.prototype.getReverseIteratorFrom = function (key, resultGenerator) {
          return new SortedMapIterator(this.root_, key, this.comparator_, true, resultGenerator);
      };
      SortedMap.prototype.getReverseIterator = function (resultGenerator) {
          return new SortedMapIterator(this.root_, null, this.comparator_, true, resultGenerator);
      };
      /**
       * Always use the same empty node, to reduce memory.
       */
      SortedMap.EMPTY_NODE = new LLRBEmptyNode();
      return SortedMap;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function NAME_ONLY_COMPARATOR(left, right) {
      return nameCompare(left.name, right.name);
  }
  function NAME_COMPARATOR(left, right) {
      return nameCompare(left, right);
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var MAX_NODE$2;
  function setMaxNode$1(val) {
      MAX_NODE$2 = val;
  }
  var priorityHashText = function (priority) {
      if (typeof priority === 'number') {
          return 'number:' + doubleToIEEE754String(priority);
      }
      else {
          return 'string:' + priority;
      }
  };
  /**
   * Validates that a priority snapshot Node is valid.
   */
  var validatePriorityNode = function (priorityNode) {
      if (priorityNode.isLeafNode()) {
          var val = priorityNode.val();
          util.assert(typeof val === 'string' ||
              typeof val === 'number' ||
              (typeof val === 'object' && util.contains(val, '.sv')), 'Priority must be a string or number.');
      }
      else {
          util.assert(priorityNode === MAX_NODE$2 || priorityNode.isEmpty(), 'priority of unexpected type.');
      }
      // Don't call getPriority() on MAX_NODE to avoid hitting assertion.
      util.assert(priorityNode === MAX_NODE$2 || priorityNode.getPriority().isEmpty(), "Priority nodes can't have a priority of their own.");
  };
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var __childrenNodeConstructor;
  /**
   * LeafNode is a class for storing leaf nodes in a DataSnapshot.  It
   * implements Node and stores the value of the node (a string,
   * number, or boolean) accessible via getValue().
   */
  var LeafNode = /** @class */ (function () {
      /**
       * @param value_ - The value to store in this leaf node. The object type is
       * possible in the event of a deferred value
       * @param priorityNode_ - The priority of this node.
       */
      function LeafNode(value_, priorityNode_) {
          if (priorityNode_ === void 0) { priorityNode_ = LeafNode.__childrenNodeConstructor.EMPTY_NODE; }
          this.value_ = value_;
          this.priorityNode_ = priorityNode_;
          this.lazyHash_ = null;
          util.assert(this.value_ !== undefined && this.value_ !== null, "LeafNode shouldn't be created with null/undefined value.");
          validatePriorityNode(this.priorityNode_);
      }
      Object.defineProperty(LeafNode, "__childrenNodeConstructor", {
          get: function () {
              return __childrenNodeConstructor;
          },
          set: function (val) {
              __childrenNodeConstructor = val;
          },
          enumerable: false,
          configurable: true
      });
      /** @inheritDoc */
      LeafNode.prototype.isLeafNode = function () {
          return true;
      };
      /** @inheritDoc */
      LeafNode.prototype.getPriority = function () {
          return this.priorityNode_;
      };
      /** @inheritDoc */
      LeafNode.prototype.updatePriority = function (newPriorityNode) {
          return new LeafNode(this.value_, newPriorityNode);
      };
      /** @inheritDoc */
      LeafNode.prototype.getImmediateChild = function (childName) {
          // Hack to treat priority as a regular child
          if (childName === '.priority') {
              return this.priorityNode_;
          }
          else {
              return LeafNode.__childrenNodeConstructor.EMPTY_NODE;
          }
      };
      /** @inheritDoc */
      LeafNode.prototype.getChild = function (path) {
          if (pathIsEmpty(path)) {
              return this;
          }
          else if (pathGetFront(path) === '.priority') {
              return this.priorityNode_;
          }
          else {
              return LeafNode.__childrenNodeConstructor.EMPTY_NODE;
          }
      };
      LeafNode.prototype.hasChild = function () {
          return false;
      };
      /** @inheritDoc */
      LeafNode.prototype.getPredecessorChildName = function (childName, childNode) {
          return null;
      };
      /** @inheritDoc */
      LeafNode.prototype.updateImmediateChild = function (childName, newChildNode) {
          if (childName === '.priority') {
              return this.updatePriority(newChildNode);
          }
          else if (newChildNode.isEmpty() && childName !== '.priority') {
              return this;
          }
          else {
              return LeafNode.__childrenNodeConstructor.EMPTY_NODE.updateImmediateChild(childName, newChildNode).updatePriority(this.priorityNode_);
          }
      };
      /** @inheritDoc */
      LeafNode.prototype.updateChild = function (path, newChildNode) {
          var front = pathGetFront(path);
          if (front === null) {
              return newChildNode;
          }
          else if (newChildNode.isEmpty() && front !== '.priority') {
              return this;
          }
          else {
              util.assert(front !== '.priority' || pathGetLength(path) === 1, '.priority must be the last token in a path');
              return this.updateImmediateChild(front, LeafNode.__childrenNodeConstructor.EMPTY_NODE.updateChild(pathPopFront(path), newChildNode));
          }
      };
      /** @inheritDoc */
      LeafNode.prototype.isEmpty = function () {
          return false;
      };
      /** @inheritDoc */
      LeafNode.prototype.numChildren = function () {
          return 0;
      };
      /** @inheritDoc */
      LeafNode.prototype.forEachChild = function (index, action) {
          return false;
      };
      LeafNode.prototype.val = function (exportFormat) {
          if (exportFormat && !this.getPriority().isEmpty()) {
              return {
                  '.value': this.getValue(),
                  '.priority': this.getPriority().val()
              };
          }
          else {
              return this.getValue();
          }
      };
      /** @inheritDoc */
      LeafNode.prototype.hash = function () {
          if (this.lazyHash_ === null) {
              var toHash = '';
              if (!this.priorityNode_.isEmpty()) {
                  toHash +=
                      'priority:' +
                          priorityHashText(this.priorityNode_.val()) +
                          ':';
              }
              var type = typeof this.value_;
              toHash += type + ':';
              if (type === 'number') {
                  toHash += doubleToIEEE754String(this.value_);
              }
              else {
                  toHash += this.value_;
              }
              this.lazyHash_ = sha1(toHash);
          }
          return this.lazyHash_;
      };
      /**
       * Returns the value of the leaf node.
       * @returns The value of the node.
       */
      LeafNode.prototype.getValue = function () {
          return this.value_;
      };
      LeafNode.prototype.compareTo = function (other) {
          if (other === LeafNode.__childrenNodeConstructor.EMPTY_NODE) {
              return 1;
          }
          else if (other instanceof LeafNode.__childrenNodeConstructor) {
              return -1;
          }
          else {
              util.assert(other.isLeafNode(), 'Unknown node type');
              return this.compareToLeafNode_(other);
          }
      };
      /**
       * Comparison specifically for two leaf nodes
       */
      LeafNode.prototype.compareToLeafNode_ = function (otherLeaf) {
          var otherLeafType = typeof otherLeaf.value_;
          var thisLeafType = typeof this.value_;
          var otherIndex = LeafNode.VALUE_TYPE_ORDER.indexOf(otherLeafType);
          var thisIndex = LeafNode.VALUE_TYPE_ORDER.indexOf(thisLeafType);
          util.assert(otherIndex >= 0, 'Unknown leaf type: ' + otherLeafType);
          util.assert(thisIndex >= 0, 'Unknown leaf type: ' + thisLeafType);
          if (otherIndex === thisIndex) {
              // Same type, compare values
              if (thisLeafType === 'object') {
                  // Deferred value nodes are all equal, but we should also never get to this point...
                  return 0;
              }
              else {
                  // Note that this works because true > false, all others are number or string comparisons
                  if (this.value_ < otherLeaf.value_) {
                      return -1;
                  }
                  else if (this.value_ === otherLeaf.value_) {
                      return 0;
                  }
                  else {
                      return 1;
                  }
              }
          }
          else {
              return thisIndex - otherIndex;
          }
      };
      LeafNode.prototype.withIndex = function () {
          return this;
      };
      LeafNode.prototype.isIndexed = function () {
          return true;
      };
      LeafNode.prototype.equals = function (other) {
          if (other === this) {
              return true;
          }
          else if (other.isLeafNode()) {
              var otherLeaf = other;
              return (this.value_ === otherLeaf.value_ &&
                  this.priorityNode_.equals(otherLeaf.priorityNode_));
          }
          else {
              return false;
          }
      };
      /**
       * The sort order for comparing leaf nodes of different types. If two leaf nodes have
       * the same type, the comparison falls back to their value
       */
      LeafNode.VALUE_TYPE_ORDER = ['object', 'boolean', 'number', 'string'];
      return LeafNode;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var nodeFromJSON$1;
  var MAX_NODE$1;
  function setNodeFromJSON(val) {
      nodeFromJSON$1 = val;
  }
  function setMaxNode(val) {
      MAX_NODE$1 = val;
  }
  var PriorityIndex = /** @class */ (function (_super) {
      tslib.__extends(PriorityIndex, _super);
      function PriorityIndex() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      PriorityIndex.prototype.compare = function (a, b) {
          var aPriority = a.node.getPriority();
          var bPriority = b.node.getPriority();
          var indexCmp = aPriority.compareTo(bPriority);
          if (indexCmp === 0) {
              return nameCompare(a.name, b.name);
          }
          else {
              return indexCmp;
          }
      };
      PriorityIndex.prototype.isDefinedOn = function (node) {
          return !node.getPriority().isEmpty();
      };
      PriorityIndex.prototype.indexedValueChanged = function (oldNode, newNode) {
          return !oldNode.getPriority().equals(newNode.getPriority());
      };
      PriorityIndex.prototype.minPost = function () {
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          return NamedNode.MIN;
      };
      PriorityIndex.prototype.maxPost = function () {
          return new NamedNode(MAX_NAME, new LeafNode('[PRIORITY-POST]', MAX_NODE$1));
      };
      PriorityIndex.prototype.makePost = function (indexValue, name) {
          var priorityNode = nodeFromJSON$1(indexValue);
          return new NamedNode(name, new LeafNode('[PRIORITY-POST]', priorityNode));
      };
      /**
       * @returns String representation for inclusion in a query spec
       */
      PriorityIndex.prototype.toString = function () {
          return '.priority';
      };
      return PriorityIndex;
  }(Index));
  var PRIORITY_INDEX = new PriorityIndex();
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var LOG_2 = Math.log(2);
  var Base12Num = /** @class */ (function () {
      function Base12Num(length) {
          var logBase2 = function (num) {
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              return parseInt((Math.log(num) / LOG_2), 10);
          };
          var bitMask = function (bits) { return parseInt(Array(bits + 1).join('1'), 2); };
          this.count = logBase2(length + 1);
          this.current_ = this.count - 1;
          var mask = bitMask(this.count);
          this.bits_ = (length + 1) & mask;
      }
      Base12Num.prototype.nextBitIsOne = function () {
          //noinspection JSBitwiseOperatorUsage
          var result = !(this.bits_ & (0x1 << this.current_));
          this.current_--;
          return result;
      };
      return Base12Num;
  }());
  /**
   * Takes a list of child nodes and constructs a SortedSet using the given comparison
   * function
   *
   * Uses the algorithm described in the paper linked here:
   * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.46.1458
   *
   * @param childList - Unsorted list of children
   * @param cmp - The comparison method to be used
   * @param keyFn - An optional function to extract K from a node wrapper, if K's
   * type is not NamedNode
   * @param mapSortFn - An optional override for comparator used by the generated sorted map
   */
  var buildChildSet = function (childList, cmp, keyFn, mapSortFn) {
      childList.sort(cmp);
      var buildBalancedTree = function (low, high) {
          var length = high - low;
          var namedNode;
          var key;
          if (length === 0) {
              return null;
          }
          else if (length === 1) {
              namedNode = childList[low];
              key = keyFn ? keyFn(namedNode) : namedNode;
              return new LLRBNode(key, namedNode.node, LLRBNode.BLACK, null, null);
          }
          else {
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              var middle = parseInt((length / 2), 10) + low;
              var left = buildBalancedTree(low, middle);
              var right = buildBalancedTree(middle + 1, high);
              namedNode = childList[middle];
              key = keyFn ? keyFn(namedNode) : namedNode;
              return new LLRBNode(key, namedNode.node, LLRBNode.BLACK, left, right);
          }
      };
      var buildFrom12Array = function (base12) {
          var node = null;
          var root = null;
          var index = childList.length;
          var buildPennant = function (chunkSize, color) {
              var low = index - chunkSize;
              var high = index;
              index -= chunkSize;
              var childTree = buildBalancedTree(low + 1, high);
              var namedNode = childList[low];
              var key = keyFn ? keyFn(namedNode) : namedNode;
              attachPennant(new LLRBNode(key, namedNode.node, color, null, childTree));
          };
          var attachPennant = function (pennant) {
              if (node) {
                  node.left = pennant;
                  node = pennant;
              }
              else {
                  root = pennant;
                  node = pennant;
              }
          };
          for (var i = 0; i < base12.count; ++i) {
              var isOne = base12.nextBitIsOne();
              // The number of nodes taken in each slice is 2^(arr.length - (i + 1))
              var chunkSize = Math.pow(2, base12.count - (i + 1));
              if (isOne) {
                  buildPennant(chunkSize, LLRBNode.BLACK);
              }
              else {
                  // current == 2
                  buildPennant(chunkSize, LLRBNode.BLACK);
                  buildPennant(chunkSize, LLRBNode.RED);
              }
          }
          return root;
      };
      var base12 = new Base12Num(childList.length);
      var root = buildFrom12Array(base12);
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      return new SortedMap(mapSortFn || cmp, root);
  };
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var _defaultIndexMap;
  var fallbackObject = {};
  var IndexMap = /** @class */ (function () {
      function IndexMap(indexes_, indexSet_) {
          this.indexes_ = indexes_;
          this.indexSet_ = indexSet_;
      }
      Object.defineProperty(IndexMap, "Default", {
          /**
           * The default IndexMap for nodes without a priority
           */
          get: function () {
              util.assert(fallbackObject && PRIORITY_INDEX, 'ChildrenNode.ts has not been loaded');
              _defaultIndexMap =
                  _defaultIndexMap ||
                      new IndexMap({ '.priority': fallbackObject }, { '.priority': PRIORITY_INDEX });
              return _defaultIndexMap;
          },
          enumerable: false,
          configurable: true
      });
      IndexMap.prototype.get = function (indexKey) {
          var sortedMap = util.safeGet(this.indexes_, indexKey);
          if (!sortedMap) {
              throw new Error('No index defined for ' + indexKey);
          }
          if (sortedMap instanceof SortedMap) {
              return sortedMap;
          }
          else {
              // The index exists, but it falls back to just name comparison. Return null so that the calling code uses the
              // regular child map
              return null;
          }
      };
      IndexMap.prototype.hasIndex = function (indexDefinition) {
          return util.contains(this.indexSet_, indexDefinition.toString());
      };
      IndexMap.prototype.addIndex = function (indexDefinition, existingChildren) {
          util.assert(indexDefinition !== KEY_INDEX, "KeyIndex always exists and isn't meant to be added to the IndexMap.");
          var childList = [];
          var sawIndexedValue = false;
          var iter = existingChildren.getIterator(NamedNode.Wrap);
          var next = iter.getNext();
          while (next) {
              sawIndexedValue =
                  sawIndexedValue || indexDefinition.isDefinedOn(next.node);
              childList.push(next);
              next = iter.getNext();
          }
          var newIndex;
          if (sawIndexedValue) {
              newIndex = buildChildSet(childList, indexDefinition.getCompare());
          }
          else {
              newIndex = fallbackObject;
          }
          var indexName = indexDefinition.toString();
          var newIndexSet = tslib.__assign({}, this.indexSet_);
          newIndexSet[indexName] = indexDefinition;
          var newIndexes = tslib.__assign({}, this.indexes_);
          newIndexes[indexName] = newIndex;
          return new IndexMap(newIndexes, newIndexSet);
      };
      /**
       * Ensure that this node is properly tracked in any indexes that we're maintaining
       */
      IndexMap.prototype.addToIndexes = function (namedNode, existingChildren) {
          var _this = this;
          var newIndexes = util.map(this.indexes_, function (indexedChildren, indexName) {
              var index = util.safeGet(_this.indexSet_, indexName);
              util.assert(index, 'Missing index implementation for ' + indexName);
              if (indexedChildren === fallbackObject) {
                  // Check to see if we need to index everything
                  if (index.isDefinedOn(namedNode.node)) {
                      // We need to build this index
                      var childList = [];
                      var iter = existingChildren.getIterator(NamedNode.Wrap);
                      var next = iter.getNext();
                      while (next) {
                          if (next.name !== namedNode.name) {
                              childList.push(next);
                          }
                          next = iter.getNext();
                      }
                      childList.push(namedNode);
                      return buildChildSet(childList, index.getCompare());
                  }
                  else {
                      // No change, this remains a fallback
                      return fallbackObject;
                  }
              }
              else {
                  var existingSnap = existingChildren.get(namedNode.name);
                  var newChildren = indexedChildren;
                  if (existingSnap) {
                      newChildren = newChildren.remove(new NamedNode(namedNode.name, existingSnap));
                  }
                  return newChildren.insert(namedNode, namedNode.node);
              }
          });
          return new IndexMap(newIndexes, this.indexSet_);
      };
      /**
       * Create a new IndexMap instance with the given value removed
       */
      IndexMap.prototype.removeFromIndexes = function (namedNode, existingChildren) {
          var newIndexes = util.map(this.indexes_, function (indexedChildren) {
              if (indexedChildren === fallbackObject) {
                  // This is the fallback. Just return it, nothing to do in this case
                  return indexedChildren;
              }
              else {
                  var existingSnap = existingChildren.get(namedNode.name);
                  if (existingSnap) {
                      return indexedChildren.remove(new NamedNode(namedNode.name, existingSnap));
                  }
                  else {
                      // No record of this child
                      return indexedChildren;
                  }
              }
          });
          return new IndexMap(newIndexes, this.indexSet_);
      };
      return IndexMap;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  // TODO: For memory savings, don't store priorityNode_ if it's empty.
  var EMPTY_NODE;
  /**
   * ChildrenNode is a class for storing internal nodes in a DataSnapshot
   * (i.e. nodes with children).  It implements Node and stores the
   * list of children in the children property, sorted by child name.
   */
  var ChildrenNode = /** @class */ (function () {
      /**
       * @param children_ - List of children of this node..
       * @param priorityNode_ - The priority of this node (as a snapshot node).
       */
      function ChildrenNode(children_, priorityNode_, indexMap_) {
          this.children_ = children_;
          this.priorityNode_ = priorityNode_;
          this.indexMap_ = indexMap_;
          this.lazyHash_ = null;
          /**
           * Note: The only reason we allow null priority is for EMPTY_NODE, since we can't use
           * EMPTY_NODE as the priority of EMPTY_NODE.  We might want to consider making EMPTY_NODE its own
           * class instead of an empty ChildrenNode.
           */
          if (this.priorityNode_) {
              validatePriorityNode(this.priorityNode_);
          }
          if (this.children_.isEmpty()) {
              util.assert(!this.priorityNode_ || this.priorityNode_.isEmpty(), 'An empty node cannot have a priority');
          }
      }
      Object.defineProperty(ChildrenNode, "EMPTY_NODE", {
          get: function () {
              return (EMPTY_NODE ||
                  (EMPTY_NODE = new ChildrenNode(new SortedMap(NAME_COMPARATOR), null, IndexMap.Default)));
          },
          enumerable: false,
          configurable: true
      });
      /** @inheritDoc */
      ChildrenNode.prototype.isLeafNode = function () {
          return false;
      };
      /** @inheritDoc */
      ChildrenNode.prototype.getPriority = function () {
          return this.priorityNode_ || EMPTY_NODE;
      };
      /** @inheritDoc */
      ChildrenNode.prototype.updatePriority = function (newPriorityNode) {
          if (this.children_.isEmpty()) {
              // Don't allow priorities on empty nodes
              return this;
          }
          else {
              return new ChildrenNode(this.children_, newPriorityNode, this.indexMap_);
          }
      };
      /** @inheritDoc */
      ChildrenNode.prototype.getImmediateChild = function (childName) {
          // Hack to treat priority as a regular child
          if (childName === '.priority') {
              return this.getPriority();
          }
          else {
              var child = this.children_.get(childName);
              return child === null ? EMPTY_NODE : child;
          }
      };
      /** @inheritDoc */
      ChildrenNode.prototype.getChild = function (path) {
          var front = pathGetFront(path);
          if (front === null) {
              return this;
          }
          return this.getImmediateChild(front).getChild(pathPopFront(path));
      };
      /** @inheritDoc */
      ChildrenNode.prototype.hasChild = function (childName) {
          return this.children_.get(childName) !== null;
      };
      /** @inheritDoc */
      ChildrenNode.prototype.updateImmediateChild = function (childName, newChildNode) {
          util.assert(newChildNode, 'We should always be passing snapshot nodes');
          if (childName === '.priority') {
              return this.updatePriority(newChildNode);
          }
          else {
              var namedNode = new NamedNode(childName, newChildNode);
              var newChildren = void 0, newIndexMap = void 0;
              if (newChildNode.isEmpty()) {
                  newChildren = this.children_.remove(childName);
                  newIndexMap = this.indexMap_.removeFromIndexes(namedNode, this.children_);
              }
              else {
                  newChildren = this.children_.insert(childName, newChildNode);
                  newIndexMap = this.indexMap_.addToIndexes(namedNode, this.children_);
              }
              var newPriority = newChildren.isEmpty()
                  ? EMPTY_NODE
                  : this.priorityNode_;
              return new ChildrenNode(newChildren, newPriority, newIndexMap);
          }
      };
      /** @inheritDoc */
      ChildrenNode.prototype.updateChild = function (path, newChildNode) {
          var front = pathGetFront(path);
          if (front === null) {
              return newChildNode;
          }
          else {
              util.assert(pathGetFront(path) !== '.priority' || pathGetLength(path) === 1, '.priority must be the last token in a path');
              var newImmediateChild = this.getImmediateChild(front).updateChild(pathPopFront(path), newChildNode);
              return this.updateImmediateChild(front, newImmediateChild);
          }
      };
      /** @inheritDoc */
      ChildrenNode.prototype.isEmpty = function () {
          return this.children_.isEmpty();
      };
      /** @inheritDoc */
      ChildrenNode.prototype.numChildren = function () {
          return this.children_.count();
      };
      /** @inheritDoc */
      ChildrenNode.prototype.val = function (exportFormat) {
          if (this.isEmpty()) {
              return null;
          }
          var obj = {};
          var numKeys = 0, maxKey = 0, allIntegerKeys = true;
          this.forEachChild(PRIORITY_INDEX, function (key, childNode) {
              obj[key] = childNode.val(exportFormat);
              numKeys++;
              if (allIntegerKeys && ChildrenNode.INTEGER_REGEXP_.test(key)) {
                  maxKey = Math.max(maxKey, Number(key));
              }
              else {
                  allIntegerKeys = false;
              }
          });
          if (!exportFormat && allIntegerKeys && maxKey < 2 * numKeys) {
              // convert to array.
              var array = [];
              // eslint-disable-next-line guard-for-in
              for (var key in obj) {
                  array[key] = obj[key];
              }
              return array;
          }
          else {
              if (exportFormat && !this.getPriority().isEmpty()) {
                  obj['.priority'] = this.getPriority().val();
              }
              return obj;
          }
      };
      /** @inheritDoc */
      ChildrenNode.prototype.hash = function () {
          if (this.lazyHash_ === null) {
              var toHash_1 = '';
              if (!this.getPriority().isEmpty()) {
                  toHash_1 +=
                      'priority:' +
                          priorityHashText(this.getPriority().val()) +
                          ':';
              }
              this.forEachChild(PRIORITY_INDEX, function (key, childNode) {
                  var childHash = childNode.hash();
                  if (childHash !== '') {
                      toHash_1 += ':' + key + ':' + childHash;
                  }
              });
              this.lazyHash_ = toHash_1 === '' ? '' : sha1(toHash_1);
          }
          return this.lazyHash_;
      };
      /** @inheritDoc */
      ChildrenNode.prototype.getPredecessorChildName = function (childName, childNode, index) {
          var idx = this.resolveIndex_(index);
          if (idx) {
              var predecessor = idx.getPredecessorKey(new NamedNode(childName, childNode));
              return predecessor ? predecessor.name : null;
          }
          else {
              return this.children_.getPredecessorKey(childName);
          }
      };
      ChildrenNode.prototype.getFirstChildName = function (indexDefinition) {
          var idx = this.resolveIndex_(indexDefinition);
          if (idx) {
              var minKey = idx.minKey();
              return minKey && minKey.name;
          }
          else {
              return this.children_.minKey();
          }
      };
      ChildrenNode.prototype.getFirstChild = function (indexDefinition) {
          var minKey = this.getFirstChildName(indexDefinition);
          if (minKey) {
              return new NamedNode(minKey, this.children_.get(minKey));
          }
          else {
              return null;
          }
      };
      /**
       * Given an index, return the key name of the largest value we have, according to that index
       */
      ChildrenNode.prototype.getLastChildName = function (indexDefinition) {
          var idx = this.resolveIndex_(indexDefinition);
          if (idx) {
              var maxKey = idx.maxKey();
              return maxKey && maxKey.name;
          }
          else {
              return this.children_.maxKey();
          }
      };
      ChildrenNode.prototype.getLastChild = function (indexDefinition) {
          var maxKey = this.getLastChildName(indexDefinition);
          if (maxKey) {
              return new NamedNode(maxKey, this.children_.get(maxKey));
          }
          else {
              return null;
          }
      };
      ChildrenNode.prototype.forEachChild = function (index, action) {
          var idx = this.resolveIndex_(index);
          if (idx) {
              return idx.inorderTraversal(function (wrappedNode) {
                  return action(wrappedNode.name, wrappedNode.node);
              });
          }
          else {
              return this.children_.inorderTraversal(action);
          }
      };
      ChildrenNode.prototype.getIterator = function (indexDefinition) {
          return this.getIteratorFrom(indexDefinition.minPost(), indexDefinition);
      };
      ChildrenNode.prototype.getIteratorFrom = function (startPost, indexDefinition) {
          var idx = this.resolveIndex_(indexDefinition);
          if (idx) {
              return idx.getIteratorFrom(startPost, function (key) { return key; });
          }
          else {
              var iterator = this.children_.getIteratorFrom(startPost.name, NamedNode.Wrap);
              var next = iterator.peek();
              while (next != null && indexDefinition.compare(next, startPost) < 0) {
                  iterator.getNext();
                  next = iterator.peek();
              }
              return iterator;
          }
      };
      ChildrenNode.prototype.getReverseIterator = function (indexDefinition) {
          return this.getReverseIteratorFrom(indexDefinition.maxPost(), indexDefinition);
      };
      ChildrenNode.prototype.getReverseIteratorFrom = function (endPost, indexDefinition) {
          var idx = this.resolveIndex_(indexDefinition);
          if (idx) {
              return idx.getReverseIteratorFrom(endPost, function (key) {
                  return key;
              });
          }
          else {
              var iterator = this.children_.getReverseIteratorFrom(endPost.name, NamedNode.Wrap);
              var next = iterator.peek();
              while (next != null && indexDefinition.compare(next, endPost) > 0) {
                  iterator.getNext();
                  next = iterator.peek();
              }
              return iterator;
          }
      };
      ChildrenNode.prototype.compareTo = function (other) {
          if (this.isEmpty()) {
              if (other.isEmpty()) {
                  return 0;
              }
              else {
                  return -1;
              }
          }
          else if (other.isLeafNode() || other.isEmpty()) {
              return 1;
          }
          else if (other === MAX_NODE) {
              return -1;
          }
          else {
              // Must be another node with children.
              return 0;
          }
      };
      ChildrenNode.prototype.withIndex = function (indexDefinition) {
          if (indexDefinition === KEY_INDEX ||
              this.indexMap_.hasIndex(indexDefinition)) {
              return this;
          }
          else {
              var newIndexMap = this.indexMap_.addIndex(indexDefinition, this.children_);
              return new ChildrenNode(this.children_, this.priorityNode_, newIndexMap);
          }
      };
      ChildrenNode.prototype.isIndexed = function (index) {
          return index === KEY_INDEX || this.indexMap_.hasIndex(index);
      };
      ChildrenNode.prototype.equals = function (other) {
          if (other === this) {
              return true;
          }
          else if (other.isLeafNode()) {
              return false;
          }
          else {
              var otherChildrenNode = other;
              if (!this.getPriority().equals(otherChildrenNode.getPriority())) {
                  return false;
              }
              else if (this.children_.count() === otherChildrenNode.children_.count()) {
                  var thisIter = this.getIterator(PRIORITY_INDEX);
                  var otherIter = otherChildrenNode.getIterator(PRIORITY_INDEX);
                  var thisCurrent = thisIter.getNext();
                  var otherCurrent = otherIter.getNext();
                  while (thisCurrent && otherCurrent) {
                      if (thisCurrent.name !== otherCurrent.name ||
                          !thisCurrent.node.equals(otherCurrent.node)) {
                          return false;
                      }
                      thisCurrent = thisIter.getNext();
                      otherCurrent = otherIter.getNext();
                  }
                  return thisCurrent === null && otherCurrent === null;
              }
              else {
                  return false;
              }
          }
      };
      /**
       * Returns a SortedMap ordered by index, or null if the default (by-key) ordering can be used
       * instead.
       *
       */
      ChildrenNode.prototype.resolveIndex_ = function (indexDefinition) {
          if (indexDefinition === KEY_INDEX) {
              return null;
          }
          else {
              return this.indexMap_.get(indexDefinition.toString());
          }
      };
      ChildrenNode.INTEGER_REGEXP_ = /^(0|[1-9]\d*)$/;
      return ChildrenNode;
  }());
  var MaxNode = /** @class */ (function (_super) {
      tslib.__extends(MaxNode, _super);
      function MaxNode() {
          return _super.call(this, new SortedMap(NAME_COMPARATOR), ChildrenNode.EMPTY_NODE, IndexMap.Default) || this;
      }
      MaxNode.prototype.compareTo = function (other) {
          if (other === this) {
              return 0;
          }
          else {
              return 1;
          }
      };
      MaxNode.prototype.equals = function (other) {
          // Not that we every compare it, but MAX_NODE is only ever equal to itself
          return other === this;
      };
      MaxNode.prototype.getPriority = function () {
          return this;
      };
      MaxNode.prototype.getImmediateChild = function (childName) {
          return ChildrenNode.EMPTY_NODE;
      };
      MaxNode.prototype.isEmpty = function () {
          return false;
      };
      return MaxNode;
  }(ChildrenNode));
  /**
   * Marker that will sort higher than any other snapshot.
   */
  var MAX_NODE = new MaxNode();
  Object.defineProperties(NamedNode, {
      MIN: {
          value: new NamedNode(MIN_NAME, ChildrenNode.EMPTY_NODE)
      },
      MAX: {
          value: new NamedNode(MAX_NAME, MAX_NODE)
      }
  });
  /**
   * Reference Extensions
   */
  KeyIndex.__EMPTY_NODE = ChildrenNode.EMPTY_NODE;
  LeafNode.__childrenNodeConstructor = ChildrenNode;
  setMaxNode$1(MAX_NODE);
  setMaxNode(MAX_NODE);
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var USE_HINZE = true;
  /**
   * Constructs a snapshot node representing the passed JSON and returns it.
   * @param json - JSON to create a node for.
   * @param priority - Optional priority to use.  This will be ignored if the
   * passed JSON contains a .priority property.
   */
  function nodeFromJSON(json, priority) {
      if (priority === void 0) { priority = null; }
      if (json === null) {
          return ChildrenNode.EMPTY_NODE;
      }
      if (typeof json === 'object' && '.priority' in json) {
          priority = json['.priority'];
      }
      util.assert(priority === null ||
          typeof priority === 'string' ||
          typeof priority === 'number' ||
          (typeof priority === 'object' && '.sv' in priority), 'Invalid priority type found: ' + typeof priority);
      if (typeof json === 'object' && '.value' in json && json['.value'] !== null) {
          json = json['.value'];
      }
      // Valid leaf nodes include non-objects or server-value wrapper objects
      if (typeof json !== 'object' || '.sv' in json) {
          var jsonLeaf = json;
          return new LeafNode(jsonLeaf, nodeFromJSON(priority));
      }
      if (!(json instanceof Array) && USE_HINZE) {
          var children_1 = [];
          var childrenHavePriority_1 = false;
          var hinzeJsonObj = json;
          each(hinzeJsonObj, function (key, child) {
              if (key.substring(0, 1) !== '.') {
                  // Ignore metadata nodes
                  var childNode = nodeFromJSON(child);
                  if (!childNode.isEmpty()) {
                      childrenHavePriority_1 =
                          childrenHavePriority_1 || !childNode.getPriority().isEmpty();
                      children_1.push(new NamedNode(key, childNode));
                  }
              }
          });
          if (children_1.length === 0) {
              return ChildrenNode.EMPTY_NODE;
          }
          var childSet = buildChildSet(children_1, NAME_ONLY_COMPARATOR, function (namedNode) { return namedNode.name; }, NAME_COMPARATOR);
          if (childrenHavePriority_1) {
              var sortedChildSet = buildChildSet(children_1, PRIORITY_INDEX.getCompare());
              return new ChildrenNode(childSet, nodeFromJSON(priority), new IndexMap({ '.priority': sortedChildSet }, { '.priority': PRIORITY_INDEX }));
          }
          else {
              return new ChildrenNode(childSet, nodeFromJSON(priority), IndexMap.Default);
          }
      }
      else {
          var node_1 = ChildrenNode.EMPTY_NODE;
          each(json, function (key, childData) {
              if (util.contains(json, key)) {
                  if (key.substring(0, 1) !== '.') {
                      // ignore metadata nodes.
                      var childNode = nodeFromJSON(childData);
                      if (childNode.isLeafNode() || !childNode.isEmpty()) {
                          node_1 = node_1.updateImmediateChild(key, childNode);
                      }
                  }
              }
          });
          return node_1.updatePriority(nodeFromJSON(priority));
      }
  }
  setNodeFromJSON(nodeFromJSON);
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var PathIndex = /** @class */ (function (_super) {
      tslib.__extends(PathIndex, _super);
      function PathIndex(indexPath_) {
          var _this = _super.call(this) || this;
          _this.indexPath_ = indexPath_;
          util.assert(!pathIsEmpty(indexPath_) && pathGetFront(indexPath_) !== '.priority', "Can't create PathIndex with empty path or .priority key");
          return _this;
      }
      PathIndex.prototype.extractChild = function (snap) {
          return snap.getChild(this.indexPath_);
      };
      PathIndex.prototype.isDefinedOn = function (node) {
          return !node.getChild(this.indexPath_).isEmpty();
      };
      PathIndex.prototype.compare = function (a, b) {
          var aChild = this.extractChild(a.node);
          var bChild = this.extractChild(b.node);
          var indexCmp = aChild.compareTo(bChild);
          if (indexCmp === 0) {
              return nameCompare(a.name, b.name);
          }
          else {
              return indexCmp;
          }
      };
      PathIndex.prototype.makePost = function (indexValue, name) {
          var valueNode = nodeFromJSON(indexValue);
          var node = ChildrenNode.EMPTY_NODE.updateChild(this.indexPath_, valueNode);
          return new NamedNode(name, node);
      };
      PathIndex.prototype.maxPost = function () {
          var node = ChildrenNode.EMPTY_NODE.updateChild(this.indexPath_, MAX_NODE);
          return new NamedNode(MAX_NAME, node);
      };
      PathIndex.prototype.toString = function () {
          return pathSlice(this.indexPath_, 0).join('/');
      };
      return PathIndex;
  }(Index));
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var ValueIndex = /** @class */ (function (_super) {
      tslib.__extends(ValueIndex, _super);
      function ValueIndex() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      ValueIndex.prototype.compare = function (a, b) {
          var indexCmp = a.node.compareTo(b.node);
          if (indexCmp === 0) {
              return nameCompare(a.name, b.name);
          }
          else {
              return indexCmp;
          }
      };
      ValueIndex.prototype.isDefinedOn = function (node) {
          return true;
      };
      ValueIndex.prototype.indexedValueChanged = function (oldNode, newNode) {
          return !oldNode.equals(newNode);
      };
      ValueIndex.prototype.minPost = function () {
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          return NamedNode.MIN;
      };
      ValueIndex.prototype.maxPost = function () {
          // eslint-disable-next-line @typescript-eslint/no-explicit-any
          return NamedNode.MAX;
      };
      ValueIndex.prototype.makePost = function (indexValue, name) {
          var valueNode = nodeFromJSON(indexValue);
          return new NamedNode(name, valueNode);
      };
      /**
       * @returns String representation for inclusion in a query spec
       */
      ValueIndex.prototype.toString = function () {
          return '.value';
      };
      return ValueIndex;
  }(Index));
  var VALUE_INDEX = new ValueIndex();
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  // Modeled after base64 web-safe chars, but ordered by ASCII.
  var PUSH_CHARS = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
  var MIN_PUSH_CHAR = '-';
  var MAX_PUSH_CHAR = 'z';
  var MAX_KEY_LEN = 786;
  /**
   * Fancy ID generator that creates 20-character string identifiers with the
   * following properties:
   *
   * 1. They're based on timestamp so that they sort *after* any existing ids.
   * 2. They contain 72-bits of random data after the timestamp so that IDs won't
   *    collide with other clients' IDs.
   * 3. They sort *lexicographically* (so the timestamp is converted to characters
   *    that will sort properly).
   * 4. They're monotonically increasing. Even if you generate more than one in
   *    the same timestamp, the latter ones will sort after the former ones. We do
   *    this by using the previous random bits but "incrementing" them by 1 (only
   *    in the case of a timestamp collision).
   */
  var nextPushId = (function () {
      // Timestamp of last push, used to prevent local collisions if you push twice
      // in one ms.
      var lastPushTime = 0;
      // We generate 72-bits of randomness which get turned into 12 characters and
      // appended to the timestamp to prevent collisions with other clients. We
      // store the last characters we generated because in the event of a collision,
      // we'll use those same characters except "incremented" by one.
      var lastRandChars = [];
      return function (now) {
          var duplicateTime = now === lastPushTime;
          lastPushTime = now;
          var i;
          var timeStampChars = new Array(8);
          for (i = 7; i >= 0; i--) {
              timeStampChars[i] = PUSH_CHARS.charAt(now % 64);
              // NOTE: Can't use << here because javascript will convert to int and lose
              // the upper bits.
              now = Math.floor(now / 64);
          }
          util.assert(now === 0, 'Cannot push at time == 0');
          var id = timeStampChars.join('');
          if (!duplicateTime) {
              for (i = 0; i < 12; i++) {
                  lastRandChars[i] = Math.floor(Math.random() * 64);
              }
          }
          else {
              // If the timestamp hasn't changed since last push, use the same random
              // number, except incremented by 1.
              for (i = 11; i >= 0 && lastRandChars[i] === 63; i--) {
                  lastRandChars[i] = 0;
              }
              lastRandChars[i]++;
          }
          for (i = 0; i < 12; i++) {
              id += PUSH_CHARS.charAt(lastRandChars[i]);
          }
          util.assert(id.length === 20, 'nextPushId: Length should be 20.');
          return id;
      };
  })();
  var successor = function (key) {
      if (key === '' + INTEGER_32_MAX) {
          // See https://firebase.google.com/docs/database/web/lists-of-data#data-order
          return MIN_PUSH_CHAR;
      }
      var keyAsInt = tryParseInt(key);
      if (keyAsInt != null) {
          return '' + (keyAsInt + 1);
      }
      var next = new Array(key.length);
      for (var i_1 = 0; i_1 < next.length; i_1++) {
          next[i_1] = key.charAt(i_1);
      }
      if (next.length < MAX_KEY_LEN) {
          next.push(MIN_PUSH_CHAR);
          return next.join('');
      }
      var i = next.length - 1;
      while (i >= 0 && next[i] === MAX_PUSH_CHAR) {
          i--;
      }
      // `successor` was called on the largest possible key, so return the
      // MAX_NAME, which sorts larger than all keys.
      if (i === -1) {
          return MAX_NAME;
      }
      var source = next[i];
      var sourcePlusOne = PUSH_CHARS.charAt(PUSH_CHARS.indexOf(source) + 1);
      next[i] = sourcePlusOne;
      return next.slice(0, i + 1).join('');
  };
  // `key` is assumed to be non-empty.
  var predecessor = function (key) {
      if (key === '' + INTEGER_32_MIN) {
          return MIN_NAME;
      }
      var keyAsInt = tryParseInt(key);
      if (keyAsInt != null) {
          return '' + (keyAsInt - 1);
      }
      var next = new Array(key.length);
      for (var i = 0; i < next.length; i++) {
          next[i] = key.charAt(i);
      }
      // If `key` ends in `MIN_PUSH_CHAR`, the largest key lexicographically
      // smaller than `key`, is `key[0:key.length - 1]`. The next key smaller
      // than that, `predecessor(predecessor(key))`, is
      //
      // `key[0:key.length - 2] + (key[key.length - 1] - 1) + \
      //   { MAX_PUSH_CHAR repeated MAX_KEY_LEN - (key.length - 1) times }
      //
      // analogous to increment/decrement for base-10 integers.
      //
      // This works because lexigographic comparison works character-by-character,
      // using length as a tie-breaker if one key is a prefix of the other.
      if (next[next.length - 1] === MIN_PUSH_CHAR) {
          if (next.length === 1) {
              // See https://firebase.google.com/docs/database/web/lists-of-data#orderbykey
              return '' + INTEGER_32_MAX;
          }
          delete next[next.length - 1];
          return next.join('');
      }
      // Replace the last character with it's immediate predecessor, and
      // fill the suffix of the key with MAX_PUSH_CHAR. This is the
      // lexicographically largest possible key smaller than `key`.
      next[next.length - 1] = PUSH_CHARS.charAt(PUSH_CHARS.indexOf(next[next.length - 1]) - 1);
      return next.join('') + MAX_PUSH_CHAR.repeat(MAX_KEY_LEN - next.length);
  };
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function changeValue(snapshotNode) {
      return { type: "value" /* VALUE */, snapshotNode: snapshotNode };
  }
  function changeChildAdded(childName, snapshotNode) {
      return { type: "child_added" /* CHILD_ADDED */, snapshotNode: snapshotNode, childName: childName };
  }
  function changeChildRemoved(childName, snapshotNode) {
      return { type: "child_removed" /* CHILD_REMOVED */, snapshotNode: snapshotNode, childName: childName };
  }
  function changeChildChanged(childName, snapshotNode, oldSnap) {
      return {
          type: "child_changed" /* CHILD_CHANGED */,
          snapshotNode: snapshotNode,
          childName: childName,
          oldSnap: oldSnap
      };
  }
  function changeChildMoved(childName, snapshotNode) {
      return { type: "child_moved" /* CHILD_MOVED */, snapshotNode: snapshotNode, childName: childName };
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Doesn't really filter nodes but applies an index to the node and keeps track of any changes
   */
  var IndexedFilter = /** @class */ (function () {
      function IndexedFilter(index_) {
          this.index_ = index_;
      }
      IndexedFilter.prototype.updateChild = function (snap, key, newChild, affectedPath, source, optChangeAccumulator) {
          util.assert(snap.isIndexed(this.index_), 'A node must be indexed if only a child is updated');
          var oldChild = snap.getImmediateChild(key);
          // Check if anything actually changed.
          if (oldChild.getChild(affectedPath).equals(newChild.getChild(affectedPath))) {
              // There's an edge case where a child can enter or leave the view because affectedPath was set to null.
              // In this case, affectedPath will appear null in both the old and new snapshots.  So we need
              // to avoid treating these cases as "nothing changed."
              if (oldChild.isEmpty() === newChild.isEmpty()) {
                  // Nothing changed.
                  // This assert should be valid, but it's expensive (can dominate perf testing) so don't actually do it.
                  //assert(oldChild.equals(newChild), 'Old and new snapshots should be equal.');
                  return snap;
              }
          }
          if (optChangeAccumulator != null) {
              if (newChild.isEmpty()) {
                  if (snap.hasChild(key)) {
                      optChangeAccumulator.trackChildChange(changeChildRemoved(key, oldChild));
                  }
                  else {
                      util.assert(snap.isLeafNode(), 'A child remove without an old child only makes sense on a leaf node');
                  }
              }
              else if (oldChild.isEmpty()) {
                  optChangeAccumulator.trackChildChange(changeChildAdded(key, newChild));
              }
              else {
                  optChangeAccumulator.trackChildChange(changeChildChanged(key, newChild, oldChild));
              }
          }
          if (snap.isLeafNode() && newChild.isEmpty()) {
              return snap;
          }
          else {
              // Make sure the node is indexed
              return snap.updateImmediateChild(key, newChild).withIndex(this.index_);
          }
      };
      IndexedFilter.prototype.updateFullNode = function (oldSnap, newSnap, optChangeAccumulator) {
          if (optChangeAccumulator != null) {
              if (!oldSnap.isLeafNode()) {
                  oldSnap.forEachChild(PRIORITY_INDEX, function (key, childNode) {
                      if (!newSnap.hasChild(key)) {
                          optChangeAccumulator.trackChildChange(changeChildRemoved(key, childNode));
                      }
                  });
              }
              if (!newSnap.isLeafNode()) {
                  newSnap.forEachChild(PRIORITY_INDEX, function (key, childNode) {
                      if (oldSnap.hasChild(key)) {
                          var oldChild = oldSnap.getImmediateChild(key);
                          if (!oldChild.equals(childNode)) {
                              optChangeAccumulator.trackChildChange(changeChildChanged(key, childNode, oldChild));
                          }
                      }
                      else {
                          optChangeAccumulator.trackChildChange(changeChildAdded(key, childNode));
                      }
                  });
              }
          }
          return newSnap.withIndex(this.index_);
      };
      IndexedFilter.prototype.updatePriority = function (oldSnap, newPriority) {
          if (oldSnap.isEmpty()) {
              return ChildrenNode.EMPTY_NODE;
          }
          else {
              return oldSnap.updatePriority(newPriority);
          }
      };
      IndexedFilter.prototype.filtersNodes = function () {
          return false;
      };
      IndexedFilter.prototype.getIndexedFilter = function () {
          return this;
      };
      IndexedFilter.prototype.getIndex = function () {
          return this.index_;
      };
      return IndexedFilter;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Filters nodes by range and uses an IndexFilter to track any changes after filtering the node
   */
  var RangedFilter = /** @class */ (function () {
      function RangedFilter(params) {
          this.indexedFilter_ = new IndexedFilter(params.getIndex());
          this.index_ = params.getIndex();
          this.startPost_ = RangedFilter.getStartPost_(params);
          this.endPost_ = RangedFilter.getEndPost_(params);
      }
      RangedFilter.prototype.getStartPost = function () {
          return this.startPost_;
      };
      RangedFilter.prototype.getEndPost = function () {
          return this.endPost_;
      };
      RangedFilter.prototype.matches = function (node) {
          return (this.index_.compare(this.getStartPost(), node) <= 0 &&
              this.index_.compare(node, this.getEndPost()) <= 0);
      };
      RangedFilter.prototype.updateChild = function (snap, key, newChild, affectedPath, source, optChangeAccumulator) {
          if (!this.matches(new NamedNode(key, newChild))) {
              newChild = ChildrenNode.EMPTY_NODE;
          }
          return this.indexedFilter_.updateChild(snap, key, newChild, affectedPath, source, optChangeAccumulator);
      };
      RangedFilter.prototype.updateFullNode = function (oldSnap, newSnap, optChangeAccumulator) {
          if (newSnap.isLeafNode()) {
              // Make sure we have a children node with the correct index, not a leaf node;
              newSnap = ChildrenNode.EMPTY_NODE;
          }
          var filtered = newSnap.withIndex(this.index_);
          // Don't support priorities on queries
          filtered = filtered.updatePriority(ChildrenNode.EMPTY_NODE);
          var self = this;
          newSnap.forEachChild(PRIORITY_INDEX, function (key, childNode) {
              if (!self.matches(new NamedNode(key, childNode))) {
                  filtered = filtered.updateImmediateChild(key, ChildrenNode.EMPTY_NODE);
              }
          });
          return this.indexedFilter_.updateFullNode(oldSnap, filtered, optChangeAccumulator);
      };
      RangedFilter.prototype.updatePriority = function (oldSnap, newPriority) {
          // Don't support priorities on queries
          return oldSnap;
      };
      RangedFilter.prototype.filtersNodes = function () {
          return true;
      };
      RangedFilter.prototype.getIndexedFilter = function () {
          return this.indexedFilter_;
      };
      RangedFilter.prototype.getIndex = function () {
          return this.index_;
      };
      RangedFilter.getStartPost_ = function (params) {
          if (params.hasStart()) {
              var startName = params.getIndexStartName();
              return params.getIndex().makePost(params.getIndexStartValue(), startName);
          }
          else {
              return params.getIndex().minPost();
          }
      };
      RangedFilter.getEndPost_ = function (params) {
          if (params.hasEnd()) {
              var endName = params.getIndexEndName();
              return params.getIndex().makePost(params.getIndexEndValue(), endName);
          }
          else {
              return params.getIndex().maxPost();
          }
      };
      return RangedFilter;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Applies a limit and a range to a node and uses RangedFilter to do the heavy lifting where possible
   */
  var LimitedFilter = /** @class */ (function () {
      function LimitedFilter(params) {
          this.rangedFilter_ = new RangedFilter(params);
          this.index_ = params.getIndex();
          this.limit_ = params.getLimit();
          this.reverse_ = !params.isViewFromLeft();
      }
      LimitedFilter.prototype.updateChild = function (snap, key, newChild, affectedPath, source, optChangeAccumulator) {
          if (!this.rangedFilter_.matches(new NamedNode(key, newChild))) {
              newChild = ChildrenNode.EMPTY_NODE;
          }
          if (snap.getImmediateChild(key).equals(newChild)) {
              // No change
              return snap;
          }
          else if (snap.numChildren() < this.limit_) {
              return this.rangedFilter_
                  .getIndexedFilter()
                  .updateChild(snap, key, newChild, affectedPath, source, optChangeAccumulator);
          }
          else {
              return this.fullLimitUpdateChild_(snap, key, newChild, source, optChangeAccumulator);
          }
      };
      LimitedFilter.prototype.updateFullNode = function (oldSnap, newSnap, optChangeAccumulator) {
          var filtered;
          if (newSnap.isLeafNode() || newSnap.isEmpty()) {
              // Make sure we have a children node with the correct index, not a leaf node;
              filtered = ChildrenNode.EMPTY_NODE.withIndex(this.index_);
          }
          else {
              if (this.limit_ * 2 < newSnap.numChildren() &&
                  newSnap.isIndexed(this.index_)) {
                  // Easier to build up a snapshot, since what we're given has more than twice the elements we want
                  filtered = ChildrenNode.EMPTY_NODE.withIndex(this.index_);
                  // anchor to the startPost, endPost, or last element as appropriate
                  var iterator = void 0;
                  if (this.reverse_) {
                      iterator = newSnap.getReverseIteratorFrom(this.rangedFilter_.getEndPost(), this.index_);
                  }
                  else {
                      iterator = newSnap.getIteratorFrom(this.rangedFilter_.getStartPost(), this.index_);
                  }
                  var count = 0;
                  while (iterator.hasNext() && count < this.limit_) {
                      var next = iterator.getNext();
                      var inRange = void 0;
                      if (this.reverse_) {
                          inRange =
                              this.index_.compare(this.rangedFilter_.getStartPost(), next) <= 0;
                      }
                      else {
                          inRange =
                              this.index_.compare(next, this.rangedFilter_.getEndPost()) <= 0;
                      }
                      if (inRange) {
                          filtered = filtered.updateImmediateChild(next.name, next.node);
                          count++;
                      }
                      else {
                          // if we have reached the end post, we cannot keep adding elemments
                          break;
                      }
                  }
              }
              else {
                  // The snap contains less than twice the limit. Faster to delete from the snap than build up a new one
                  filtered = newSnap.withIndex(this.index_);
                  // Don't support priorities on queries
                  filtered = filtered.updatePriority(ChildrenNode.EMPTY_NODE);
                  var startPost = void 0;
                  var endPost = void 0;
                  var cmp = void 0;
                  var iterator = void 0;
                  if (this.reverse_) {
                      iterator = filtered.getReverseIterator(this.index_);
                      startPost = this.rangedFilter_.getEndPost();
                      endPost = this.rangedFilter_.getStartPost();
                      var indexCompare_1 = this.index_.getCompare();
                      cmp = function (a, b) { return indexCompare_1(b, a); };
                  }
                  else {
                      iterator = filtered.getIterator(this.index_);
                      startPost = this.rangedFilter_.getStartPost();
                      endPost = this.rangedFilter_.getEndPost();
                      cmp = this.index_.getCompare();
                  }
                  var count = 0;
                  var foundStartPost = false;
                  while (iterator.hasNext()) {
                      var next = iterator.getNext();
                      if (!foundStartPost && cmp(startPost, next) <= 0) {
                          // start adding
                          foundStartPost = true;
                      }
                      var inRange = foundStartPost && count < this.limit_ && cmp(next, endPost) <= 0;
                      if (inRange) {
                          count++;
                      }
                      else {
                          filtered = filtered.updateImmediateChild(next.name, ChildrenNode.EMPTY_NODE);
                      }
                  }
              }
          }
          return this.rangedFilter_
              .getIndexedFilter()
              .updateFullNode(oldSnap, filtered, optChangeAccumulator);
      };
      LimitedFilter.prototype.updatePriority = function (oldSnap, newPriority) {
          // Don't support priorities on queries
          return oldSnap;
      };
      LimitedFilter.prototype.filtersNodes = function () {
          return true;
      };
      LimitedFilter.prototype.getIndexedFilter = function () {
          return this.rangedFilter_.getIndexedFilter();
      };
      LimitedFilter.prototype.getIndex = function () {
          return this.index_;
      };
      LimitedFilter.prototype.fullLimitUpdateChild_ = function (snap, childKey, childSnap, source, changeAccumulator) {
          // TODO: rename all cache stuff etc to general snap terminology
          var cmp;
          if (this.reverse_) {
              var indexCmp_1 = this.index_.getCompare();
              cmp = function (a, b) { return indexCmp_1(b, a); };
          }
          else {
              cmp = this.index_.getCompare();
          }
          var oldEventCache = snap;
          util.assert(oldEventCache.numChildren() === this.limit_, '');
          var newChildNamedNode = new NamedNode(childKey, childSnap);
          var windowBoundary = this.reverse_
              ? oldEventCache.getFirstChild(this.index_)
              : oldEventCache.getLastChild(this.index_);
          var inRange = this.rangedFilter_.matches(newChildNamedNode);
          if (oldEventCache.hasChild(childKey)) {
              var oldChildSnap = oldEventCache.getImmediateChild(childKey);
              var nextChild = source.getChildAfterChild(this.index_, windowBoundary, this.reverse_);
              while (nextChild != null &&
                  (nextChild.name === childKey || oldEventCache.hasChild(nextChild.name))) {
                  // There is a weird edge case where a node is updated as part of a merge in the write tree, but hasn't
                  // been applied to the limited filter yet. Ignore this next child which will be updated later in
                  // the limited filter...
                  nextChild = source.getChildAfterChild(this.index_, nextChild, this.reverse_);
              }
              var compareNext = nextChild == null ? 1 : cmp(nextChild, newChildNamedNode);
              var remainsInWindow = inRange && !childSnap.isEmpty() && compareNext >= 0;
              if (remainsInWindow) {
                  if (changeAccumulator != null) {
                      changeAccumulator.trackChildChange(changeChildChanged(childKey, childSnap, oldChildSnap));
                  }
                  return oldEventCache.updateImmediateChild(childKey, childSnap);
              }
              else {
                  if (changeAccumulator != null) {
                      changeAccumulator.trackChildChange(changeChildRemoved(childKey, oldChildSnap));
                  }
                  var newEventCache = oldEventCache.updateImmediateChild(childKey, ChildrenNode.EMPTY_NODE);
                  var nextChildInRange = nextChild != null && this.rangedFilter_.matches(nextChild);
                  if (nextChildInRange) {
                      if (changeAccumulator != null) {
                          changeAccumulator.trackChildChange(changeChildAdded(nextChild.name, nextChild.node));
                      }
                      return newEventCache.updateImmediateChild(nextChild.name, nextChild.node);
                  }
                  else {
                      return newEventCache;
                  }
              }
          }
          else if (childSnap.isEmpty()) {
              // we're deleting a node, but it was not in the window, so ignore it
              return snap;
          }
          else if (inRange) {
              if (cmp(windowBoundary, newChildNamedNode) >= 0) {
                  if (changeAccumulator != null) {
                      changeAccumulator.trackChildChange(changeChildRemoved(windowBoundary.name, windowBoundary.node));
                      changeAccumulator.trackChildChange(changeChildAdded(childKey, childSnap));
                  }
                  return oldEventCache
                      .updateImmediateChild(childKey, childSnap)
                      .updateImmediateChild(windowBoundary.name, ChildrenNode.EMPTY_NODE);
              }
              else {
                  return snap;
              }
          }
          else {
              return snap;
          }
      };
      return LimitedFilter;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * This class is an immutable-from-the-public-api struct containing a set of query parameters defining a
   * range to be returned for a particular location. It is assumed that validation of parameters is done at the
   * user-facing API level, so it is not done here.
   *
   * @internal
   */
  var QueryParams = /** @class */ (function () {
      function QueryParams() {
          this.limitSet_ = false;
          this.startSet_ = false;
          this.startNameSet_ = false;
          this.startAfterSet_ = false;
          this.endSet_ = false;
          this.endNameSet_ = false;
          this.endBeforeSet_ = false;
          this.limit_ = 0;
          this.viewFrom_ = '';
          this.indexStartValue_ = null;
          this.indexStartName_ = '';
          this.indexEndValue_ = null;
          this.indexEndName_ = '';
          this.index_ = PRIORITY_INDEX;
      }
      QueryParams.prototype.hasStart = function () {
          return this.startSet_;
      };
      QueryParams.prototype.hasStartAfter = function () {
          return this.startAfterSet_;
      };
      QueryParams.prototype.hasEndBefore = function () {
          return this.endBeforeSet_;
      };
      /**
       * @returns True if it would return from left.
       */
      QueryParams.prototype.isViewFromLeft = function () {
          if (this.viewFrom_ === '') {
              // limit(), rather than limitToFirst or limitToLast was called.
              // This means that only one of startSet_ and endSet_ is true. Use them
              // to calculate which side of the view to anchor to. If neither is set,
              // anchor to the end.
              return this.startSet_;
          }
          else {
              return this.viewFrom_ === "l" /* VIEW_FROM_LEFT */;
          }
      };
      /**
       * Only valid to call if hasStart() returns true
       */
      QueryParams.prototype.getIndexStartValue = function () {
          util.assert(this.startSet_, 'Only valid if start has been set');
          return this.indexStartValue_;
      };
      /**
       * Only valid to call if hasStart() returns true.
       * Returns the starting key name for the range defined by these query parameters
       */
      QueryParams.prototype.getIndexStartName = function () {
          util.assert(this.startSet_, 'Only valid if start has been set');
          if (this.startNameSet_) {
              return this.indexStartName_;
          }
          else {
              return MIN_NAME;
          }
      };
      QueryParams.prototype.hasEnd = function () {
          return this.endSet_;
      };
      /**
       * Only valid to call if hasEnd() returns true.
       */
      QueryParams.prototype.getIndexEndValue = function () {
          util.assert(this.endSet_, 'Only valid if end has been set');
          return this.indexEndValue_;
      };
      /**
       * Only valid to call if hasEnd() returns true.
       * Returns the end key name for the range defined by these query parameters
       */
      QueryParams.prototype.getIndexEndName = function () {
          util.assert(this.endSet_, 'Only valid if end has been set');
          if (this.endNameSet_) {
              return this.indexEndName_;
          }
          else {
              return MAX_NAME;
          }
      };
      QueryParams.prototype.hasLimit = function () {
          return this.limitSet_;
      };
      /**
       * @returns True if a limit has been set and it has been explicitly anchored
       */
      QueryParams.prototype.hasAnchoredLimit = function () {
          return this.limitSet_ && this.viewFrom_ !== '';
      };
      /**
       * Only valid to call if hasLimit() returns true
       */
      QueryParams.prototype.getLimit = function () {
          util.assert(this.limitSet_, 'Only valid if limit has been set');
          return this.limit_;
      };
      QueryParams.prototype.getIndex = function () {
          return this.index_;
      };
      QueryParams.prototype.loadsAllData = function () {
          return !(this.startSet_ || this.endSet_ || this.limitSet_);
      };
      QueryParams.prototype.isDefault = function () {
          return this.loadsAllData() && this.index_ === PRIORITY_INDEX;
      };
      QueryParams.prototype.copy = function () {
          var copy = new QueryParams();
          copy.limitSet_ = this.limitSet_;
          copy.limit_ = this.limit_;
          copy.startSet_ = this.startSet_;
          copy.indexStartValue_ = this.indexStartValue_;
          copy.startNameSet_ = this.startNameSet_;
          copy.indexStartName_ = this.indexStartName_;
          copy.endSet_ = this.endSet_;
          copy.indexEndValue_ = this.indexEndValue_;
          copy.endNameSet_ = this.endNameSet_;
          copy.indexEndName_ = this.indexEndName_;
          copy.index_ = this.index_;
          copy.viewFrom_ = this.viewFrom_;
          return copy;
      };
      return QueryParams;
  }());
  function queryParamsGetNodeFilter(queryParams) {
      if (queryParams.loadsAllData()) {
          return new IndexedFilter(queryParams.getIndex());
      }
      else if (queryParams.hasLimit()) {
          return new LimitedFilter(queryParams);
      }
      else {
          return new RangedFilter(queryParams);
      }
  }
  function queryParamsLimitToFirst(queryParams, newLimit) {
      var newParams = queryParams.copy();
      newParams.limitSet_ = true;
      newParams.limit_ = newLimit;
      newParams.viewFrom_ = "l" /* VIEW_FROM_LEFT */;
      return newParams;
  }
  function queryParamsLimitToLast(queryParams, newLimit) {
      var newParams = queryParams.copy();
      newParams.limitSet_ = true;
      newParams.limit_ = newLimit;
      newParams.viewFrom_ = "r" /* VIEW_FROM_RIGHT */;
      return newParams;
  }
  function queryParamsStartAt(queryParams, indexValue, key) {
      var newParams = queryParams.copy();
      newParams.startSet_ = true;
      if (indexValue === undefined) {
          indexValue = null;
      }
      newParams.indexStartValue_ = indexValue;
      if (key != null) {
          newParams.startNameSet_ = true;
          newParams.indexStartName_ = key;
      }
      else {
          newParams.startNameSet_ = false;
          newParams.indexStartName_ = '';
      }
      return newParams;
  }
  function queryParamsStartAfter(queryParams, indexValue, key) {
      var params;
      if (queryParams.index_ === KEY_INDEX) {
          if (typeof indexValue === 'string') {
              indexValue = successor(indexValue);
          }
          params = queryParamsStartAt(queryParams, indexValue, key);
      }
      else {
          var childKey = void 0;
          if (key == null) {
              childKey = MAX_NAME;
          }
          else {
              childKey = successor(key);
          }
          params = queryParamsStartAt(queryParams, indexValue, childKey);
      }
      params.startAfterSet_ = true;
      return params;
  }
  function queryParamsEndAt(queryParams, indexValue, key) {
      var newParams = queryParams.copy();
      newParams.endSet_ = true;
      if (indexValue === undefined) {
          indexValue = null;
      }
      newParams.indexEndValue_ = indexValue;
      if (key !== undefined) {
          newParams.endNameSet_ = true;
          newParams.indexEndName_ = key;
      }
      else {
          newParams.endNameSet_ = false;
          newParams.indexEndName_ = '';
      }
      return newParams;
  }
  function queryParamsEndBefore(queryParams, indexValue, key) {
      var childKey;
      var params;
      if (queryParams.index_ === KEY_INDEX) {
          if (typeof indexValue === 'string') {
              indexValue = predecessor(indexValue);
          }
          params = queryParamsEndAt(queryParams, indexValue, key);
      }
      else {
          if (key == null) {
              childKey = MIN_NAME;
          }
          else {
              childKey = predecessor(key);
          }
          params = queryParamsEndAt(queryParams, indexValue, childKey);
      }
      params.endBeforeSet_ = true;
      return params;
  }
  function queryParamsOrderBy(queryParams, index) {
      var newParams = queryParams.copy();
      newParams.index_ = index;
      return newParams;
  }
  /**
   * Returns a set of REST query string parameters representing this query.
   *
   * @returns query string parameters
   */
  function queryParamsToRestQueryStringParameters(queryParams) {
      var qs = {};
      if (queryParams.isDefault()) {
          return qs;
      }
      var orderBy;
      if (queryParams.index_ === PRIORITY_INDEX) {
          orderBy = "$priority" /* PRIORITY_INDEX */;
      }
      else if (queryParams.index_ === VALUE_INDEX) {
          orderBy = "$value" /* VALUE_INDEX */;
      }
      else if (queryParams.index_ === KEY_INDEX) {
          orderBy = "$key" /* KEY_INDEX */;
      }
      else {
          util.assert(queryParams.index_ instanceof PathIndex, 'Unrecognized index type!');
          orderBy = queryParams.index_.toString();
      }
      qs["orderBy" /* ORDER_BY */] = util.stringify(orderBy);
      if (queryParams.startSet_) {
          qs["startAt" /* START_AT */] = util.stringify(queryParams.indexStartValue_);
          if (queryParams.startNameSet_) {
              qs["startAt" /* START_AT */] +=
                  ',' + util.stringify(queryParams.indexStartName_);
          }
      }
      if (queryParams.endSet_) {
          qs["endAt" /* END_AT */] = util.stringify(queryParams.indexEndValue_);
          if (queryParams.endNameSet_) {
              qs["endAt" /* END_AT */] +=
                  ',' + util.stringify(queryParams.indexEndName_);
          }
      }
      if (queryParams.limitSet_) {
          if (queryParams.isViewFromLeft()) {
              qs["limitToFirst" /* LIMIT_TO_FIRST */] = queryParams.limit_;
          }
          else {
              qs["limitToLast" /* LIMIT_TO_LAST */] = queryParams.limit_;
          }
      }
      return qs;
  }
  function queryParamsGetQueryObject(queryParams) {
      var obj = {};
      if (queryParams.startSet_) {
          obj["sp" /* INDEX_START_VALUE */] =
              queryParams.indexStartValue_;
          if (queryParams.startNameSet_) {
              obj["sn" /* INDEX_START_NAME */] =
                  queryParams.indexStartName_;
          }
      }
      if (queryParams.endSet_) {
          obj["ep" /* INDEX_END_VALUE */] = queryParams.indexEndValue_;
          if (queryParams.endNameSet_) {
              obj["en" /* INDEX_END_NAME */] = queryParams.indexEndName_;
          }
      }
      if (queryParams.limitSet_) {
          obj["l" /* LIMIT */] = queryParams.limit_;
          var viewFrom = queryParams.viewFrom_;
          if (viewFrom === '') {
              if (queryParams.isViewFromLeft()) {
                  viewFrom = "l" /* VIEW_FROM_LEFT */;
              }
              else {
                  viewFrom = "r" /* VIEW_FROM_RIGHT */;
              }
          }
          obj["vf" /* VIEW_FROM */] = viewFrom;
      }
      // For now, priority index is the default, so we only specify if it's some other index
      if (queryParams.index_ !== PRIORITY_INDEX) {
          obj["i" /* INDEX */] = queryParams.index_.toString();
      }
      return obj;
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * An implementation of ServerActions that communicates with the server via REST requests.
   * This is mostly useful for compatibility with crawlers, where we don't want to spin up a full
   * persistent connection (using WebSockets or long-polling)
   */
  var ReadonlyRestClient = /** @class */ (function (_super) {
      tslib.__extends(ReadonlyRestClient, _super);
      /**
       * @param repoInfo_ - Data about the namespace we are connecting to
       * @param onDataUpdate_ - A callback for new data from the server
       */
      function ReadonlyRestClient(repoInfo_, onDataUpdate_, authTokenProvider_, appCheckTokenProvider_) {
          var _this = _super.call(this) || this;
          _this.repoInfo_ = repoInfo_;
          _this.onDataUpdate_ = onDataUpdate_;
          _this.authTokenProvider_ = authTokenProvider_;
          _this.appCheckTokenProvider_ = appCheckTokenProvider_;
          /** @private {function(...[*])} */
          _this.log_ = logWrapper('p:rest:');
          /**
           * We don't actually need to track listens, except to prevent us calling an onComplete for a listen
           * that's been removed. :-/
           */
          _this.listens_ = {};
          return _this;
      }
      ReadonlyRestClient.prototype.reportStats = function (stats) {
          throw new Error('Method not implemented.');
      };
      ReadonlyRestClient.getListenId_ = function (query, tag) {
          if (tag !== undefined) {
              return 'tag$' + tag;
          }
          else {
              util.assert(query._queryParams.isDefault(), "should have a tag if it's not a default query.");
              return query._path.toString();
          }
      };
      /** @inheritDoc */
      ReadonlyRestClient.prototype.listen = function (query, currentHashFn, tag, onComplete) {
          var _this = this;
          var pathString = query._path.toString();
          this.log_('Listen called for ' + pathString + ' ' + query._queryIdentifier);
          // Mark this listener so we can tell if it's removed.
          var listenId = ReadonlyRestClient.getListenId_(query, tag);
          var thisListen = {};
          this.listens_[listenId] = thisListen;
          var queryStringParameters = queryParamsToRestQueryStringParameters(query._queryParams);
          this.restRequest_(pathString + '.json', queryStringParameters, function (error, result) {
              var data = result;
              if (error === 404) {
                  data = null;
                  error = null;
              }
              if (error === null) {
                  _this.onDataUpdate_(pathString, data, /*isMerge=*/ false, tag);
              }
              if (util.safeGet(_this.listens_, listenId) === thisListen) {
                  var status_1;
                  if (!error) {
                      status_1 = 'ok';
                  }
                  else if (error === 401) {
                      status_1 = 'permission_denied';
                  }
                  else {
                      status_1 = 'rest_error:' + error;
                  }
                  onComplete(status_1, null);
              }
          });
      };
      /** @inheritDoc */
      ReadonlyRestClient.prototype.unlisten = function (query, tag) {
          var listenId = ReadonlyRestClient.getListenId_(query, tag);
          delete this.listens_[listenId];
      };
      ReadonlyRestClient.prototype.get = function (query) {
          var _this = this;
          var queryStringParameters = queryParamsToRestQueryStringParameters(query._queryParams);
          var pathString = query._path.toString();
          var deferred = new util.Deferred();
          this.restRequest_(pathString + '.json', queryStringParameters, function (error, result) {
              var data = result;
              if (error === 404) {
                  data = null;
                  error = null;
              }
              if (error === null) {
                  _this.onDataUpdate_(pathString, data, 
                  /*isMerge=*/ false, 
                  /*tag=*/ null);
                  deferred.resolve(data);
              }
              else {
                  deferred.reject(new Error(data));
              }
          });
          return deferred.promise;
      };
      /** @inheritDoc */
      ReadonlyRestClient.prototype.refreshAuthToken = function (token) {
          // no-op since we just always call getToken.
      };
      /**
       * Performs a REST request to the given path, with the provided query string parameters,
       * and any auth credentials we have.
       */
      ReadonlyRestClient.prototype.restRequest_ = function (pathString, queryStringParameters, callback) {
          var _this = this;
          if (queryStringParameters === void 0) { queryStringParameters = {}; }
          queryStringParameters['format'] = 'export';
          return Promise.all([
              this.authTokenProvider_.getToken(/*forceRefresh=*/ false),
              this.appCheckTokenProvider_.getToken(/*forceRefresh=*/ false)
          ]).then(function (_a) {
              var _b = tslib.__read(_a, 2), authToken = _b[0], appCheckToken = _b[1];
              if (authToken && authToken.accessToken) {
                  queryStringParameters['auth'] = authToken.accessToken;
              }
              if (appCheckToken && appCheckToken.token) {
                  queryStringParameters['ac'] = appCheckToken.token;
              }
              var url = (_this.repoInfo_.secure ? 'https://' : 'http://') +
                  _this.repoInfo_.host +
                  pathString +
                  '?' +
                  'ns=' +
                  _this.repoInfo_.namespace +
                  util.querystring(queryStringParameters);
              _this.log_('Sending REST request for ' + url);
              var xhr = new XMLHttpRequest();
              xhr.onreadystatechange = function () {
                  if (callback && xhr.readyState === 4) {
                      _this.log_('REST Response for ' + url + ' received. status:', xhr.status, 'response:', xhr.responseText);
                      var res = null;
                      if (xhr.status >= 200 && xhr.status < 300) {
                          try {
                              res = util.jsonEval(xhr.responseText);
                          }
                          catch (e) {
                              warn('Failed to parse JSON response for ' +
                                  url +
                                  ': ' +
                                  xhr.responseText);
                          }
                          callback(null, res);
                      }
                      else {
                          // 401 and 404 are expected.
                          if (xhr.status !== 401 && xhr.status !== 404) {
                              warn('Got unsuccessful REST response for ' +
                                  url +
                                  ' Status: ' +
                                  xhr.status);
                          }
                          callback(xhr.status);
                      }
                      callback = null;
                  }
              };
              xhr.open('GET', url, /*asynchronous=*/ true);
              xhr.send();
          });
      };
      return ReadonlyRestClient;
  }(ServerActions));
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Mutable object which basically just stores a reference to the "latest" immutable snapshot.
   */
  var SnapshotHolder = /** @class */ (function () {
      function SnapshotHolder() {
          this.rootNode_ = ChildrenNode.EMPTY_NODE;
      }
      SnapshotHolder.prototype.getNode = function (path) {
          return this.rootNode_.getChild(path);
      };
      SnapshotHolder.prototype.updateSnapshot = function (path, newSnapshotNode) {
          this.rootNode_ = this.rootNode_.updateChild(path, newSnapshotNode);
      };
      return SnapshotHolder;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function newSparseSnapshotTree() {
      return {
          value: null,
          children: new Map()
      };
  }
  /**
   * Stores the given node at the specified path. If there is already a node
   * at a shallower path, it merges the new data into that snapshot node.
   *
   * @param path - Path to look up snapshot for.
   * @param data - The new data, or null.
   */
  function sparseSnapshotTreeRemember(sparseSnapshotTree, path, data) {
      if (pathIsEmpty(path)) {
          sparseSnapshotTree.value = data;
          sparseSnapshotTree.children.clear();
      }
      else if (sparseSnapshotTree.value !== null) {
          sparseSnapshotTree.value = sparseSnapshotTree.value.updateChild(path, data);
      }
      else {
          var childKey = pathGetFront(path);
          if (!sparseSnapshotTree.children.has(childKey)) {
              sparseSnapshotTree.children.set(childKey, newSparseSnapshotTree());
          }
          var child = sparseSnapshotTree.children.get(childKey);
          path = pathPopFront(path);
          sparseSnapshotTreeRemember(child, path, data);
      }
  }
  /**
   * Purge the data at path from the cache.
   *
   * @param path - Path to look up snapshot for.
   * @returns True if this node should now be removed.
   */
  function sparseSnapshotTreeForget(sparseSnapshotTree, path) {
      if (pathIsEmpty(path)) {
          sparseSnapshotTree.value = null;
          sparseSnapshotTree.children.clear();
          return true;
      }
      else {
          if (sparseSnapshotTree.value !== null) {
              if (sparseSnapshotTree.value.isLeafNode()) {
                  // We're trying to forget a node that doesn't exist
                  return false;
              }
              else {
                  var value = sparseSnapshotTree.value;
                  sparseSnapshotTree.value = null;
                  value.forEachChild(PRIORITY_INDEX, function (key, tree) {
                      sparseSnapshotTreeRemember(sparseSnapshotTree, new Path(key), tree);
                  });
                  return sparseSnapshotTreeForget(sparseSnapshotTree, path);
              }
          }
          else if (sparseSnapshotTree.children.size > 0) {
              var childKey = pathGetFront(path);
              path = pathPopFront(path);
              if (sparseSnapshotTree.children.has(childKey)) {
                  var safeToRemove = sparseSnapshotTreeForget(sparseSnapshotTree.children.get(childKey), path);
                  if (safeToRemove) {
                      sparseSnapshotTree.children.delete(childKey);
                  }
              }
              return sparseSnapshotTree.children.size === 0;
          }
          else {
              return true;
          }
      }
  }
  /**
   * Recursively iterates through all of the stored tree and calls the
   * callback on each one.
   *
   * @param prefixPath - Path to look up node for.
   * @param func - The function to invoke for each tree.
   */
  function sparseSnapshotTreeForEachTree(sparseSnapshotTree, prefixPath, func) {
      if (sparseSnapshotTree.value !== null) {
          func(prefixPath, sparseSnapshotTree.value);
      }
      else {
          sparseSnapshotTreeForEachChild(sparseSnapshotTree, function (key, tree) {
              var path = new Path(prefixPath.toString() + '/' + key);
              sparseSnapshotTreeForEachTree(tree, path, func);
          });
      }
  }
  /**
   * Iterates through each immediate child and triggers the callback.
   * Only seems to be used in tests.
   *
   * @param func - The function to invoke for each child.
   */
  function sparseSnapshotTreeForEachChild(sparseSnapshotTree, func) {
      sparseSnapshotTree.children.forEach(function (tree, key) {
          func(key, tree);
      });
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Returns the delta from the previous call to get stats.
   *
   * @param collection_ - The collection to "listen" to.
   */
  var StatsListener = /** @class */ (function () {
      function StatsListener(collection_) {
          this.collection_ = collection_;
          this.last_ = null;
      }
      StatsListener.prototype.get = function () {
          var newStats = this.collection_.get();
          var delta = tslib.__assign({}, newStats);
          if (this.last_) {
              each(this.last_, function (stat, value) {
                  delta[stat] = delta[stat] - value;
              });
          }
          this.last_ = newStats;
          return delta;
      };
      return StatsListener;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  // Assuming some apps may have a short amount of time on page, and a bulk of firebase operations probably
  // happen on page load, we try to report our first set of stats pretty quickly, but we wait at least 10
  // seconds to try to ensure the Firebase connection is established / settled.
  var FIRST_STATS_MIN_TIME = 10 * 1000;
  var FIRST_STATS_MAX_TIME = 30 * 1000;
  // We'll continue to report stats on average every 5 minutes.
  var REPORT_STATS_INTERVAL = 5 * 60 * 1000;
  var StatsReporter = /** @class */ (function () {
      function StatsReporter(collection, server_) {
          this.server_ = server_;
          this.statsToReport_ = {};
          this.statsListener_ = new StatsListener(collection);
          var timeout = FIRST_STATS_MIN_TIME +
              (FIRST_STATS_MAX_TIME - FIRST_STATS_MIN_TIME) * Math.random();
          setTimeoutNonBlocking(this.reportStats_.bind(this), Math.floor(timeout));
      }
      StatsReporter.prototype.reportStats_ = function () {
          var _this = this;
          var stats = this.statsListener_.get();
          var reportedStats = {};
          var haveStatsToReport = false;
          each(stats, function (stat, value) {
              if (value > 0 && util.contains(_this.statsToReport_, stat)) {
                  reportedStats[stat] = value;
                  haveStatsToReport = true;
              }
          });
          if (haveStatsToReport) {
              this.server_.reportStats(reportedStats);
          }
          // queue our next run.
          setTimeoutNonBlocking(this.reportStats_.bind(this), Math.floor(Math.random() * 2 * REPORT_STATS_INTERVAL));
      };
      return StatsReporter;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   *
   * @enum
   */
  var OperationType;
  (function (OperationType) {
      OperationType[OperationType["OVERWRITE"] = 0] = "OVERWRITE";
      OperationType[OperationType["MERGE"] = 1] = "MERGE";
      OperationType[OperationType["ACK_USER_WRITE"] = 2] = "ACK_USER_WRITE";
      OperationType[OperationType["LISTEN_COMPLETE"] = 3] = "LISTEN_COMPLETE";
  })(OperationType || (OperationType = {}));
  function newOperationSourceUser() {
      return {
          fromUser: true,
          fromServer: false,
          queryId: null,
          tagged: false
      };
  }
  function newOperationSourceServer() {
      return {
          fromUser: false,
          fromServer: true,
          queryId: null,
          tagged: false
      };
  }
  function newOperationSourceServerTaggedQuery(queryId) {
      return {
          fromUser: false,
          fromServer: true,
          queryId: queryId,
          tagged: true
      };
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var AckUserWrite = /** @class */ (function () {
      /**
       * @param affectedTree - A tree containing true for each affected path. Affected paths can't overlap.
       */
      function AckUserWrite(
      /** @inheritDoc */ path, 
      /** @inheritDoc */ affectedTree, 
      /** @inheritDoc */ revert) {
          this.path = path;
          this.affectedTree = affectedTree;
          this.revert = revert;
          /** @inheritDoc */
          this.type = OperationType.ACK_USER_WRITE;
          /** @inheritDoc */
          this.source = newOperationSourceUser();
      }
      AckUserWrite.prototype.operationForChild = function (childName) {
          if (!pathIsEmpty(this.path)) {
              util.assert(pathGetFront(this.path) === childName, 'operationForChild called for unrelated child.');
              return new AckUserWrite(pathPopFront(this.path), this.affectedTree, this.revert);
          }
          else if (this.affectedTree.value != null) {
              util.assert(this.affectedTree.children.isEmpty(), 'affectedTree should not have overlapping affected paths.');
              // All child locations are affected as well; just return same operation.
              return this;
          }
          else {
              var childTree = this.affectedTree.subtree(new Path(childName));
              return new AckUserWrite(newEmptyPath(), childTree, this.revert);
          }
      };
      return AckUserWrite;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var ListenComplete = /** @class */ (function () {
      function ListenComplete(source, path) {
          this.source = source;
          this.path = path;
          /** @inheritDoc */
          this.type = OperationType.LISTEN_COMPLETE;
      }
      ListenComplete.prototype.operationForChild = function (childName) {
          if (pathIsEmpty(this.path)) {
              return new ListenComplete(this.source, newEmptyPath());
          }
          else {
              return new ListenComplete(this.source, pathPopFront(this.path));
          }
      };
      return ListenComplete;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var Overwrite = /** @class */ (function () {
      function Overwrite(source, path, snap) {
          this.source = source;
          this.path = path;
          this.snap = snap;
          /** @inheritDoc */
          this.type = OperationType.OVERWRITE;
      }
      Overwrite.prototype.operationForChild = function (childName) {
          if (pathIsEmpty(this.path)) {
              return new Overwrite(this.source, newEmptyPath(), this.snap.getImmediateChild(childName));
          }
          else {
              return new Overwrite(this.source, pathPopFront(this.path), this.snap);
          }
      };
      return Overwrite;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var Merge = /** @class */ (function () {
      function Merge(
      /** @inheritDoc */ source, 
      /** @inheritDoc */ path, 
      /** @inheritDoc */ children) {
          this.source = source;
          this.path = path;
          this.children = children;
          /** @inheritDoc */
          this.type = OperationType.MERGE;
      }
      Merge.prototype.operationForChild = function (childName) {
          if (pathIsEmpty(this.path)) {
              var childTree = this.children.subtree(new Path(childName));
              if (childTree.isEmpty()) {
                  // This child is unaffected
                  return null;
              }
              else if (childTree.value) {
                  // We have a snapshot for the child in question.  This becomes an overwrite of the child.
                  return new Overwrite(this.source, newEmptyPath(), childTree.value);
              }
              else {
                  // This is a merge at a deeper level
                  return new Merge(this.source, newEmptyPath(), childTree);
              }
          }
          else {
              util.assert(pathGetFront(this.path) === childName, "Can't get a merge for a child not on the path of the operation");
              return new Merge(this.source, pathPopFront(this.path), this.children);
          }
      };
      Merge.prototype.toString = function () {
          return ('Operation(' +
              this.path +
              ': ' +
              this.source.toString() +
              ' merge: ' +
              this.children.toString() +
              ')');
      };
      return Merge;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * A cache node only stores complete children. Additionally it holds a flag whether the node can be considered fully
   * initialized in the sense that we know at one point in time this represented a valid state of the world, e.g.
   * initialized with data from the server, or a complete overwrite by the client. The filtered flag also tracks
   * whether a node potentially had children removed due to a filter.
   */
  var CacheNode = /** @class */ (function () {
      function CacheNode(node_, fullyInitialized_, filtered_) {
          this.node_ = node_;
          this.fullyInitialized_ = fullyInitialized_;
          this.filtered_ = filtered_;
      }
      /**
       * Returns whether this node was fully initialized with either server data or a complete overwrite by the client
       */
      CacheNode.prototype.isFullyInitialized = function () {
          return this.fullyInitialized_;
      };
      /**
       * Returns whether this node is potentially missing children due to a filter applied to the node
       */
      CacheNode.prototype.isFiltered = function () {
          return this.filtered_;
      };
      CacheNode.prototype.isCompleteForPath = function (path) {
          if (pathIsEmpty(path)) {
              return this.isFullyInitialized() && !this.filtered_;
          }
          var childKey = pathGetFront(path);
          return this.isCompleteForChild(childKey);
      };
      CacheNode.prototype.isCompleteForChild = function (key) {
          return ((this.isFullyInitialized() && !this.filtered_) || this.node_.hasChild(key));
      };
      CacheNode.prototype.getNode = function () {
          return this.node_;
      };
      return CacheNode;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * An EventGenerator is used to convert "raw" changes (Change) as computed by the
   * CacheDiffer into actual events (Event) that can be raised.  See generateEventsForChanges()
   * for details.
   *
   */
  var EventGenerator = /** @class */ (function () {
      function EventGenerator(query_) {
          this.query_ = query_;
          this.index_ = this.query_._queryParams.getIndex();
      }
      return EventGenerator;
  }());
  /**
   * Given a set of raw changes (no moved events and prevName not specified yet), and a set of
   * EventRegistrations that should be notified of these changes, generate the actual events to be raised.
   *
   * Notes:
   *  - child_moved events will be synthesized at this time for any child_changed events that affect
   *    our index.
   *  - prevName will be calculated based on the index ordering.
   */
  function eventGeneratorGenerateEventsForChanges(eventGenerator, changes, eventCache, eventRegistrations) {
      var events = [];
      var moves = [];
      changes.forEach(function (change) {
          if (change.type === "child_changed" /* CHILD_CHANGED */ &&
              eventGenerator.index_.indexedValueChanged(change.oldSnap, change.snapshotNode)) {
              moves.push(changeChildMoved(change.childName, change.snapshotNode));
          }
      });
      eventGeneratorGenerateEventsForType(eventGenerator, events, "child_removed" /* CHILD_REMOVED */, changes, eventRegistrations, eventCache);
      eventGeneratorGenerateEventsForType(eventGenerator, events, "child_added" /* CHILD_ADDED */, changes, eventRegistrations, eventCache);
      eventGeneratorGenerateEventsForType(eventGenerator, events, "child_moved" /* CHILD_MOVED */, moves, eventRegistrations, eventCache);
      eventGeneratorGenerateEventsForType(eventGenerator, events, "child_changed" /* CHILD_CHANGED */, changes, eventRegistrations, eventCache);
      eventGeneratorGenerateEventsForType(eventGenerator, events, "value" /* VALUE */, changes, eventRegistrations, eventCache);
      return events;
  }
  /**
   * Given changes of a single change type, generate the corresponding events.
   */
  function eventGeneratorGenerateEventsForType(eventGenerator, events, eventType, changes, registrations, eventCache) {
      var filteredChanges = changes.filter(function (change) { return change.type === eventType; });
      filteredChanges.sort(function (a, b) {
          return eventGeneratorCompareChanges(eventGenerator, a, b);
      });
      filteredChanges.forEach(function (change) {
          var materializedChange = eventGeneratorMaterializeSingleChange(eventGenerator, change, eventCache);
          registrations.forEach(function (registration) {
              if (registration.respondsTo(change.type)) {
                  events.push(registration.createEvent(materializedChange, eventGenerator.query_));
              }
          });
      });
  }
  function eventGeneratorMaterializeSingleChange(eventGenerator, change, eventCache) {
      if (change.type === 'value' || change.type === 'child_removed') {
          return change;
      }
      else {
          change.prevName = eventCache.getPredecessorChildName(change.childName, change.snapshotNode, eventGenerator.index_);
          return change;
      }
  }
  function eventGeneratorCompareChanges(eventGenerator, a, b) {
      if (a.childName == null || b.childName == null) {
          throw util.assertionError('Should only compare child_ events.');
      }
      var aWrapped = new NamedNode(a.childName, a.snapshotNode);
      var bWrapped = new NamedNode(b.childName, b.snapshotNode);
      return eventGenerator.index_.compare(aWrapped, bWrapped);
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function newViewCache(eventCache, serverCache) {
      return { eventCache: eventCache, serverCache: serverCache };
  }
  function viewCacheUpdateEventSnap(viewCache, eventSnap, complete, filtered) {
      return newViewCache(new CacheNode(eventSnap, complete, filtered), viewCache.serverCache);
  }
  function viewCacheUpdateServerSnap(viewCache, serverSnap, complete, filtered) {
      return newViewCache(viewCache.eventCache, new CacheNode(serverSnap, complete, filtered));
  }
  function viewCacheGetCompleteEventSnap(viewCache) {
      return viewCache.eventCache.isFullyInitialized()
          ? viewCache.eventCache.getNode()
          : null;
  }
  function viewCacheGetCompleteServerSnap(viewCache) {
      return viewCache.serverCache.isFullyInitialized()
          ? viewCache.serverCache.getNode()
          : null;
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var emptyChildrenSingleton;
  /**
   * Singleton empty children collection.
   *
   */
  var EmptyChildren = function () {
      if (!emptyChildrenSingleton) {
          emptyChildrenSingleton = new SortedMap(stringCompare);
      }
      return emptyChildrenSingleton;
  };
  /**
   * A tree with immutable elements.
   */
  var ImmutableTree = /** @class */ (function () {
      function ImmutableTree(value, children) {
          if (children === void 0) { children = EmptyChildren(); }
          this.value = value;
          this.children = children;
      }
      ImmutableTree.fromObject = function (obj) {
          var tree = new ImmutableTree(null);
          each(obj, function (childPath, childSnap) {
              tree = tree.set(new Path(childPath), childSnap);
          });
          return tree;
      };
      /**
       * True if the value is empty and there are no children
       */
      ImmutableTree.prototype.isEmpty = function () {
          return this.value === null && this.children.isEmpty();
      };
      /**
       * Given a path and predicate, return the first node and the path to that node
       * where the predicate returns true.
       *
       * TODO Do a perf test -- If we're creating a bunch of `{path: value:}`
       * objects on the way back out, it may be better to pass down a pathSoFar obj.
       *
       * @param relativePath - The remainder of the path
       * @param predicate - The predicate to satisfy to return a node
       */
      ImmutableTree.prototype.findRootMostMatchingPathAndValue = function (relativePath, predicate) {
          if (this.value != null && predicate(this.value)) {
              return { path: newEmptyPath(), value: this.value };
          }
          else {
              if (pathIsEmpty(relativePath)) {
                  return null;
              }
              else {
                  var front = pathGetFront(relativePath);
                  var child = this.children.get(front);
                  if (child !== null) {
                      var childExistingPathAndValue = child.findRootMostMatchingPathAndValue(pathPopFront(relativePath), predicate);
                      if (childExistingPathAndValue != null) {
                          var fullPath = pathChild(new Path(front), childExistingPathAndValue.path);
                          return { path: fullPath, value: childExistingPathAndValue.value };
                      }
                      else {
                          return null;
                      }
                  }
                  else {
                      return null;
                  }
              }
          }
      };
      /**
       * Find, if it exists, the shortest subpath of the given path that points a defined
       * value in the tree
       */
      ImmutableTree.prototype.findRootMostValueAndPath = function (relativePath) {
          return this.findRootMostMatchingPathAndValue(relativePath, function () { return true; });
      };
      /**
       * @returns The subtree at the given path
       */
      ImmutableTree.prototype.subtree = function (relativePath) {
          if (pathIsEmpty(relativePath)) {
              return this;
          }
          else {
              var front = pathGetFront(relativePath);
              var childTree = this.children.get(front);
              if (childTree !== null) {
                  return childTree.subtree(pathPopFront(relativePath));
              }
              else {
                  return new ImmutableTree(null);
              }
          }
      };
      /**
       * Sets a value at the specified path.
       *
       * @param relativePath - Path to set value at.
       * @param toSet - Value to set.
       * @returns Resulting tree.
       */
      ImmutableTree.prototype.set = function (relativePath, toSet) {
          if (pathIsEmpty(relativePath)) {
              return new ImmutableTree(toSet, this.children);
          }
          else {
              var front = pathGetFront(relativePath);
              var child = this.children.get(front) || new ImmutableTree(null);
              var newChild = child.set(pathPopFront(relativePath), toSet);
              var newChildren = this.children.insert(front, newChild);
              return new ImmutableTree(this.value, newChildren);
          }
      };
      /**
       * Removes the value at the specified path.
       *
       * @param relativePath - Path to value to remove.
       * @returns Resulting tree.
       */
      ImmutableTree.prototype.remove = function (relativePath) {
          if (pathIsEmpty(relativePath)) {
              if (this.children.isEmpty()) {
                  return new ImmutableTree(null);
              }
              else {
                  return new ImmutableTree(null, this.children);
              }
          }
          else {
              var front = pathGetFront(relativePath);
              var child = this.children.get(front);
              if (child) {
                  var newChild = child.remove(pathPopFront(relativePath));
                  var newChildren = void 0;
                  if (newChild.isEmpty()) {
                      newChildren = this.children.remove(front);
                  }
                  else {
                      newChildren = this.children.insert(front, newChild);
                  }
                  if (this.value === null && newChildren.isEmpty()) {
                      return new ImmutableTree(null);
                  }
                  else {
                      return new ImmutableTree(this.value, newChildren);
                  }
              }
              else {
                  return this;
              }
          }
      };
      /**
       * Gets a value from the tree.
       *
       * @param relativePath - Path to get value for.
       * @returns Value at path, or null.
       */
      ImmutableTree.prototype.get = function (relativePath) {
          if (pathIsEmpty(relativePath)) {
              return this.value;
          }
          else {
              var front = pathGetFront(relativePath);
              var child = this.children.get(front);
              if (child) {
                  return child.get(pathPopFront(relativePath));
              }
              else {
                  return null;
              }
          }
      };
      /**
       * Replace the subtree at the specified path with the given new tree.
       *
       * @param relativePath - Path to replace subtree for.
       * @param newTree - New tree.
       * @returns Resulting tree.
       */
      ImmutableTree.prototype.setTree = function (relativePath, newTree) {
          if (pathIsEmpty(relativePath)) {
              return newTree;
          }
          else {
              var front = pathGetFront(relativePath);
              var child = this.children.get(front) || new ImmutableTree(null);
              var newChild = child.setTree(pathPopFront(relativePath), newTree);
              var newChildren = void 0;
              if (newChild.isEmpty()) {
                  newChildren = this.children.remove(front);
              }
              else {
                  newChildren = this.children.insert(front, newChild);
              }
              return new ImmutableTree(this.value, newChildren);
          }
      };
      /**
       * Performs a depth first fold on this tree. Transforms a tree into a single
       * value, given a function that operates on the path to a node, an optional
       * current value, and a map of child names to folded subtrees
       */
      ImmutableTree.prototype.fold = function (fn) {
          return this.fold_(newEmptyPath(), fn);
      };
      /**
       * Recursive helper for public-facing fold() method
       */
      ImmutableTree.prototype.fold_ = function (pathSoFar, fn) {
          var accum = {};
          this.children.inorderTraversal(function (childKey, childTree) {
              accum[childKey] = childTree.fold_(pathChild(pathSoFar, childKey), fn);
          });
          return fn(pathSoFar, this.value, accum);
      };
      /**
       * Find the first matching value on the given path. Return the result of applying f to it.
       */
      ImmutableTree.prototype.findOnPath = function (path, f) {
          return this.findOnPath_(path, newEmptyPath(), f);
      };
      ImmutableTree.prototype.findOnPath_ = function (pathToFollow, pathSoFar, f) {
          var result = this.value ? f(pathSoFar, this.value) : false;
          if (result) {
              return result;
          }
          else {
              if (pathIsEmpty(pathToFollow)) {
                  return null;
              }
              else {
                  var front = pathGetFront(pathToFollow);
                  var nextChild = this.children.get(front);
                  if (nextChild) {
                      return nextChild.findOnPath_(pathPopFront(pathToFollow), pathChild(pathSoFar, front), f);
                  }
                  else {
                      return null;
                  }
              }
          }
      };
      ImmutableTree.prototype.foreachOnPath = function (path, f) {
          return this.foreachOnPath_(path, newEmptyPath(), f);
      };
      ImmutableTree.prototype.foreachOnPath_ = function (pathToFollow, currentRelativePath, f) {
          if (pathIsEmpty(pathToFollow)) {
              return this;
          }
          else {
              if (this.value) {
                  f(currentRelativePath, this.value);
              }
              var front = pathGetFront(pathToFollow);
              var nextChild = this.children.get(front);
              if (nextChild) {
                  return nextChild.foreachOnPath_(pathPopFront(pathToFollow), pathChild(currentRelativePath, front), f);
              }
              else {
                  return new ImmutableTree(null);
              }
          }
      };
      /**
       * Calls the given function for each node in the tree that has a value.
       *
       * @param f - A function to be called with the path from the root of the tree to
       * a node, and the value at that node. Called in depth-first order.
       */
      ImmutableTree.prototype.foreach = function (f) {
          this.foreach_(newEmptyPath(), f);
      };
      ImmutableTree.prototype.foreach_ = function (currentRelativePath, f) {
          this.children.inorderTraversal(function (childName, childTree) {
              childTree.foreach_(pathChild(currentRelativePath, childName), f);
          });
          if (this.value) {
              f(currentRelativePath, this.value);
          }
      };
      ImmutableTree.prototype.foreachChild = function (f) {
          this.children.inorderTraversal(function (childName, childTree) {
              if (childTree.value) {
                  f(childName, childTree.value);
              }
          });
      };
      return ImmutableTree;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * This class holds a collection of writes that can be applied to nodes in unison. It abstracts away the logic with
   * dealing with priority writes and multiple nested writes. At any given path there is only allowed to be one write
   * modifying that path. Any write to an existing path or shadowing an existing path will modify that existing write
   * to reflect the write added.
   */
  var CompoundWrite = /** @class */ (function () {
      function CompoundWrite(writeTree_) {
          this.writeTree_ = writeTree_;
      }
      CompoundWrite.empty = function () {
          return new CompoundWrite(new ImmutableTree(null));
      };
      return CompoundWrite;
  }());
  function compoundWriteAddWrite(compoundWrite, path, node) {
      if (pathIsEmpty(path)) {
          return new CompoundWrite(new ImmutableTree(node));
      }
      else {
          var rootmost = compoundWrite.writeTree_.findRootMostValueAndPath(path);
          if (rootmost != null) {
              var rootMostPath = rootmost.path;
              var value = rootmost.value;
              var relativePath = newRelativePath(rootMostPath, path);
              value = value.updateChild(relativePath, node);
              return new CompoundWrite(compoundWrite.writeTree_.set(rootMostPath, value));
          }
          else {
              var subtree = new ImmutableTree(node);
              var newWriteTree = compoundWrite.writeTree_.setTree(path, subtree);
              return new CompoundWrite(newWriteTree);
          }
      }
  }
  function compoundWriteAddWrites(compoundWrite, path, updates) {
      var newWrite = compoundWrite;
      each(updates, function (childKey, node) {
          newWrite = compoundWriteAddWrite(newWrite, pathChild(path, childKey), node);
      });
      return newWrite;
  }
  /**
   * Will remove a write at the given path and deeper paths. This will <em>not</em> modify a write at a higher
   * location, which must be removed by calling this method with that path.
   *
   * @param compoundWrite - The CompoundWrite to remove.
   * @param path - The path at which a write and all deeper writes should be removed
   * @returns The new CompoundWrite with the removed path
   */
  function compoundWriteRemoveWrite(compoundWrite, path) {
      if (pathIsEmpty(path)) {
          return CompoundWrite.empty();
      }
      else {
          var newWriteTree = compoundWrite.writeTree_.setTree(path, new ImmutableTree(null));
          return new CompoundWrite(newWriteTree);
      }
  }
  /**
   * Returns whether this CompoundWrite will fully overwrite a node at a given location and can therefore be
   * considered "complete".
   *
   * @param compoundWrite - The CompoundWrite to check.
   * @param path - The path to check for
   * @returns Whether there is a complete write at that path
   */
  function compoundWriteHasCompleteWrite(compoundWrite, path) {
      return compoundWriteGetCompleteNode(compoundWrite, path) != null;
  }
  /**
   * Returns a node for a path if and only if the node is a "complete" overwrite at that path. This will not aggregate
   * writes from deeper paths, but will return child nodes from a more shallow path.
   *
   * @param compoundWrite - The CompoundWrite to get the node from.
   * @param path - The path to get a complete write
   * @returns The node if complete at that path, or null otherwise.
   */
  function compoundWriteGetCompleteNode(compoundWrite, path) {
      var rootmost = compoundWrite.writeTree_.findRootMostValueAndPath(path);
      if (rootmost != null) {
          return compoundWrite.writeTree_
              .get(rootmost.path)
              .getChild(newRelativePath(rootmost.path, path));
      }
      else {
          return null;
      }
  }
  /**
   * Returns all children that are guaranteed to be a complete overwrite.
   *
   * @param compoundWrite - The CompoundWrite to get children from.
   * @returns A list of all complete children.
   */
  function compoundWriteGetCompleteChildren(compoundWrite) {
      var children = [];
      var node = compoundWrite.writeTree_.value;
      if (node != null) {
          // If it's a leaf node, it has no children; so nothing to do.
          if (!node.isLeafNode()) {
              node.forEachChild(PRIORITY_INDEX, function (childName, childNode) {
                  children.push(new NamedNode(childName, childNode));
              });
          }
      }
      else {
          compoundWrite.writeTree_.children.inorderTraversal(function (childName, childTree) {
              if (childTree.value != null) {
                  children.push(new NamedNode(childName, childTree.value));
              }
          });
      }
      return children;
  }
  function compoundWriteChildCompoundWrite(compoundWrite, path) {
      if (pathIsEmpty(path)) {
          return compoundWrite;
      }
      else {
          var shadowingNode = compoundWriteGetCompleteNode(compoundWrite, path);
          if (shadowingNode != null) {
              return new CompoundWrite(new ImmutableTree(shadowingNode));
          }
          else {
              return new CompoundWrite(compoundWrite.writeTree_.subtree(path));
          }
      }
  }
  /**
   * Returns true if this CompoundWrite is empty and therefore does not modify any nodes.
   * @returns Whether this CompoundWrite is empty
   */
  function compoundWriteIsEmpty(compoundWrite) {
      return compoundWrite.writeTree_.isEmpty();
  }
  /**
   * Applies this CompoundWrite to a node. The node is returned with all writes from this CompoundWrite applied to the
   * node
   * @param node - The node to apply this CompoundWrite to
   * @returns The node with all writes applied
   */
  function compoundWriteApply(compoundWrite, node) {
      return applySubtreeWrite(newEmptyPath(), compoundWrite.writeTree_, node);
  }
  function applySubtreeWrite(relativePath, writeTree, node) {
      if (writeTree.value != null) {
          // Since there a write is always a leaf, we're done here
          return node.updateChild(relativePath, writeTree.value);
      }
      else {
          var priorityWrite_1 = null;
          writeTree.children.inorderTraversal(function (childKey, childTree) {
              if (childKey === '.priority') {
                  // Apply priorities at the end so we don't update priorities for either empty nodes or forget
                  // to apply priorities to empty nodes that are later filled
                  util.assert(childTree.value !== null, 'Priority writes must always be leaf nodes');
                  priorityWrite_1 = childTree.value;
              }
              else {
                  node = applySubtreeWrite(pathChild(relativePath, childKey), childTree, node);
              }
          });
          // If there was a priority write, we only apply it if the node is not empty
          if (!node.getChild(relativePath).isEmpty() && priorityWrite_1 !== null) {
              node = node.updateChild(pathChild(relativePath, '.priority'), priorityWrite_1);
          }
          return node;
      }
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Create a new WriteTreeRef for the given path. For use with a new sync point at the given path.
   *
   */
  function writeTreeChildWrites(writeTree, path) {
      return newWriteTreeRef(path, writeTree);
  }
  /**
   * Record a new overwrite from user code.
   *
   * @param visible - This is set to false by some transactions. It should be excluded from event caches
   */
  function writeTreeAddOverwrite(writeTree, path, snap, writeId, visible) {
      util.assert(writeId > writeTree.lastWriteId, 'Stacking an older write on top of newer ones');
      if (visible === undefined) {
          visible = true;
      }
      writeTree.allWrites.push({
          path: path,
          snap: snap,
          writeId: writeId,
          visible: visible
      });
      if (visible) {
          writeTree.visibleWrites = compoundWriteAddWrite(writeTree.visibleWrites, path, snap);
      }
      writeTree.lastWriteId = writeId;
  }
  /**
   * Record a new merge from user code.
   */
  function writeTreeAddMerge(writeTree, path, changedChildren, writeId) {
      util.assert(writeId > writeTree.lastWriteId, 'Stacking an older merge on top of newer ones');
      writeTree.allWrites.push({
          path: path,
          children: changedChildren,
          writeId: writeId,
          visible: true
      });
      writeTree.visibleWrites = compoundWriteAddWrites(writeTree.visibleWrites, path, changedChildren);
      writeTree.lastWriteId = writeId;
  }
  function writeTreeGetWrite(writeTree, writeId) {
      for (var i = 0; i < writeTree.allWrites.length; i++) {
          var record = writeTree.allWrites[i];
          if (record.writeId === writeId) {
              return record;
          }
      }
      return null;
  }
  /**
   * Remove a write (either an overwrite or merge) that has been successfully acknowledge by the server. Recalculates
   * the tree if necessary.  We return true if it may have been visible, meaning views need to reevaluate.
   *
   * @returns true if the write may have been visible (meaning we'll need to reevaluate / raise
   * events as a result).
   */
  function writeTreeRemoveWrite(writeTree, writeId) {
      // Note: disabling this check. It could be a transaction that preempted another transaction, and thus was applied
      // out of order.
      //const validClear = revert || this.allWrites_.length === 0 || writeId <= this.allWrites_[0].writeId;
      //assert(validClear, "Either we don't have this write, or it's the first one in the queue");
      var idx = writeTree.allWrites.findIndex(function (s) {
          return s.writeId === writeId;
      });
      util.assert(idx >= 0, 'removeWrite called with nonexistent writeId.');
      var writeToRemove = writeTree.allWrites[idx];
      writeTree.allWrites.splice(idx, 1);
      var removedWriteWasVisible = writeToRemove.visible;
      var removedWriteOverlapsWithOtherWrites = false;
      var i = writeTree.allWrites.length - 1;
      while (removedWriteWasVisible && i >= 0) {
          var currentWrite = writeTree.allWrites[i];
          if (currentWrite.visible) {
              if (i >= idx &&
                  writeTreeRecordContainsPath_(currentWrite, writeToRemove.path)) {
                  // The removed write was completely shadowed by a subsequent write.
                  removedWriteWasVisible = false;
              }
              else if (pathContains(writeToRemove.path, currentWrite.path)) {
                  // Either we're covering some writes or they're covering part of us (depending on which came first).
                  removedWriteOverlapsWithOtherWrites = true;
              }
          }
          i--;
      }
      if (!removedWriteWasVisible) {
          return false;
      }
      else if (removedWriteOverlapsWithOtherWrites) {
          // There's some shadowing going on. Just rebuild the visible writes from scratch.
          writeTreeResetTree_(writeTree);
          return true;
      }
      else {
          // There's no shadowing.  We can safely just remove the write(s) from visibleWrites.
          if (writeToRemove.snap) {
              writeTree.visibleWrites = compoundWriteRemoveWrite(writeTree.visibleWrites, writeToRemove.path);
          }
          else {
              var children = writeToRemove.children;
              each(children, function (childName) {
                  writeTree.visibleWrites = compoundWriteRemoveWrite(writeTree.visibleWrites, pathChild(writeToRemove.path, childName));
              });
          }
          return true;
      }
  }
  function writeTreeRecordContainsPath_(writeRecord, path) {
      if (writeRecord.snap) {
          return pathContains(writeRecord.path, path);
      }
      else {
          for (var childName in writeRecord.children) {
              if (writeRecord.children.hasOwnProperty(childName) &&
                  pathContains(pathChild(writeRecord.path, childName), path)) {
                  return true;
              }
          }
          return false;
      }
  }
  /**
   * Re-layer the writes and merges into a tree so we can efficiently calculate event snapshots
   */
  function writeTreeResetTree_(writeTree) {
      writeTree.visibleWrites = writeTreeLayerTree_(writeTree.allWrites, writeTreeDefaultFilter_, newEmptyPath());
      if (writeTree.allWrites.length > 0) {
          writeTree.lastWriteId =
              writeTree.allWrites[writeTree.allWrites.length - 1].writeId;
      }
      else {
          writeTree.lastWriteId = -1;
      }
  }
  /**
   * The default filter used when constructing the tree. Keep everything that's visible.
   */
  function writeTreeDefaultFilter_(write) {
      return write.visible;
  }
  /**
   * Static method. Given an array of WriteRecords, a filter for which ones to include, and a path, construct the tree of
   * event data at that path.
   */
  function writeTreeLayerTree_(writes, filter, treeRoot) {
      var compoundWrite = CompoundWrite.empty();
      for (var i = 0; i < writes.length; ++i) {
          var write = writes[i];
          // Theory, a later set will either:
          // a) abort a relevant transaction, so no need to worry about excluding it from calculating that transaction
          // b) not be relevant to a transaction (separate branch), so again will not affect the data for that transaction
          if (filter(write)) {
              var writePath = write.path;
              var relativePath = void 0;
              if (write.snap) {
                  if (pathContains(treeRoot, writePath)) {
                      relativePath = newRelativePath(treeRoot, writePath);
                      compoundWrite = compoundWriteAddWrite(compoundWrite, relativePath, write.snap);
                  }
                  else if (pathContains(writePath, treeRoot)) {
                      relativePath = newRelativePath(writePath, treeRoot);
                      compoundWrite = compoundWriteAddWrite(compoundWrite, newEmptyPath(), write.snap.getChild(relativePath));
                  }
                  else ;
              }
              else if (write.children) {
                  if (pathContains(treeRoot, writePath)) {
                      relativePath = newRelativePath(treeRoot, writePath);
                      compoundWrite = compoundWriteAddWrites(compoundWrite, relativePath, write.children);
                  }
                  else if (pathContains(writePath, treeRoot)) {
                      relativePath = newRelativePath(writePath, treeRoot);
                      if (pathIsEmpty(relativePath)) {
                          compoundWrite = compoundWriteAddWrites(compoundWrite, newEmptyPath(), write.children);
                      }
                      else {
                          var child = util.safeGet(write.children, pathGetFront(relativePath));
                          if (child) {
                              // There exists a child in this node that matches the root path
                              var deepNode = child.getChild(pathPopFront(relativePath));
                              compoundWrite = compoundWriteAddWrite(compoundWrite, newEmptyPath(), deepNode);
                          }
                      }
                  }
                  else ;
              }
              else {
                  throw util.assertionError('WriteRecord should have .snap or .children');
              }
          }
      }
      return compoundWrite;
  }
  /**
   * Given optional, underlying server data, and an optional set of constraints (exclude some sets, include hidden
   * writes), attempt to calculate a complete snapshot for the given path
   *
   * @param writeIdsToExclude - An optional set to be excluded
   * @param includeHiddenWrites - Defaults to false, whether or not to layer on writes with visible set to false
   */
  function writeTreeCalcCompleteEventCache(writeTree, treePath, completeServerCache, writeIdsToExclude, includeHiddenWrites) {
      if (!writeIdsToExclude && !includeHiddenWrites) {
          var shadowingNode = compoundWriteGetCompleteNode(writeTree.visibleWrites, treePath);
          if (shadowingNode != null) {
              return shadowingNode;
          }
          else {
              var subMerge = compoundWriteChildCompoundWrite(writeTree.visibleWrites, treePath);
              if (compoundWriteIsEmpty(subMerge)) {
                  return completeServerCache;
              }
              else if (completeServerCache == null &&
                  !compoundWriteHasCompleteWrite(subMerge, newEmptyPath())) {
                  // We wouldn't have a complete snapshot, since there's no underlying data and no complete shadow
                  return null;
              }
              else {
                  var layeredCache = completeServerCache || ChildrenNode.EMPTY_NODE;
                  return compoundWriteApply(subMerge, layeredCache);
              }
          }
      }
      else {
          var merge = compoundWriteChildCompoundWrite(writeTree.visibleWrites, treePath);
          if (!includeHiddenWrites && compoundWriteIsEmpty(merge)) {
              return completeServerCache;
          }
          else {
              // If the server cache is null, and we don't have a complete cache, we need to return null
              if (!includeHiddenWrites &&
                  completeServerCache == null &&
                  !compoundWriteHasCompleteWrite(merge, newEmptyPath())) {
                  return null;
              }
              else {
                  var filter = function (write) {
                      return ((write.visible || includeHiddenWrites) &&
                          (!writeIdsToExclude ||
                              !~writeIdsToExclude.indexOf(write.writeId)) &&
                          (pathContains(write.path, treePath) ||
                              pathContains(treePath, write.path)));
                  };
                  var mergeAtPath = writeTreeLayerTree_(writeTree.allWrites, filter, treePath);
                  var layeredCache = completeServerCache || ChildrenNode.EMPTY_NODE;
                  return compoundWriteApply(mergeAtPath, layeredCache);
              }
          }
      }
  }
  /**
   * With optional, underlying server data, attempt to return a children node of children that we have complete data for.
   * Used when creating new views, to pre-fill their complete event children snapshot.
   */
  function writeTreeCalcCompleteEventChildren(writeTree, treePath, completeServerChildren) {
      var completeChildren = ChildrenNode.EMPTY_NODE;
      var topLevelSet = compoundWriteGetCompleteNode(writeTree.visibleWrites, treePath);
      if (topLevelSet) {
          if (!topLevelSet.isLeafNode()) {
              // we're shadowing everything. Return the children.
              topLevelSet.forEachChild(PRIORITY_INDEX, function (childName, childSnap) {
                  completeChildren = completeChildren.updateImmediateChild(childName, childSnap);
              });
          }
          return completeChildren;
      }
      else if (completeServerChildren) {
          // Layer any children we have on top of this
          // We know we don't have a top-level set, so just enumerate existing children
          var merge_1 = compoundWriteChildCompoundWrite(writeTree.visibleWrites, treePath);
          completeServerChildren.forEachChild(PRIORITY_INDEX, function (childName, childNode) {
              var node = compoundWriteApply(compoundWriteChildCompoundWrite(merge_1, new Path(childName)), childNode);
              completeChildren = completeChildren.updateImmediateChild(childName, node);
          });
          // Add any complete children we have from the set
          compoundWriteGetCompleteChildren(merge_1).forEach(function (namedNode) {
              completeChildren = completeChildren.updateImmediateChild(namedNode.name, namedNode.node);
          });
          return completeChildren;
      }
      else {
          // We don't have anything to layer on top of. Layer on any children we have
          // Note that we can return an empty snap if we have a defined delete
          var merge = compoundWriteChildCompoundWrite(writeTree.visibleWrites, treePath);
          compoundWriteGetCompleteChildren(merge).forEach(function (namedNode) {
              completeChildren = completeChildren.updateImmediateChild(namedNode.name, namedNode.node);
          });
          return completeChildren;
      }
  }
  /**
   * Given that the underlying server data has updated, determine what, if anything, needs to be
   * applied to the event cache.
   *
   * Possibilities:
   *
   * 1. No writes are shadowing. Events should be raised, the snap to be applied comes from the server data
   *
   * 2. Some write is completely shadowing. No events to be raised
   *
   * 3. Is partially shadowed. Events
   *
   * Either existingEventSnap or existingServerSnap must exist
   */
  function writeTreeCalcEventCacheAfterServerOverwrite(writeTree, treePath, childPath, existingEventSnap, existingServerSnap) {
      util.assert(existingEventSnap || existingServerSnap, 'Either existingEventSnap or existingServerSnap must exist');
      var path = pathChild(treePath, childPath);
      if (compoundWriteHasCompleteWrite(writeTree.visibleWrites, path)) {
          // At this point we can probably guarantee that we're in case 2, meaning no events
          // May need to check visibility while doing the findRootMostValueAndPath call
          return null;
      }
      else {
          // No complete shadowing. We're either partially shadowing or not shadowing at all.
          var childMerge = compoundWriteChildCompoundWrite(writeTree.visibleWrites, path);
          if (compoundWriteIsEmpty(childMerge)) {
              // We're not shadowing at all. Case 1
              return existingServerSnap.getChild(childPath);
          }
          else {
              // This could be more efficient if the serverNode + updates doesn't change the eventSnap
              // However this is tricky to find out, since user updates don't necessary change the server
              // snap, e.g. priority updates on empty nodes, or deep deletes. Another special case is if the server
              // adds nodes, but doesn't change any existing writes. It is therefore not enough to
              // only check if the updates change the serverNode.
              // Maybe check if the merge tree contains these special cases and only do a full overwrite in that case?
              return compoundWriteApply(childMerge, existingServerSnap.getChild(childPath));
          }
      }
  }
  /**
   * Returns a complete child for a given server snap after applying all user writes or null if there is no
   * complete child for this ChildKey.
   */
  function writeTreeCalcCompleteChild(writeTree, treePath, childKey, existingServerSnap) {
      var path = pathChild(treePath, childKey);
      var shadowingNode = compoundWriteGetCompleteNode(writeTree.visibleWrites, path);
      if (shadowingNode != null) {
          return shadowingNode;
      }
      else {
          if (existingServerSnap.isCompleteForChild(childKey)) {
              var childMerge = compoundWriteChildCompoundWrite(writeTree.visibleWrites, path);
              return compoundWriteApply(childMerge, existingServerSnap.getNode().getImmediateChild(childKey));
          }
          else {
              return null;
          }
      }
  }
  /**
   * Returns a node if there is a complete overwrite for this path. More specifically, if there is a write at
   * a higher path, this will return the child of that write relative to the write and this path.
   * Returns null if there is no write at this path.
   */
  function writeTreeShadowingWrite(writeTree, path) {
      return compoundWriteGetCompleteNode(writeTree.visibleWrites, path);
  }
  /**
   * This method is used when processing child remove events on a query. If we can, we pull in children that were outside
   * the window, but may now be in the window.
   */
  function writeTreeCalcIndexedSlice(writeTree, treePath, completeServerData, startPost, count, reverse, index) {
      var toIterate;
      var merge = compoundWriteChildCompoundWrite(writeTree.visibleWrites, treePath);
      var shadowingNode = compoundWriteGetCompleteNode(merge, newEmptyPath());
      if (shadowingNode != null) {
          toIterate = shadowingNode;
      }
      else if (completeServerData != null) {
          toIterate = compoundWriteApply(merge, completeServerData);
      }
      else {
          // no children to iterate on
          return [];
      }
      toIterate = toIterate.withIndex(index);
      if (!toIterate.isEmpty() && !toIterate.isLeafNode()) {
          var nodes = [];
          var cmp = index.getCompare();
          var iter = reverse
              ? toIterate.getReverseIteratorFrom(startPost, index)
              : toIterate.getIteratorFrom(startPost, index);
          var next = iter.getNext();
          while (next && nodes.length < count) {
              if (cmp(next, startPost) !== 0) {
                  nodes.push(next);
              }
              next = iter.getNext();
          }
          return nodes;
      }
      else {
          return [];
      }
  }
  function newWriteTree() {
      return {
          visibleWrites: CompoundWrite.empty(),
          allWrites: [],
          lastWriteId: -1
      };
  }
  /**
   * If possible, returns a complete event cache, using the underlying server data if possible. In addition, can be used
   * to get a cache that includes hidden writes, and excludes arbitrary writes. Note that customizing the returned node
   * can lead to a more expensive calculation.
   *
   * @param writeIdsToExclude - Optional writes to exclude.
   * @param includeHiddenWrites - Defaults to false, whether or not to layer on writes with visible set to false
   */
  function writeTreeRefCalcCompleteEventCache(writeTreeRef, completeServerCache, writeIdsToExclude, includeHiddenWrites) {
      return writeTreeCalcCompleteEventCache(writeTreeRef.writeTree, writeTreeRef.treePath, completeServerCache, writeIdsToExclude, includeHiddenWrites);
  }
  /**
   * If possible, returns a children node containing all of the complete children we have data for. The returned data is a
   * mix of the given server data and write data.
   *
   */
  function writeTreeRefCalcCompleteEventChildren(writeTreeRef, completeServerChildren) {
      return writeTreeCalcCompleteEventChildren(writeTreeRef.writeTree, writeTreeRef.treePath, completeServerChildren);
  }
  /**
   * Given that either the underlying server data has updated or the outstanding writes have updated, determine what,
   * if anything, needs to be applied to the event cache.
   *
   * Possibilities:
   *
   * 1. No writes are shadowing. Events should be raised, the snap to be applied comes from the server data
   *
   * 2. Some write is completely shadowing. No events to be raised
   *
   * 3. Is partially shadowed. Events should be raised
   *
   * Either existingEventSnap or existingServerSnap must exist, this is validated via an assert
   *
   *
   */
  function writeTreeRefCalcEventCacheAfterServerOverwrite(writeTreeRef, path, existingEventSnap, existingServerSnap) {
      return writeTreeCalcEventCacheAfterServerOverwrite(writeTreeRef.writeTree, writeTreeRef.treePath, path, existingEventSnap, existingServerSnap);
  }
  /**
   * Returns a node if there is a complete overwrite for this path. More specifically, if there is a write at
   * a higher path, this will return the child of that write relative to the write and this path.
   * Returns null if there is no write at this path.
   *
   */
  function writeTreeRefShadowingWrite(writeTreeRef, path) {
      return writeTreeShadowingWrite(writeTreeRef.writeTree, pathChild(writeTreeRef.treePath, path));
  }
  /**
   * This method is used when processing child remove events on a query. If we can, we pull in children that were outside
   * the window, but may now be in the window
   */
  function writeTreeRefCalcIndexedSlice(writeTreeRef, completeServerData, startPost, count, reverse, index) {
      return writeTreeCalcIndexedSlice(writeTreeRef.writeTree, writeTreeRef.treePath, completeServerData, startPost, count, reverse, index);
  }
  /**
   * Returns a complete child for a given server snap after applying all user writes or null if there is no
   * complete child for this ChildKey.
   */
  function writeTreeRefCalcCompleteChild(writeTreeRef, childKey, existingServerCache) {
      return writeTreeCalcCompleteChild(writeTreeRef.writeTree, writeTreeRef.treePath, childKey, existingServerCache);
  }
  /**
   * Return a WriteTreeRef for a child.
   */
  function writeTreeRefChild(writeTreeRef, childName) {
      return newWriteTreeRef(pathChild(writeTreeRef.treePath, childName), writeTreeRef.writeTree);
  }
  function newWriteTreeRef(path, writeTree) {
      return {
          treePath: path,
          writeTree: writeTree
      };
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var ChildChangeAccumulator = /** @class */ (function () {
      function ChildChangeAccumulator() {
          this.changeMap = new Map();
      }
      ChildChangeAccumulator.prototype.trackChildChange = function (change) {
          var type = change.type;
          var childKey = change.childName;
          util.assert(type === "child_added" /* CHILD_ADDED */ ||
              type === "child_changed" /* CHILD_CHANGED */ ||
              type === "child_removed" /* CHILD_REMOVED */, 'Only child changes supported for tracking');
          util.assert(childKey !== '.priority', 'Only non-priority child changes can be tracked.');
          var oldChange = this.changeMap.get(childKey);
          if (oldChange) {
              var oldType = oldChange.type;
              if (type === "child_added" /* CHILD_ADDED */ &&
                  oldType === "child_removed" /* CHILD_REMOVED */) {
                  this.changeMap.set(childKey, changeChildChanged(childKey, change.snapshotNode, oldChange.snapshotNode));
              }
              else if (type === "child_removed" /* CHILD_REMOVED */ &&
                  oldType === "child_added" /* CHILD_ADDED */) {
                  this.changeMap.delete(childKey);
              }
              else if (type === "child_removed" /* CHILD_REMOVED */ &&
                  oldType === "child_changed" /* CHILD_CHANGED */) {
                  this.changeMap.set(childKey, changeChildRemoved(childKey, oldChange.oldSnap));
              }
              else if (type === "child_changed" /* CHILD_CHANGED */ &&
                  oldType === "child_added" /* CHILD_ADDED */) {
                  this.changeMap.set(childKey, changeChildAdded(childKey, change.snapshotNode));
              }
              else if (type === "child_changed" /* CHILD_CHANGED */ &&
                  oldType === "child_changed" /* CHILD_CHANGED */) {
                  this.changeMap.set(childKey, changeChildChanged(childKey, change.snapshotNode, oldChange.oldSnap));
              }
              else {
                  throw util.assertionError('Illegal combination of changes: ' +
                      change +
                      ' occurred after ' +
                      oldChange);
              }
          }
          else {
              this.changeMap.set(childKey, change);
          }
      };
      ChildChangeAccumulator.prototype.getChanges = function () {
          return Array.from(this.changeMap.values());
      };
      return ChildChangeAccumulator;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * An implementation of CompleteChildSource that never returns any additional children
   */
  // eslint-disable-next-line @typescript-eslint/naming-convention
  var NoCompleteChildSource_ = /** @class */ (function () {
      function NoCompleteChildSource_() {
      }
      NoCompleteChildSource_.prototype.getCompleteChild = function (childKey) {
          return null;
      };
      NoCompleteChildSource_.prototype.getChildAfterChild = function (index, child, reverse) {
          return null;
      };
      return NoCompleteChildSource_;
  }());
  /**
   * Singleton instance.
   */
  var NO_COMPLETE_CHILD_SOURCE = new NoCompleteChildSource_();
  /**
   * An implementation of CompleteChildSource that uses a WriteTree in addition to any other server data or
   * old event caches available to calculate complete children.
   */
  var WriteTreeCompleteChildSource = /** @class */ (function () {
      function WriteTreeCompleteChildSource(writes_, viewCache_, optCompleteServerCache_) {
          if (optCompleteServerCache_ === void 0) { optCompleteServerCache_ = null; }
          this.writes_ = writes_;
          this.viewCache_ = viewCache_;
          this.optCompleteServerCache_ = optCompleteServerCache_;
      }
      WriteTreeCompleteChildSource.prototype.getCompleteChild = function (childKey) {
          var node = this.viewCache_.eventCache;
          if (node.isCompleteForChild(childKey)) {
              return node.getNode().getImmediateChild(childKey);
          }
          else {
              var serverNode = this.optCompleteServerCache_ != null
                  ? new CacheNode(this.optCompleteServerCache_, true, false)
                  : this.viewCache_.serverCache;
              return writeTreeRefCalcCompleteChild(this.writes_, childKey, serverNode);
          }
      };
      WriteTreeCompleteChildSource.prototype.getChildAfterChild = function (index, child, reverse) {
          var completeServerData = this.optCompleteServerCache_ != null
              ? this.optCompleteServerCache_
              : viewCacheGetCompleteServerSnap(this.viewCache_);
          var nodes = writeTreeRefCalcIndexedSlice(this.writes_, completeServerData, child, 1, reverse, index);
          if (nodes.length === 0) {
              return null;
          }
          else {
              return nodes[0];
          }
      };
      return WriteTreeCompleteChildSource;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function newViewProcessor(filter) {
      return { filter: filter };
  }
  function viewProcessorAssertIndexed(viewProcessor, viewCache) {
      util.assert(viewCache.eventCache.getNode().isIndexed(viewProcessor.filter.getIndex()), 'Event snap not indexed');
      util.assert(viewCache.serverCache.getNode().isIndexed(viewProcessor.filter.getIndex()), 'Server snap not indexed');
  }
  function viewProcessorApplyOperation(viewProcessor, oldViewCache, operation, writesCache, completeCache) {
      var accumulator = new ChildChangeAccumulator();
      var newViewCache, filterServerNode;
      if (operation.type === OperationType.OVERWRITE) {
          var overwrite = operation;
          if (overwrite.source.fromUser) {
              newViewCache = viewProcessorApplyUserOverwrite(viewProcessor, oldViewCache, overwrite.path, overwrite.snap, writesCache, completeCache, accumulator);
          }
          else {
              util.assert(overwrite.source.fromServer, 'Unknown source.');
              // We filter the node if it's a tagged update or the node has been previously filtered  and the
              // update is not at the root in which case it is ok (and necessary) to mark the node unfiltered
              // again
              filterServerNode =
                  overwrite.source.tagged ||
                      (oldViewCache.serverCache.isFiltered() && !pathIsEmpty(overwrite.path));
              newViewCache = viewProcessorApplyServerOverwrite(viewProcessor, oldViewCache, overwrite.path, overwrite.snap, writesCache, completeCache, filterServerNode, accumulator);
          }
      }
      else if (operation.type === OperationType.MERGE) {
          var merge = operation;
          if (merge.source.fromUser) {
              newViewCache = viewProcessorApplyUserMerge(viewProcessor, oldViewCache, merge.path, merge.children, writesCache, completeCache, accumulator);
          }
          else {
              util.assert(merge.source.fromServer, 'Unknown source.');
              // We filter the node if it's a tagged update or the node has been previously filtered
              filterServerNode =
                  merge.source.tagged || oldViewCache.serverCache.isFiltered();
              newViewCache = viewProcessorApplyServerMerge(viewProcessor, oldViewCache, merge.path, merge.children, writesCache, completeCache, filterServerNode, accumulator);
          }
      }
      else if (operation.type === OperationType.ACK_USER_WRITE) {
          var ackUserWrite = operation;
          if (!ackUserWrite.revert) {
              newViewCache = viewProcessorAckUserWrite(viewProcessor, oldViewCache, ackUserWrite.path, ackUserWrite.affectedTree, writesCache, completeCache, accumulator);
          }
          else {
              newViewCache = viewProcessorRevertUserWrite(viewProcessor, oldViewCache, ackUserWrite.path, writesCache, completeCache, accumulator);
          }
      }
      else if (operation.type === OperationType.LISTEN_COMPLETE) {
          newViewCache = viewProcessorListenComplete(viewProcessor, oldViewCache, operation.path, writesCache, accumulator);
      }
      else {
          throw util.assertionError('Unknown operation type: ' + operation.type);
      }
      var changes = accumulator.getChanges();
      viewProcessorMaybeAddValueEvent(oldViewCache, newViewCache, changes);
      return { viewCache: newViewCache, changes: changes };
  }
  function viewProcessorMaybeAddValueEvent(oldViewCache, newViewCache, accumulator) {
      var eventSnap = newViewCache.eventCache;
      if (eventSnap.isFullyInitialized()) {
          var isLeafOrEmpty = eventSnap.getNode().isLeafNode() || eventSnap.getNode().isEmpty();
          var oldCompleteSnap = viewCacheGetCompleteEventSnap(oldViewCache);
          if (accumulator.length > 0 ||
              !oldViewCache.eventCache.isFullyInitialized() ||
              (isLeafOrEmpty && !eventSnap.getNode().equals(oldCompleteSnap)) ||
              !eventSnap.getNode().getPriority().equals(oldCompleteSnap.getPriority())) {
              accumulator.push(changeValue(viewCacheGetCompleteEventSnap(newViewCache)));
          }
      }
  }
  function viewProcessorGenerateEventCacheAfterServerEvent(viewProcessor, viewCache, changePath, writesCache, source, accumulator) {
      var oldEventSnap = viewCache.eventCache;
      if (writeTreeRefShadowingWrite(writesCache, changePath) != null) {
          // we have a shadowing write, ignore changes
          return viewCache;
      }
      else {
          var newEventCache = void 0, serverNode = void 0;
          if (pathIsEmpty(changePath)) {
              // TODO: figure out how this plays with "sliding ack windows"
              util.assert(viewCache.serverCache.isFullyInitialized(), 'If change path is empty, we must have complete server data');
              if (viewCache.serverCache.isFiltered()) {
                  // We need to special case this, because we need to only apply writes to complete children, or
                  // we might end up raising events for incomplete children. If the server data is filtered deep
                  // writes cannot be guaranteed to be complete
                  var serverCache = viewCacheGetCompleteServerSnap(viewCache);
                  var completeChildren = serverCache instanceof ChildrenNode
                      ? serverCache
                      : ChildrenNode.EMPTY_NODE;
                  var completeEventChildren = writeTreeRefCalcCompleteEventChildren(writesCache, completeChildren);
                  newEventCache = viewProcessor.filter.updateFullNode(viewCache.eventCache.getNode(), completeEventChildren, accumulator);
              }
              else {
                  var completeNode = writeTreeRefCalcCompleteEventCache(writesCache, viewCacheGetCompleteServerSnap(viewCache));
                  newEventCache = viewProcessor.filter.updateFullNode(viewCache.eventCache.getNode(), completeNode, accumulator);
              }
          }
          else {
              var childKey = pathGetFront(changePath);
              if (childKey === '.priority') {
                  util.assert(pathGetLength(changePath) === 1, "Can't have a priority with additional path components");
                  var oldEventNode = oldEventSnap.getNode();
                  serverNode = viewCache.serverCache.getNode();
                  // we might have overwrites for this priority
                  var updatedPriority = writeTreeRefCalcEventCacheAfterServerOverwrite(writesCache, changePath, oldEventNode, serverNode);
                  if (updatedPriority != null) {
                      newEventCache = viewProcessor.filter.updatePriority(oldEventNode, updatedPriority);
                  }
                  else {
                      // priority didn't change, keep old node
                      newEventCache = oldEventSnap.getNode();
                  }
              }
              else {
                  var childChangePath = pathPopFront(changePath);
                  // update child
                  var newEventChild = void 0;
                  if (oldEventSnap.isCompleteForChild(childKey)) {
                      serverNode = viewCache.serverCache.getNode();
                      var eventChildUpdate = writeTreeRefCalcEventCacheAfterServerOverwrite(writesCache, changePath, oldEventSnap.getNode(), serverNode);
                      if (eventChildUpdate != null) {
                          newEventChild = oldEventSnap
                              .getNode()
                              .getImmediateChild(childKey)
                              .updateChild(childChangePath, eventChildUpdate);
                      }
                      else {
                          // Nothing changed, just keep the old child
                          newEventChild = oldEventSnap.getNode().getImmediateChild(childKey);
                      }
                  }
                  else {
                      newEventChild = writeTreeRefCalcCompleteChild(writesCache, childKey, viewCache.serverCache);
                  }
                  if (newEventChild != null) {
                      newEventCache = viewProcessor.filter.updateChild(oldEventSnap.getNode(), childKey, newEventChild, childChangePath, source, accumulator);
                  }
                  else {
                      // no complete child available or no change
                      newEventCache = oldEventSnap.getNode();
                  }
              }
          }
          return viewCacheUpdateEventSnap(viewCache, newEventCache, oldEventSnap.isFullyInitialized() || pathIsEmpty(changePath), viewProcessor.filter.filtersNodes());
      }
  }
  function viewProcessorApplyServerOverwrite(viewProcessor, oldViewCache, changePath, changedSnap, writesCache, completeCache, filterServerNode, accumulator) {
      var oldServerSnap = oldViewCache.serverCache;
      var newServerCache;
      var serverFilter = filterServerNode
          ? viewProcessor.filter
          : viewProcessor.filter.getIndexedFilter();
      if (pathIsEmpty(changePath)) {
          newServerCache = serverFilter.updateFullNode(oldServerSnap.getNode(), changedSnap, null);
      }
      else if (serverFilter.filtersNodes() && !oldServerSnap.isFiltered()) {
          // we want to filter the server node, but we didn't filter the server node yet, so simulate a full update
          var newServerNode = oldServerSnap
              .getNode()
              .updateChild(changePath, changedSnap);
          newServerCache = serverFilter.updateFullNode(oldServerSnap.getNode(), newServerNode, null);
      }
      else {
          var childKey = pathGetFront(changePath);
          if (!oldServerSnap.isCompleteForPath(changePath) &&
              pathGetLength(changePath) > 1) {
              // We don't update incomplete nodes with updates intended for other listeners
              return oldViewCache;
          }
          var childChangePath = pathPopFront(changePath);
          var childNode = oldServerSnap.getNode().getImmediateChild(childKey);
          var newChildNode = childNode.updateChild(childChangePath, changedSnap);
          if (childKey === '.priority') {
              newServerCache = serverFilter.updatePriority(oldServerSnap.getNode(), newChildNode);
          }
          else {
              newServerCache = serverFilter.updateChild(oldServerSnap.getNode(), childKey, newChildNode, childChangePath, NO_COMPLETE_CHILD_SOURCE, null);
          }
      }
      var newViewCache = viewCacheUpdateServerSnap(oldViewCache, newServerCache, oldServerSnap.isFullyInitialized() || pathIsEmpty(changePath), serverFilter.filtersNodes());
      var source = new WriteTreeCompleteChildSource(writesCache, newViewCache, completeCache);
      return viewProcessorGenerateEventCacheAfterServerEvent(viewProcessor, newViewCache, changePath, writesCache, source, accumulator);
  }
  function viewProcessorApplyUserOverwrite(viewProcessor, oldViewCache, changePath, changedSnap, writesCache, completeCache, accumulator) {
      var oldEventSnap = oldViewCache.eventCache;
      var newViewCache, newEventCache;
      var source = new WriteTreeCompleteChildSource(writesCache, oldViewCache, completeCache);
      if (pathIsEmpty(changePath)) {
          newEventCache = viewProcessor.filter.updateFullNode(oldViewCache.eventCache.getNode(), changedSnap, accumulator);
          newViewCache = viewCacheUpdateEventSnap(oldViewCache, newEventCache, true, viewProcessor.filter.filtersNodes());
      }
      else {
          var childKey = pathGetFront(changePath);
          if (childKey === '.priority') {
              newEventCache = viewProcessor.filter.updatePriority(oldViewCache.eventCache.getNode(), changedSnap);
              newViewCache = viewCacheUpdateEventSnap(oldViewCache, newEventCache, oldEventSnap.isFullyInitialized(), oldEventSnap.isFiltered());
          }
          else {
              var childChangePath = pathPopFront(changePath);
              var oldChild = oldEventSnap.getNode().getImmediateChild(childKey);
              var newChild = void 0;
              if (pathIsEmpty(childChangePath)) {
                  // Child overwrite, we can replace the child
                  newChild = changedSnap;
              }
              else {
                  var childNode = source.getCompleteChild(childKey);
                  if (childNode != null) {
                      if (pathGetBack(childChangePath) === '.priority' &&
                          childNode.getChild(pathParent(childChangePath)).isEmpty()) {
                          // This is a priority update on an empty node. If this node exists on the server, the
                          // server will send down the priority in the update, so ignore for now
                          newChild = childNode;
                      }
                      else {
                          newChild = childNode.updateChild(childChangePath, changedSnap);
                      }
                  }
                  else {
                      // There is no complete child node available
                      newChild = ChildrenNode.EMPTY_NODE;
                  }
              }
              if (!oldChild.equals(newChild)) {
                  var newEventSnap = viewProcessor.filter.updateChild(oldEventSnap.getNode(), childKey, newChild, childChangePath, source, accumulator);
                  newViewCache = viewCacheUpdateEventSnap(oldViewCache, newEventSnap, oldEventSnap.isFullyInitialized(), viewProcessor.filter.filtersNodes());
              }
              else {
                  newViewCache = oldViewCache;
              }
          }
      }
      return newViewCache;
  }
  function viewProcessorCacheHasChild(viewCache, childKey) {
      return viewCache.eventCache.isCompleteForChild(childKey);
  }
  function viewProcessorApplyUserMerge(viewProcessor, viewCache, path, changedChildren, writesCache, serverCache, accumulator) {
      // HACK: In the case of a limit query, there may be some changes that bump things out of the
      // window leaving room for new items.  It's important we process these changes first, so we
      // iterate the changes twice, first processing any that affect items currently in view.
      // TODO: I consider an item "in view" if cacheHasChild is true, which checks both the server
      // and event snap.  I'm not sure if this will result in edge cases when a child is in one but
      // not the other.
      var curViewCache = viewCache;
      changedChildren.foreach(function (relativePath, childNode) {
          var writePath = pathChild(path, relativePath);
          if (viewProcessorCacheHasChild(viewCache, pathGetFront(writePath))) {
              curViewCache = viewProcessorApplyUserOverwrite(viewProcessor, curViewCache, writePath, childNode, writesCache, serverCache, accumulator);
          }
      });
      changedChildren.foreach(function (relativePath, childNode) {
          var writePath = pathChild(path, relativePath);
          if (!viewProcessorCacheHasChild(viewCache, pathGetFront(writePath))) {
              curViewCache = viewProcessorApplyUserOverwrite(viewProcessor, curViewCache, writePath, childNode, writesCache, serverCache, accumulator);
          }
      });
      return curViewCache;
  }
  function viewProcessorApplyMerge(viewProcessor, node, merge) {
      merge.foreach(function (relativePath, childNode) {
          node = node.updateChild(relativePath, childNode);
      });
      return node;
  }
  function viewProcessorApplyServerMerge(viewProcessor, viewCache, path, changedChildren, writesCache, serverCache, filterServerNode, accumulator) {
      // If we don't have a cache yet, this merge was intended for a previously listen in the same location. Ignore it and
      // wait for the complete data update coming soon.
      if (viewCache.serverCache.getNode().isEmpty() &&
          !viewCache.serverCache.isFullyInitialized()) {
          return viewCache;
      }
      // HACK: In the case of a limit query, there may be some changes that bump things out of the
      // window leaving room for new items.  It's important we process these changes first, so we
      // iterate the changes twice, first processing any that affect items currently in view.
      // TODO: I consider an item "in view" if cacheHasChild is true, which checks both the server
      // and event snap.  I'm not sure if this will result in edge cases when a child is in one but
      // not the other.
      var curViewCache = viewCache;
      var viewMergeTree;
      if (pathIsEmpty(path)) {
          viewMergeTree = changedChildren;
      }
      else {
          viewMergeTree = new ImmutableTree(null).setTree(path, changedChildren);
      }
      var serverNode = viewCache.serverCache.getNode();
      viewMergeTree.children.inorderTraversal(function (childKey, childTree) {
          if (serverNode.hasChild(childKey)) {
              var serverChild = viewCache.serverCache
                  .getNode()
                  .getImmediateChild(childKey);
              var newChild = viewProcessorApplyMerge(viewProcessor, serverChild, childTree);
              curViewCache = viewProcessorApplyServerOverwrite(viewProcessor, curViewCache, new Path(childKey), newChild, writesCache, serverCache, filterServerNode, accumulator);
          }
      });
      viewMergeTree.children.inorderTraversal(function (childKey, childMergeTree) {
          var isUnknownDeepMerge = !viewCache.serverCache.isCompleteForChild(childKey) &&
              childMergeTree.value === undefined;
          if (!serverNode.hasChild(childKey) && !isUnknownDeepMerge) {
              var serverChild = viewCache.serverCache
                  .getNode()
                  .getImmediateChild(childKey);
              var newChild = viewProcessorApplyMerge(viewProcessor, serverChild, childMergeTree);
              curViewCache = viewProcessorApplyServerOverwrite(viewProcessor, curViewCache, new Path(childKey), newChild, writesCache, serverCache, filterServerNode, accumulator);
          }
      });
      return curViewCache;
  }
  function viewProcessorAckUserWrite(viewProcessor, viewCache, ackPath, affectedTree, writesCache, completeCache, accumulator) {
      if (writeTreeRefShadowingWrite(writesCache, ackPath) != null) {
          return viewCache;
      }
      // Only filter server node if it is currently filtered
      var filterServerNode = viewCache.serverCache.isFiltered();
      // Essentially we'll just get our existing server cache for the affected paths and re-apply it as a server update
      // now that it won't be shadowed.
      var serverCache = viewCache.serverCache;
      if (affectedTree.value != null) {
          // This is an overwrite.
          if ((pathIsEmpty(ackPath) && serverCache.isFullyInitialized()) ||
              serverCache.isCompleteForPath(ackPath)) {
              return viewProcessorApplyServerOverwrite(viewProcessor, viewCache, ackPath, serverCache.getNode().getChild(ackPath), writesCache, completeCache, filterServerNode, accumulator);
          }
          else if (pathIsEmpty(ackPath)) {
              // This is a goofy edge case where we are acking data at this location but don't have full data.  We
              // should just re-apply whatever we have in our cache as a merge.
              var changedChildren_1 = new ImmutableTree(null);
              serverCache.getNode().forEachChild(KEY_INDEX, function (name, node) {
                  changedChildren_1 = changedChildren_1.set(new Path(name), node);
              });
              return viewProcessorApplyServerMerge(viewProcessor, viewCache, ackPath, changedChildren_1, writesCache, completeCache, filterServerNode, accumulator);
          }
          else {
              return viewCache;
          }
      }
      else {
          // This is a merge.
          var changedChildren_2 = new ImmutableTree(null);
          affectedTree.foreach(function (mergePath, value) {
              var serverCachePath = pathChild(ackPath, mergePath);
              if (serverCache.isCompleteForPath(serverCachePath)) {
                  changedChildren_2 = changedChildren_2.set(mergePath, serverCache.getNode().getChild(serverCachePath));
              }
          });
          return viewProcessorApplyServerMerge(viewProcessor, viewCache, ackPath, changedChildren_2, writesCache, completeCache, filterServerNode, accumulator);
      }
  }
  function viewProcessorListenComplete(viewProcessor, viewCache, path, writesCache, accumulator) {
      var oldServerNode = viewCache.serverCache;
      var newViewCache = viewCacheUpdateServerSnap(viewCache, oldServerNode.getNode(), oldServerNode.isFullyInitialized() || pathIsEmpty(path), oldServerNode.isFiltered());
      return viewProcessorGenerateEventCacheAfterServerEvent(viewProcessor, newViewCache, path, writesCache, NO_COMPLETE_CHILD_SOURCE, accumulator);
  }
  function viewProcessorRevertUserWrite(viewProcessor, viewCache, path, writesCache, completeServerCache, accumulator) {
      var complete;
      if (writeTreeRefShadowingWrite(writesCache, path) != null) {
          return viewCache;
      }
      else {
          var source = new WriteTreeCompleteChildSource(writesCache, viewCache, completeServerCache);
          var oldEventCache = viewCache.eventCache.getNode();
          var newEventCache = void 0;
          if (pathIsEmpty(path) || pathGetFront(path) === '.priority') {
              var newNode = void 0;
              if (viewCache.serverCache.isFullyInitialized()) {
                  newNode = writeTreeRefCalcCompleteEventCache(writesCache, viewCacheGetCompleteServerSnap(viewCache));
              }
              else {
                  var serverChildren = viewCache.serverCache.getNode();
                  util.assert(serverChildren instanceof ChildrenNode, 'serverChildren would be complete if leaf node');
                  newNode = writeTreeRefCalcCompleteEventChildren(writesCache, serverChildren);
              }
              newNode = newNode;
              newEventCache = viewProcessor.filter.updateFullNode(oldEventCache, newNode, accumulator);
          }
          else {
              var childKey = pathGetFront(path);
              var newChild = writeTreeRefCalcCompleteChild(writesCache, childKey, viewCache.serverCache);
              if (newChild == null &&
                  viewCache.serverCache.isCompleteForChild(childKey)) {
                  newChild = oldEventCache.getImmediateChild(childKey);
              }
              if (newChild != null) {
                  newEventCache = viewProcessor.filter.updateChild(oldEventCache, childKey, newChild, pathPopFront(path), source, accumulator);
              }
              else if (viewCache.eventCache.getNode().hasChild(childKey)) {
                  // No complete child available, delete the existing one, if any
                  newEventCache = viewProcessor.filter.updateChild(oldEventCache, childKey, ChildrenNode.EMPTY_NODE, pathPopFront(path), source, accumulator);
              }
              else {
                  newEventCache = oldEventCache;
              }
              if (newEventCache.isEmpty() &&
                  viewCache.serverCache.isFullyInitialized()) {
                  // We might have reverted all child writes. Maybe the old event was a leaf node
                  complete = writeTreeRefCalcCompleteEventCache(writesCache, viewCacheGetCompleteServerSnap(viewCache));
                  if (complete.isLeafNode()) {
                      newEventCache = viewProcessor.filter.updateFullNode(newEventCache, complete, accumulator);
                  }
              }
          }
          complete =
              viewCache.serverCache.isFullyInitialized() ||
                  writeTreeRefShadowingWrite(writesCache, newEmptyPath()) != null;
          return viewCacheUpdateEventSnap(viewCache, newEventCache, complete, viewProcessor.filter.filtersNodes());
      }
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * A view represents a specific location and query that has 1 or more event registrations.
   *
   * It does several things:
   *  - Maintains the list of event registrations for this location/query.
   *  - Maintains a cache of the data visible for this location/query.
   *  - Applies new operations (via applyOperation), updates the cache, and based on the event
   *    registrations returns the set of events to be raised.
   */
  var View = /** @class */ (function () {
      function View(query_, initialViewCache) {
          this.query_ = query_;
          this.eventRegistrations_ = [];
          var params = this.query_._queryParams;
          var indexFilter = new IndexedFilter(params.getIndex());
          var filter = queryParamsGetNodeFilter(params);
          this.processor_ = newViewProcessor(filter);
          var initialServerCache = initialViewCache.serverCache;
          var initialEventCache = initialViewCache.eventCache;
          // Don't filter server node with other filter than index, wait for tagged listen
          var serverSnap = indexFilter.updateFullNode(ChildrenNode.EMPTY_NODE, initialServerCache.getNode(), null);
          var eventSnap = filter.updateFullNode(ChildrenNode.EMPTY_NODE, initialEventCache.getNode(), null);
          var newServerCache = new CacheNode(serverSnap, initialServerCache.isFullyInitialized(), indexFilter.filtersNodes());
          var newEventCache = new CacheNode(eventSnap, initialEventCache.isFullyInitialized(), filter.filtersNodes());
          this.viewCache_ = newViewCache(newEventCache, newServerCache);
          this.eventGenerator_ = new EventGenerator(this.query_);
      }
      Object.defineProperty(View.prototype, "query", {
          get: function () {
              return this.query_;
          },
          enumerable: false,
          configurable: true
      });
      return View;
  }());
  function viewGetServerCache(view) {
      return view.viewCache_.serverCache.getNode();
  }
  function viewGetCompleteNode(view) {
      return viewCacheGetCompleteEventSnap(view.viewCache_);
  }
  function viewGetCompleteServerCache(view, path) {
      var cache = viewCacheGetCompleteServerSnap(view.viewCache_);
      if (cache) {
          // If this isn't a "loadsAllData" view, then cache isn't actually a complete cache and
          // we need to see if it contains the child we're interested in.
          if (view.query._queryParams.loadsAllData() ||
              (!pathIsEmpty(path) &&
                  !cache.getImmediateChild(pathGetFront(path)).isEmpty())) {
              return cache.getChild(path);
          }
      }
      return null;
  }
  function viewIsEmpty(view) {
      return view.eventRegistrations_.length === 0;
  }
  function viewAddEventRegistration(view, eventRegistration) {
      view.eventRegistrations_.push(eventRegistration);
  }
  /**
   * @param eventRegistration - If null, remove all callbacks.
   * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
   * @returns Cancel events, if cancelError was provided.
   */
  function viewRemoveEventRegistration(view, eventRegistration, cancelError) {
      var cancelEvents = [];
      if (cancelError) {
          util.assert(eventRegistration == null, 'A cancel should cancel all event registrations.');
          var path_1 = view.query._path;
          view.eventRegistrations_.forEach(function (registration) {
              var maybeEvent = registration.createCancelEvent(cancelError, path_1);
              if (maybeEvent) {
                  cancelEvents.push(maybeEvent);
              }
          });
      }
      if (eventRegistration) {
          var remaining = [];
          for (var i = 0; i < view.eventRegistrations_.length; ++i) {
              var existing = view.eventRegistrations_[i];
              if (!existing.matches(eventRegistration)) {
                  remaining.push(existing);
              }
              else if (eventRegistration.hasAnyCallback()) {
                  // We're removing just this one
                  remaining = remaining.concat(view.eventRegistrations_.slice(i + 1));
                  break;
              }
          }
          view.eventRegistrations_ = remaining;
      }
      else {
          view.eventRegistrations_ = [];
      }
      return cancelEvents;
  }
  /**
   * Applies the given Operation, updates our cache, and returns the appropriate events.
   */
  function viewApplyOperation(view, operation, writesCache, completeServerCache) {
      if (operation.type === OperationType.MERGE &&
          operation.source.queryId !== null) {
          util.assert(viewCacheGetCompleteServerSnap(view.viewCache_), 'We should always have a full cache before handling merges');
          util.assert(viewCacheGetCompleteEventSnap(view.viewCache_), 'Missing event cache, even though we have a server cache');
      }
      var oldViewCache = view.viewCache_;
      var result = viewProcessorApplyOperation(view.processor_, oldViewCache, operation, writesCache, completeServerCache);
      viewProcessorAssertIndexed(view.processor_, result.viewCache);
      util.assert(result.viewCache.serverCache.isFullyInitialized() ||
          !oldViewCache.serverCache.isFullyInitialized(), 'Once a server snap is complete, it should never go back');
      view.viewCache_ = result.viewCache;
      return viewGenerateEventsForChanges_(view, result.changes, result.viewCache.eventCache.getNode(), null);
  }
  function viewGetInitialEvents(view, registration) {
      var eventSnap = view.viewCache_.eventCache;
      var initialChanges = [];
      if (!eventSnap.getNode().isLeafNode()) {
          var eventNode = eventSnap.getNode();
          eventNode.forEachChild(PRIORITY_INDEX, function (key, childNode) {
              initialChanges.push(changeChildAdded(key, childNode));
          });
      }
      if (eventSnap.isFullyInitialized()) {
          initialChanges.push(changeValue(eventSnap.getNode()));
      }
      return viewGenerateEventsForChanges_(view, initialChanges, eventSnap.getNode(), registration);
  }
  function viewGenerateEventsForChanges_(view, changes, eventCache, eventRegistration) {
      var registrations = eventRegistration
          ? [eventRegistration]
          : view.eventRegistrations_;
      return eventGeneratorGenerateEventsForChanges(view.eventGenerator_, changes, eventCache, registrations);
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var referenceConstructor$1;
  /**
   * SyncPoint represents a single location in a SyncTree with 1 or more event registrations, meaning we need to
   * maintain 1 or more Views at this location to cache server data and raise appropriate events for server changes
   * and user writes (set, transaction, update).
   *
   * It's responsible for:
   *  - Maintaining the set of 1 or more views necessary at this location (a SyncPoint with 0 views should be removed).
   *  - Proxying user / server operations to the views as appropriate (i.e. applyServerOverwrite,
   *    applyUserOverwrite, etc.)
   */
  var SyncPoint = /** @class */ (function () {
      function SyncPoint() {
          /**
           * The Views being tracked at this location in the tree, stored as a map where the key is a
           * queryId and the value is the View for that query.
           *
           * NOTE: This list will be quite small (usually 1, but perhaps 2 or 3; any more is an odd use case).
           */
          this.views = new Map();
      }
      return SyncPoint;
  }());
  function syncPointSetReferenceConstructor(val) {
      util.assert(!referenceConstructor$1, '__referenceConstructor has already been defined');
      referenceConstructor$1 = val;
  }
  function syncPointGetReferenceConstructor() {
      util.assert(referenceConstructor$1, 'Reference.ts has not been loaded');
      return referenceConstructor$1;
  }
  function syncPointIsEmpty(syncPoint) {
      return syncPoint.views.size === 0;
  }
  function syncPointApplyOperation(syncPoint, operation, writesCache, optCompleteServerCache) {
      var e_1, _a;
      var queryId = operation.source.queryId;
      if (queryId !== null) {
          var view = syncPoint.views.get(queryId);
          util.assert(view != null, 'SyncTree gave us an op for an invalid query.');
          return viewApplyOperation(view, operation, writesCache, optCompleteServerCache);
      }
      else {
          var events = [];
          try {
              for (var _b = tslib.__values(syncPoint.views.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
                  var view = _c.value;
                  events = events.concat(viewApplyOperation(view, operation, writesCache, optCompleteServerCache));
              }
          }
          catch (e_1_1) { e_1 = { error: e_1_1 }; }
          finally {
              try {
                  if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
              }
              finally { if (e_1) throw e_1.error; }
          }
          return events;
      }
  }
  /**
   * Get a view for the specified query.
   *
   * @param query - The query to return a view for
   * @param writesCache
   * @param serverCache
   * @param serverCacheComplete
   * @returns Events to raise.
   */
  function syncPointGetView(syncPoint, query, writesCache, serverCache, serverCacheComplete) {
      var queryId = query._queryIdentifier;
      var view = syncPoint.views.get(queryId);
      if (!view) {
          // TODO: make writesCache take flag for complete server node
          var eventCache = writeTreeRefCalcCompleteEventCache(writesCache, serverCacheComplete ? serverCache : null);
          var eventCacheComplete = false;
          if (eventCache) {
              eventCacheComplete = true;
          }
          else if (serverCache instanceof ChildrenNode) {
              eventCache = writeTreeRefCalcCompleteEventChildren(writesCache, serverCache);
              eventCacheComplete = false;
          }
          else {
              eventCache = ChildrenNode.EMPTY_NODE;
              eventCacheComplete = false;
          }
          var viewCache = newViewCache(new CacheNode(eventCache, eventCacheComplete, false), new CacheNode(serverCache, serverCacheComplete, false));
          return new View(query, viewCache);
      }
      return view;
  }
  /**
   * Add an event callback for the specified query.
   *
   * @param query
   * @param eventRegistration
   * @param writesCache
   * @param serverCache - Complete server cache, if we have it.
   * @param serverCacheComplete
   * @returns Events to raise.
   */
  function syncPointAddEventRegistration(syncPoint, query, eventRegistration, writesCache, serverCache, serverCacheComplete) {
      var view = syncPointGetView(syncPoint, query, writesCache, serverCache, serverCacheComplete);
      if (!syncPoint.views.has(query._queryIdentifier)) {
          syncPoint.views.set(query._queryIdentifier, view);
      }
      // This is guaranteed to exist now, we just created anything that was missing
      viewAddEventRegistration(view, eventRegistration);
      return viewGetInitialEvents(view, eventRegistration);
  }
  /**
   * Remove event callback(s).  Return cancelEvents if a cancelError is specified.
   *
   * If query is the default query, we'll check all views for the specified eventRegistration.
   * If eventRegistration is null, we'll remove all callbacks for the specified view(s).
   *
   * @param eventRegistration - If null, remove all callbacks.
   * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
   * @returns removed queries and any cancel events
   */
  function syncPointRemoveEventRegistration(syncPoint, query, eventRegistration, cancelError) {
      var e_2, _a;
      var queryId = query._queryIdentifier;
      var removed = [];
      var cancelEvents = [];
      var hadCompleteView = syncPointHasCompleteView(syncPoint);
      if (queryId === 'default') {
          try {
              // When you do ref.off(...), we search all views for the registration to remove.
              for (var _b = tslib.__values(syncPoint.views.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
                  var _d = tslib.__read(_c.value, 2), viewQueryId = _d[0], view = _d[1];
                  cancelEvents = cancelEvents.concat(viewRemoveEventRegistration(view, eventRegistration, cancelError));
                  if (viewIsEmpty(view)) {
                      syncPoint.views.delete(viewQueryId);
                      // We'll deal with complete views later.
                      if (!view.query._queryParams.loadsAllData()) {
                          removed.push(view.query);
                      }
                  }
              }
          }
          catch (e_2_1) { e_2 = { error: e_2_1 }; }
          finally {
              try {
                  if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
              }
              finally { if (e_2) throw e_2.error; }
          }
      }
      else {
          // remove the callback from the specific view.
          var view = syncPoint.views.get(queryId);
          if (view) {
              cancelEvents = cancelEvents.concat(viewRemoveEventRegistration(view, eventRegistration, cancelError));
              if (viewIsEmpty(view)) {
                  syncPoint.views.delete(queryId);
                  // We'll deal with complete views later.
                  if (!view.query._queryParams.loadsAllData()) {
                      removed.push(view.query);
                  }
              }
          }
      }
      if (hadCompleteView && !syncPointHasCompleteView(syncPoint)) {
          // We removed our last complete view.
          removed.push(new (syncPointGetReferenceConstructor())(query._repo, query._path));
      }
      return { removed: removed, events: cancelEvents };
  }
  function syncPointGetQueryViews(syncPoint) {
      var e_3, _a;
      var result = [];
      try {
          for (var _b = tslib.__values(syncPoint.views.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
              var view = _c.value;
              if (!view.query._queryParams.loadsAllData()) {
                  result.push(view);
              }
          }
      }
      catch (e_3_1) { e_3 = { error: e_3_1 }; }
      finally {
          try {
              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
          }
          finally { if (e_3) throw e_3.error; }
      }
      return result;
  }
  /**
   * @param path - The path to the desired complete snapshot
   * @returns A complete cache, if it exists
   */
  function syncPointGetCompleteServerCache(syncPoint, path) {
      var e_4, _a;
      var serverCache = null;
      try {
          for (var _b = tslib.__values(syncPoint.views.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
              var view = _c.value;
              serverCache = serverCache || viewGetCompleteServerCache(view, path);
          }
      }
      catch (e_4_1) { e_4 = { error: e_4_1 }; }
      finally {
          try {
              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
          }
          finally { if (e_4) throw e_4.error; }
      }
      return serverCache;
  }
  function syncPointViewForQuery(syncPoint, query) {
      var params = query._queryParams;
      if (params.loadsAllData()) {
          return syncPointGetCompleteView(syncPoint);
      }
      else {
          var queryId = query._queryIdentifier;
          return syncPoint.views.get(queryId);
      }
  }
  function syncPointViewExistsForQuery(syncPoint, query) {
      return syncPointViewForQuery(syncPoint, query) != null;
  }
  function syncPointHasCompleteView(syncPoint) {
      return syncPointGetCompleteView(syncPoint) != null;
  }
  function syncPointGetCompleteView(syncPoint) {
      var e_5, _a;
      try {
          for (var _b = tslib.__values(syncPoint.views.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
              var view = _c.value;
              if (view.query._queryParams.loadsAllData()) {
                  return view;
              }
          }
      }
      catch (e_5_1) { e_5 = { error: e_5_1 }; }
      finally {
          try {
              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
          }
          finally { if (e_5) throw e_5.error; }
      }
      return null;
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var referenceConstructor;
  function syncTreeSetReferenceConstructor(val) {
      util.assert(!referenceConstructor, '__referenceConstructor has already been defined');
      referenceConstructor = val;
  }
  function syncTreeGetReferenceConstructor() {
      util.assert(referenceConstructor, 'Reference.ts has not been loaded');
      return referenceConstructor;
  }
  /**
   * Static tracker for next query tag.
   */
  var syncTreeNextQueryTag_ = 1;
  /**
   * SyncTree is the central class for managing event callback registration, data caching, views
   * (query processing), and event generation.  There are typically two SyncTree instances for
   * each Repo, one for the normal Firebase data, and one for the .info data.
   *
   * It has a number of responsibilities, including:
   *  - Tracking all user event callbacks (registered via addEventRegistration() and removeEventRegistration()).
   *  - Applying and caching data changes for user set(), transaction(), and update() calls
   *    (applyUserOverwrite(), applyUserMerge()).
   *  - Applying and caching data changes for server data changes (applyServerOverwrite(),
   *    applyServerMerge()).
   *  - Generating user-facing events for server and user changes (all of the apply* methods
   *    return the set of events that need to be raised as a result).
   *  - Maintaining the appropriate set of server listens to ensure we are always subscribed
   *    to the correct set of paths and queries to satisfy the current set of user event
   *    callbacks (listens are started/stopped using the provided listenProvider).
   *
   * NOTE: Although SyncTree tracks event callbacks and calculates events to raise, the actual
   * events are returned to the caller rather than raised synchronously.
   *
   */
  var SyncTree = /** @class */ (function () {
      /**
       * @param listenProvider_ - Used by SyncTree to start / stop listening
       *   to server data.
       */
      function SyncTree(listenProvider_) {
          this.listenProvider_ = listenProvider_;
          /**
           * Tree of SyncPoints.  There's a SyncPoint at any location that has 1 or more views.
           */
          this.syncPointTree_ = new ImmutableTree(null);
          /**
           * A tree of all pending user writes (user-initiated set()'s, transaction()'s, update()'s, etc.).
           */
          this.pendingWriteTree_ = newWriteTree();
          this.tagToQueryMap = new Map();
          this.queryToTagMap = new Map();
      }
      return SyncTree;
  }());
  /**
   * Apply the data changes for a user-generated set() or transaction() call.
   *
   * @returns Events to raise.
   */
  function syncTreeApplyUserOverwrite(syncTree, path, newData, writeId, visible) {
      // Record pending write.
      writeTreeAddOverwrite(syncTree.pendingWriteTree_, path, newData, writeId, visible);
      if (!visible) {
          return [];
      }
      else {
          return syncTreeApplyOperationToSyncPoints_(syncTree, new Overwrite(newOperationSourceUser(), path, newData));
      }
  }
  /**
   * Apply the data from a user-generated update() call
   *
   * @returns Events to raise.
   */
  function syncTreeApplyUserMerge(syncTree, path, changedChildren, writeId) {
      // Record pending merge.
      writeTreeAddMerge(syncTree.pendingWriteTree_, path, changedChildren, writeId);
      var changeTree = ImmutableTree.fromObject(changedChildren);
      return syncTreeApplyOperationToSyncPoints_(syncTree, new Merge(newOperationSourceUser(), path, changeTree));
  }
  /**
   * Acknowledge a pending user write that was previously registered with applyUserOverwrite() or applyUserMerge().
   *
   * @param revert - True if the given write failed and needs to be reverted
   * @returns Events to raise.
   */
  function syncTreeAckUserWrite(syncTree, writeId, revert) {
      if (revert === void 0) { revert = false; }
      var write = writeTreeGetWrite(syncTree.pendingWriteTree_, writeId);
      var needToReevaluate = writeTreeRemoveWrite(syncTree.pendingWriteTree_, writeId);
      if (!needToReevaluate) {
          return [];
      }
      else {
          var affectedTree_1 = new ImmutableTree(null);
          if (write.snap != null) {
              // overwrite
              affectedTree_1 = affectedTree_1.set(newEmptyPath(), true);
          }
          else {
              each(write.children, function (pathString) {
                  affectedTree_1 = affectedTree_1.set(new Path(pathString), true);
              });
          }
          return syncTreeApplyOperationToSyncPoints_(syncTree, new AckUserWrite(write.path, affectedTree_1, revert));
      }
  }
  /**
   * Apply new server data for the specified path..
   *
   * @returns Events to raise.
   */
  function syncTreeApplyServerOverwrite(syncTree, path, newData) {
      return syncTreeApplyOperationToSyncPoints_(syncTree, new Overwrite(newOperationSourceServer(), path, newData));
  }
  /**
   * Apply new server data to be merged in at the specified path.
   *
   * @returns Events to raise.
   */
  function syncTreeApplyServerMerge(syncTree, path, changedChildren) {
      var changeTree = ImmutableTree.fromObject(changedChildren);
      return syncTreeApplyOperationToSyncPoints_(syncTree, new Merge(newOperationSourceServer(), path, changeTree));
  }
  /**
   * Apply a listen complete for a query
   *
   * @returns Events to raise.
   */
  function syncTreeApplyListenComplete(syncTree, path) {
      return syncTreeApplyOperationToSyncPoints_(syncTree, new ListenComplete(newOperationSourceServer(), path));
  }
  /**
   * Apply a listen complete for a tagged query
   *
   * @returns Events to raise.
   */
  function syncTreeApplyTaggedListenComplete(syncTree, path, tag) {
      var queryKey = syncTreeQueryKeyForTag_(syncTree, tag);
      if (queryKey) {
          var r = syncTreeParseQueryKey_(queryKey);
          var queryPath = r.path, queryId = r.queryId;
          var relativePath = newRelativePath(queryPath, path);
          var op = new ListenComplete(newOperationSourceServerTaggedQuery(queryId), relativePath);
          return syncTreeApplyTaggedOperation_(syncTree, queryPath, op);
      }
      else {
          // We've already removed the query. No big deal, ignore the update
          return [];
      }
  }
  /**
   * Remove event callback(s).
   *
   * If query is the default query, we'll check all queries for the specified eventRegistration.
   * If eventRegistration is null, we'll remove all callbacks for the specified query/queries.
   *
   * @param eventRegistration - If null, all callbacks are removed.
   * @param cancelError - If a cancelError is provided, appropriate cancel events will be returned.
   * @returns Cancel events, if cancelError was provided.
   */
  function syncTreeRemoveEventRegistration(syncTree, query, eventRegistration, cancelError) {
      // Find the syncPoint first. Then deal with whether or not it has matching listeners
      var path = query._path;
      var maybeSyncPoint = syncTree.syncPointTree_.get(path);
      var cancelEvents = [];
      // A removal on a default query affects all queries at that location. A removal on an indexed query, even one without
      // other query constraints, does *not* affect all queries at that location. So this check must be for 'default', and
      // not loadsAllData().
      if (maybeSyncPoint &&
          (query._queryIdentifier === 'default' ||
              syncPointViewExistsForQuery(maybeSyncPoint, query))) {
          var removedAndEvents = syncPointRemoveEventRegistration(maybeSyncPoint, query, eventRegistration, cancelError);
          if (syncPointIsEmpty(maybeSyncPoint)) {
              syncTree.syncPointTree_ = syncTree.syncPointTree_.remove(path);
          }
          var removed = removedAndEvents.removed;
          cancelEvents = removedAndEvents.events;
          // We may have just removed one of many listeners and can short-circuit this whole process
          // We may also not have removed a default listener, in which case all of the descendant listeners should already be
          // properly set up.
          //
          // Since indexed queries can shadow if they don't have other query constraints, check for loadsAllData(), instead of
          // queryId === 'default'
          var removingDefault = -1 !==
              removed.findIndex(function (query) {
                  return query._queryParams.loadsAllData();
              });
          var covered = syncTree.syncPointTree_.findOnPath(path, function (relativePath, parentSyncPoint) {
              return syncPointHasCompleteView(parentSyncPoint);
          });
          if (removingDefault && !covered) {
              var subtree = syncTree.syncPointTree_.subtree(path);
              // There are potentially child listeners. Determine what if any listens we need to send before executing the
              // removal
              if (!subtree.isEmpty()) {
                  // We need to fold over our subtree and collect the listeners to send
                  var newViews = syncTreeCollectDistinctViewsForSubTree_(subtree);
                  // Ok, we've collected all the listens we need. Set them up.
                  for (var i = 0; i < newViews.length; ++i) {
                      var view = newViews[i], newQuery = view.query;
                      var listener = syncTreeCreateListenerForView_(syncTree, view);
                      syncTree.listenProvider_.startListening(syncTreeQueryForListening_(newQuery), syncTreeTagForQuery_(syncTree, newQuery), listener.hashFn, listener.onComplete);
                  }
              }
          }
          // If we removed anything and we're not covered by a higher up listen, we need to stop listening on this query
          // The above block has us covered in terms of making sure we're set up on listens lower in the tree.
          // Also, note that if we have a cancelError, it's already been removed at the provider level.
          if (!covered && removed.length > 0 && !cancelError) {
              // If we removed a default, then we weren't listening on any of the other queries here. Just cancel the one
              // default. Otherwise, we need to iterate through and cancel each individual query
              if (removingDefault) {
                  // We don't tag default listeners
                  var defaultTag = null;
                  syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(query), defaultTag);
              }
              else {
                  removed.forEach(function (queryToRemove) {
                      var tagToRemove = syncTree.queryToTagMap.get(syncTreeMakeQueryKey_(queryToRemove));
                      syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToRemove), tagToRemove);
                  });
              }
          }
          // Now, clear all of the tags we're tracking for the removed listens
          syncTreeRemoveTags_(syncTree, removed);
      }
      return cancelEvents;
  }
  /**
   * Apply new server data for the specified tagged query.
   *
   * @returns Events to raise.
   */
  function syncTreeApplyTaggedQueryOverwrite(syncTree, path, snap, tag) {
      var queryKey = syncTreeQueryKeyForTag_(syncTree, tag);
      if (queryKey != null) {
          var r = syncTreeParseQueryKey_(queryKey);
          var queryPath = r.path, queryId = r.queryId;
          var relativePath = newRelativePath(queryPath, path);
          var op = new Overwrite(newOperationSourceServerTaggedQuery(queryId), relativePath, snap);
          return syncTreeApplyTaggedOperation_(syncTree, queryPath, op);
      }
      else {
          // Query must have been removed already
          return [];
      }
  }
  /**
   * Apply server data to be merged in for the specified tagged query.
   *
   * @returns Events to raise.
   */
  function syncTreeApplyTaggedQueryMerge(syncTree, path, changedChildren, tag) {
      var queryKey = syncTreeQueryKeyForTag_(syncTree, tag);
      if (queryKey) {
          var r = syncTreeParseQueryKey_(queryKey);
          var queryPath = r.path, queryId = r.queryId;
          var relativePath = newRelativePath(queryPath, path);
          var changeTree = ImmutableTree.fromObject(changedChildren);
          var op = new Merge(newOperationSourceServerTaggedQuery(queryId), relativePath, changeTree);
          return syncTreeApplyTaggedOperation_(syncTree, queryPath, op);
      }
      else {
          // We've already removed the query. No big deal, ignore the update
          return [];
      }
  }
  /**
   * Add an event callback for the specified query.
   *
   * @returns Events to raise.
   */
  function syncTreeAddEventRegistration(syncTree, query, eventRegistration) {
      var path = query._path;
      var serverCache = null;
      var foundAncestorDefaultView = false;
      // Any covering writes will necessarily be at the root, so really all we need to find is the server cache.
      // Consider optimizing this once there's a better understanding of what actual behavior will be.
      syncTree.syncPointTree_.foreachOnPath(path, function (pathToSyncPoint, sp) {
          var relativePath = newRelativePath(pathToSyncPoint, path);
          serverCache =
              serverCache || syncPointGetCompleteServerCache(sp, relativePath);
          foundAncestorDefaultView =
              foundAncestorDefaultView || syncPointHasCompleteView(sp);
      });
      var syncPoint = syncTree.syncPointTree_.get(path);
      if (!syncPoint) {
          syncPoint = new SyncPoint();
          syncTree.syncPointTree_ = syncTree.syncPointTree_.set(path, syncPoint);
      }
      else {
          foundAncestorDefaultView =
              foundAncestorDefaultView || syncPointHasCompleteView(syncPoint);
          serverCache =
              serverCache || syncPointGetCompleteServerCache(syncPoint, newEmptyPath());
      }
      var serverCacheComplete;
      if (serverCache != null) {
          serverCacheComplete = true;
      }
      else {
          serverCacheComplete = false;
          serverCache = ChildrenNode.EMPTY_NODE;
          var subtree = syncTree.syncPointTree_.subtree(path);
          subtree.foreachChild(function (childName, childSyncPoint) {
              var completeCache = syncPointGetCompleteServerCache(childSyncPoint, newEmptyPath());
              if (completeCache) {
                  serverCache = serverCache.updateImmediateChild(childName, completeCache);
              }
          });
      }
      var viewAlreadyExists = syncPointViewExistsForQuery(syncPoint, query);
      if (!viewAlreadyExists && !query._queryParams.loadsAllData()) {
          // We need to track a tag for this query
          var queryKey = syncTreeMakeQueryKey_(query);
          util.assert(!syncTree.queryToTagMap.has(queryKey), 'View does not exist, but we have a tag');
          var tag = syncTreeGetNextQueryTag_();
          syncTree.queryToTagMap.set(queryKey, tag);
          syncTree.tagToQueryMap.set(tag, queryKey);
      }
      var writesCache = writeTreeChildWrites(syncTree.pendingWriteTree_, path);
      var events = syncPointAddEventRegistration(syncPoint, query, eventRegistration, writesCache, serverCache, serverCacheComplete);
      if (!viewAlreadyExists && !foundAncestorDefaultView) {
          var view = syncPointViewForQuery(syncPoint, query);
          events = events.concat(syncTreeSetupListener_(syncTree, query, view));
      }
      return events;
  }
  /**
   * Returns a complete cache, if we have one, of the data at a particular path. If the location does not have a
   * listener above it, we will get a false "null". This shouldn't be a problem because transactions will always
   * have a listener above, and atomic operations would correctly show a jitter of <increment value> ->
   *     <incremented total> as the write is applied locally and then acknowledged at the server.
   *
   * Note: this method will *include* hidden writes from transaction with applyLocally set to false.
   *
   * @param path - The path to the data we want
   * @param writeIdsToExclude - A specific set to be excluded
   */
  function syncTreeCalcCompleteEventCache(syncTree, path, writeIdsToExclude) {
      var includeHiddenSets = true;
      var writeTree = syncTree.pendingWriteTree_;
      var serverCache = syncTree.syncPointTree_.findOnPath(path, function (pathSoFar, syncPoint) {
          var relativePath = newRelativePath(pathSoFar, path);
          var serverCache = syncPointGetCompleteServerCache(syncPoint, relativePath);
          if (serverCache) {
              return serverCache;
          }
      });
      return writeTreeCalcCompleteEventCache(writeTree, path, serverCache, writeIdsToExclude, includeHiddenSets);
  }
  function syncTreeGetServerValue(syncTree, query) {
      var path = query._path;
      var serverCache = null;
      // Any covering writes will necessarily be at the root, so really all we need to find is the server cache.
      // Consider optimizing this once there's a better understanding of what actual behavior will be.
      syncTree.syncPointTree_.foreachOnPath(path, function (pathToSyncPoint, sp) {
          var relativePath = newRelativePath(pathToSyncPoint, path);
          serverCache =
              serverCache || syncPointGetCompleteServerCache(sp, relativePath);
      });
      var syncPoint = syncTree.syncPointTree_.get(path);
      if (!syncPoint) {
          syncPoint = new SyncPoint();
          syncTree.syncPointTree_ = syncTree.syncPointTree_.set(path, syncPoint);
      }
      else {
          serverCache =
              serverCache || syncPointGetCompleteServerCache(syncPoint, newEmptyPath());
      }
      var serverCacheComplete = serverCache != null;
      var serverCacheNode = serverCacheComplete
          ? new CacheNode(serverCache, true, false)
          : null;
      var writesCache = writeTreeChildWrites(syncTree.pendingWriteTree_, query._path);
      var view = syncPointGetView(syncPoint, query, writesCache, serverCacheComplete ? serverCacheNode.getNode() : ChildrenNode.EMPTY_NODE, serverCacheComplete);
      return viewGetCompleteNode(view);
  }
  /**
   * A helper method that visits all descendant and ancestor SyncPoints, applying the operation.
   *
   * NOTES:
   * - Descendant SyncPoints will be visited first (since we raise events depth-first).
   *
   * - We call applyOperation() on each SyncPoint passing three things:
   *   1. A version of the Operation that has been made relative to the SyncPoint location.
   *   2. A WriteTreeRef of any writes we have cached at the SyncPoint location.
   *   3. A snapshot Node with cached server data, if we have it.
   *
   * - We concatenate all of the events returned by each SyncPoint and return the result.
   */
  function syncTreeApplyOperationToSyncPoints_(syncTree, operation) {
      return syncTreeApplyOperationHelper_(operation, syncTree.syncPointTree_, 
      /*serverCache=*/ null, writeTreeChildWrites(syncTree.pendingWriteTree_, newEmptyPath()));
  }
  /**
   * Recursive helper for applyOperationToSyncPoints_
   */
  function syncTreeApplyOperationHelper_(operation, syncPointTree, serverCache, writesCache) {
      if (pathIsEmpty(operation.path)) {
          return syncTreeApplyOperationDescendantsHelper_(operation, syncPointTree, serverCache, writesCache);
      }
      else {
          var syncPoint = syncPointTree.get(newEmptyPath());
          // If we don't have cached server data, see if we can get it from this SyncPoint.
          if (serverCache == null && syncPoint != null) {
              serverCache = syncPointGetCompleteServerCache(syncPoint, newEmptyPath());
          }
          var events = [];
          var childName = pathGetFront(operation.path);
          var childOperation = operation.operationForChild(childName);
          var childTree = syncPointTree.children.get(childName);
          if (childTree && childOperation) {
              var childServerCache = serverCache
                  ? serverCache.getImmediateChild(childName)
                  : null;
              var childWritesCache = writeTreeRefChild(writesCache, childName);
              events = events.concat(syncTreeApplyOperationHelper_(childOperation, childTree, childServerCache, childWritesCache));
          }
          if (syncPoint) {
              events = events.concat(syncPointApplyOperation(syncPoint, operation, writesCache, serverCache));
          }
          return events;
      }
  }
  /**
   * Recursive helper for applyOperationToSyncPoints_
   */
  function syncTreeApplyOperationDescendantsHelper_(operation, syncPointTree, serverCache, writesCache) {
      var syncPoint = syncPointTree.get(newEmptyPath());
      // If we don't have cached server data, see if we can get it from this SyncPoint.
      if (serverCache == null && syncPoint != null) {
          serverCache = syncPointGetCompleteServerCache(syncPoint, newEmptyPath());
      }
      var events = [];
      syncPointTree.children.inorderTraversal(function (childName, childTree) {
          var childServerCache = serverCache
              ? serverCache.getImmediateChild(childName)
              : null;
          var childWritesCache = writeTreeRefChild(writesCache, childName);
          var childOperation = operation.operationForChild(childName);
          if (childOperation) {
              events = events.concat(syncTreeApplyOperationDescendantsHelper_(childOperation, childTree, childServerCache, childWritesCache));
          }
      });
      if (syncPoint) {
          events = events.concat(syncPointApplyOperation(syncPoint, operation, writesCache, serverCache));
      }
      return events;
  }
  function syncTreeCreateListenerForView_(syncTree, view) {
      var query = view.query;
      var tag = syncTreeTagForQuery_(syncTree, query);
      return {
          hashFn: function () {
              var cache = viewGetServerCache(view) || ChildrenNode.EMPTY_NODE;
              return cache.hash();
          },
          onComplete: function (status) {
              if (status === 'ok') {
                  if (tag) {
                      return syncTreeApplyTaggedListenComplete(syncTree, query._path, tag);
                  }
                  else {
                      return syncTreeApplyListenComplete(syncTree, query._path);
                  }
              }
              else {
                  // If a listen failed, kill all of the listeners here, not just the one that triggered the error.
                  // Note that this may need to be scoped to just this listener if we change permissions on filtered children
                  var error = errorForServerCode(status, query);
                  return syncTreeRemoveEventRegistration(syncTree, query, 
                  /*eventRegistration*/ null, error);
              }
          }
      };
  }
  /**
   * Return the tag associated with the given query.
   */
  function syncTreeTagForQuery_(syncTree, query) {
      var queryKey = syncTreeMakeQueryKey_(query);
      return syncTree.queryToTagMap.get(queryKey);
  }
  /**
   * Given a query, computes a "queryKey" suitable for use in our queryToTagMap_.
   */
  function syncTreeMakeQueryKey_(query) {
      return query._path.toString() + '$' + query._queryIdentifier;
  }
  /**
   * Return the query associated with the given tag, if we have one
   */
  function syncTreeQueryKeyForTag_(syncTree, tag) {
      return syncTree.tagToQueryMap.get(tag);
  }
  /**
   * Given a queryKey (created by makeQueryKey), parse it back into a path and queryId.
   */
  function syncTreeParseQueryKey_(queryKey) {
      var splitIndex = queryKey.indexOf('$');
      util.assert(splitIndex !== -1 && splitIndex < queryKey.length - 1, 'Bad queryKey.');
      return {
          queryId: queryKey.substr(splitIndex + 1),
          path: new Path(queryKey.substr(0, splitIndex))
      };
  }
  /**
   * A helper method to apply tagged operations
   */
  function syncTreeApplyTaggedOperation_(syncTree, queryPath, operation) {
      var syncPoint = syncTree.syncPointTree_.get(queryPath);
      util.assert(syncPoint, "Missing sync point for query tag that we're tracking");
      var writesCache = writeTreeChildWrites(syncTree.pendingWriteTree_, queryPath);
      return syncPointApplyOperation(syncPoint, operation, writesCache, null);
  }
  /**
   * This collapses multiple unfiltered views into a single view, since we only need a single
   * listener for them.
   */
  function syncTreeCollectDistinctViewsForSubTree_(subtree) {
      return subtree.fold(function (relativePath, maybeChildSyncPoint, childMap) {
          if (maybeChildSyncPoint && syncPointHasCompleteView(maybeChildSyncPoint)) {
              var completeView = syncPointGetCompleteView(maybeChildSyncPoint);
              return [completeView];
          }
          else {
              // No complete view here, flatten any deeper listens into an array
              var views_1 = [];
              if (maybeChildSyncPoint) {
                  views_1 = syncPointGetQueryViews(maybeChildSyncPoint);
              }
              each(childMap, function (_key, childViews) {
                  views_1 = views_1.concat(childViews);
              });
              return views_1;
          }
      });
  }
  /**
   * Normalizes a query to a query we send the server for listening
   *
   * @returns The normalized query
   */
  function syncTreeQueryForListening_(query) {
      if (query._queryParams.loadsAllData() && !query._queryParams.isDefault()) {
          // We treat queries that load all data as default queries
          // Cast is necessary because ref() technically returns Firebase which is actually fb.api.Firebase which inherits
          // from Query
          return new (syncTreeGetReferenceConstructor())(query._repo, query._path);
      }
      else {
          return query;
      }
  }
  function syncTreeRemoveTags_(syncTree, queries) {
      for (var j = 0; j < queries.length; ++j) {
          var removedQuery = queries[j];
          if (!removedQuery._queryParams.loadsAllData()) {
              // We should have a tag for this
              var removedQueryKey = syncTreeMakeQueryKey_(removedQuery);
              var removedQueryTag = syncTree.queryToTagMap.get(removedQueryKey);
              syncTree.queryToTagMap.delete(removedQueryKey);
              syncTree.tagToQueryMap.delete(removedQueryTag);
          }
      }
  }
  /**
   * Static accessor for query tags.
   */
  function syncTreeGetNextQueryTag_() {
      return syncTreeNextQueryTag_++;
  }
  /**
   * For a given new listen, manage the de-duplication of outstanding subscriptions.
   *
   * @returns This method can return events to support synchronous data sources
   */
  function syncTreeSetupListener_(syncTree, query, view) {
      var path = query._path;
      var tag = syncTreeTagForQuery_(syncTree, query);
      var listener = syncTreeCreateListenerForView_(syncTree, view);
      var events = syncTree.listenProvider_.startListening(syncTreeQueryForListening_(query), tag, listener.hashFn, listener.onComplete);
      var subtree = syncTree.syncPointTree_.subtree(path);
      // The root of this subtree has our query. We're here because we definitely need to send a listen for that, but we
      // may need to shadow other listens as well.
      if (tag) {
          util.assert(!syncPointHasCompleteView(subtree.value), "If we're adding a query, it shouldn't be shadowed");
      }
      else {
          // Shadow everything at or below this location, this is a default listener.
          var queriesToStop = subtree.fold(function (relativePath, maybeChildSyncPoint, childMap) {
              if (!pathIsEmpty(relativePath) &&
                  maybeChildSyncPoint &&
                  syncPointHasCompleteView(maybeChildSyncPoint)) {
                  return [syncPointGetCompleteView(maybeChildSyncPoint).query];
              }
              else {
                  // No default listener here, flatten any deeper queries into an array
                  var queries_1 = [];
                  if (maybeChildSyncPoint) {
                      queries_1 = queries_1.concat(syncPointGetQueryViews(maybeChildSyncPoint).map(function (view) { return view.query; }));
                  }
                  each(childMap, function (_key, childQueries) {
                      queries_1 = queries_1.concat(childQueries);
                  });
                  return queries_1;
              }
          });
          for (var i = 0; i < queriesToStop.length; ++i) {
              var queryToStop = queriesToStop[i];
              syncTree.listenProvider_.stopListening(syncTreeQueryForListening_(queryToStop), syncTreeTagForQuery_(syncTree, queryToStop));
          }
      }
      return events;
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var ExistingValueProvider = /** @class */ (function () {
      function ExistingValueProvider(node_) {
          this.node_ = node_;
      }
      ExistingValueProvider.prototype.getImmediateChild = function (childName) {
          var child = this.node_.getImmediateChild(childName);
          return new ExistingValueProvider(child);
      };
      ExistingValueProvider.prototype.node = function () {
          return this.node_;
      };
      return ExistingValueProvider;
  }());
  var DeferredValueProvider = /** @class */ (function () {
      function DeferredValueProvider(syncTree, path) {
          this.syncTree_ = syncTree;
          this.path_ = path;
      }
      DeferredValueProvider.prototype.getImmediateChild = function (childName) {
          var childPath = pathChild(this.path_, childName);
          return new DeferredValueProvider(this.syncTree_, childPath);
      };
      DeferredValueProvider.prototype.node = function () {
          return syncTreeCalcCompleteEventCache(this.syncTree_, this.path_);
      };
      return DeferredValueProvider;
  }());
  /**
   * Generate placeholders for deferred values.
   */
  var generateWithValues = function (values) {
      values = values || {};
      values['timestamp'] = values['timestamp'] || new Date().getTime();
      return values;
  };
  /**
   * Value to use when firing local events. When writing server values, fire
   * local events with an approximate value, otherwise return value as-is.
   */
  var resolveDeferredLeafValue = function (value, existingVal, serverValues) {
      if (!value || typeof value !== 'object') {
          return value;
      }
      util.assert('.sv' in value, 'Unexpected leaf node or priority contents');
      if (typeof value['.sv'] === 'string') {
          return resolveScalarDeferredValue(value['.sv'], existingVal, serverValues);
      }
      else if (typeof value['.sv'] === 'object') {
          return resolveComplexDeferredValue(value['.sv'], existingVal);
      }
      else {
          util.assert(false, 'Unexpected server value: ' + JSON.stringify(value, null, 2));
      }
  };
  var resolveScalarDeferredValue = function (op, existing, serverValues) {
      switch (op) {
          case 'timestamp':
              return serverValues['timestamp'];
          default:
              util.assert(false, 'Unexpected server value: ' + op);
      }
  };
  var resolveComplexDeferredValue = function (op, existing, unused) {
      if (!op.hasOwnProperty('increment')) {
          util.assert(false, 'Unexpected server value: ' + JSON.stringify(op, null, 2));
      }
      var delta = op['increment'];
      if (typeof delta !== 'number') {
          util.assert(false, 'Unexpected increment value: ' + delta);
      }
      var existingNode = existing.node();
      util.assert(existingNode !== null && typeof existingNode !== 'undefined', 'Expected ChildrenNode.EMPTY_NODE for nulls');
      // Incrementing a non-number sets the value to the incremented amount
      if (!existingNode.isLeafNode()) {
          return delta;
      }
      var leaf = existingNode;
      var existingVal = leaf.getValue();
      if (typeof existingVal !== 'number') {
          return delta;
      }
      // No need to do over/underflow arithmetic here because JS only handles floats under the covers
      return existingVal + delta;
  };
  /**
   * Recursively replace all deferred values and priorities in the tree with the
   * specified generated replacement values.
   * @param path - path to which write is relative
   * @param node - new data written at path
   * @param syncTree - current data
   */
  var resolveDeferredValueTree = function (path, node, syncTree, serverValues) {
      return resolveDeferredValue(node, new DeferredValueProvider(syncTree, path), serverValues);
  };
  /**
   * Recursively replace all deferred values and priorities in the node with the
   * specified generated replacement values.  If there are no server values in the node,
   * it'll be returned as-is.
   */
  var resolveDeferredValueSnapshot = function (node, existing, serverValues) {
      return resolveDeferredValue(node, new ExistingValueProvider(existing), serverValues);
  };
  function resolveDeferredValue(node, existingVal, serverValues) {
      var rawPri = node.getPriority().val();
      var priority = resolveDeferredLeafValue(rawPri, existingVal.getImmediateChild('.priority'), serverValues);
      var newNode;
      if (node.isLeafNode()) {
          var leafNode = node;
          var value = resolveDeferredLeafValue(leafNode.getValue(), existingVal, serverValues);
          if (value !== leafNode.getValue() ||
              priority !== leafNode.getPriority().val()) {
              return new LeafNode(value, nodeFromJSON(priority));
          }
          else {
              return node;
          }
      }
      else {
          var childrenNode = node;
          newNode = childrenNode;
          if (priority !== childrenNode.getPriority().val()) {
              newNode = newNode.updatePriority(new LeafNode(priority));
          }
          childrenNode.forEachChild(PRIORITY_INDEX, function (childName, childNode) {
              var newChildNode = resolveDeferredValue(childNode, existingVal.getImmediateChild(childName), serverValues);
              if (newChildNode !== childNode) {
                  newNode = newNode.updateImmediateChild(childName, newChildNode);
              }
          });
          return newNode;
      }
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * A light-weight tree, traversable by path.  Nodes can have both values and children.
   * Nodes are not enumerated (by forEachChild) unless they have a value or non-empty
   * children.
   */
  var Tree = /** @class */ (function () {
      /**
       * @param name - Optional name of the node.
       * @param parent - Optional parent node.
       * @param node - Optional node to wrap.
       */
      function Tree(name, parent, node) {
          if (name === void 0) { name = ''; }
          if (parent === void 0) { parent = null; }
          if (node === void 0) { node = { children: {}, childCount: 0 }; }
          this.name = name;
          this.parent = parent;
          this.node = node;
      }
      return Tree;
  }());
  /**
   * Returns a sub-Tree for the given path.
   *
   * @param pathObj - Path to look up.
   * @returns Tree for path.
   */
  function treeSubTree(tree, pathObj) {
      // TODO: Require pathObj to be Path?
      var path = pathObj instanceof Path ? pathObj : new Path(pathObj);
      var child = tree, next = pathGetFront(path);
      while (next !== null) {
          var childNode = util.safeGet(child.node.children, next) || {
              children: {},
              childCount: 0
          };
          child = new Tree(next, child, childNode);
          path = pathPopFront(path);
          next = pathGetFront(path);
      }
      return child;
  }
  /**
   * Returns the data associated with this tree node.
   *
   * @returns The data or null if no data exists.
   */
  function treeGetValue(tree) {
      return tree.node.value;
  }
  /**
   * Sets data to this tree node.
   *
   * @param value - Value to set.
   */
  function treeSetValue(tree, value) {
      tree.node.value = value;
      treeUpdateParents(tree);
  }
  /**
   * @returns Whether the tree has any children.
   */
  function treeHasChildren(tree) {
      return tree.node.childCount > 0;
  }
  /**
   * @returns Whethe rthe tree is empty (no value or children).
   */
  function treeIsEmpty(tree) {
      return treeGetValue(tree) === undefined && !treeHasChildren(tree);
  }
  /**
   * Calls action for each child of this tree node.
   *
   * @param action - Action to be called for each child.
   */
  function treeForEachChild(tree, action) {
      each(tree.node.children, function (child, childTree) {
          action(new Tree(child, tree, childTree));
      });
  }
  /**
   * Does a depth-first traversal of this node's descendants, calling action for each one.
   *
   * @param action - Action to be called for each child.
   * @param includeSelf - Whether to call action on this node as well. Defaults to
   *   false.
   * @param childrenFirst - Whether to call action on children before calling it on
   *   parent.
   */
  function treeForEachDescendant(tree, action, includeSelf, childrenFirst) {
      if (includeSelf && !childrenFirst) {
          action(tree);
      }
      treeForEachChild(tree, function (child) {
          treeForEachDescendant(child, action, true, childrenFirst);
      });
      if (includeSelf && childrenFirst) {
          action(tree);
      }
  }
  /**
   * Calls action on each ancestor node.
   *
   * @param action - Action to be called on each parent; return
   *   true to abort.
   * @param includeSelf - Whether to call action on this node as well.
   * @returns true if the action callback returned true.
   */
  function treeForEachAncestor(tree, action, includeSelf) {
      var node = includeSelf ? tree : tree.parent;
      while (node !== null) {
          if (action(node)) {
              return true;
          }
          node = node.parent;
      }
      return false;
  }
  /**
   * @returns The path of this tree node, as a Path.
   */
  function treeGetPath(tree) {
      return new Path(tree.parent === null
          ? tree.name
          : treeGetPath(tree.parent) + '/' + tree.name);
  }
  /**
   * Adds or removes this child from its parent based on whether it's empty or not.
   */
  function treeUpdateParents(tree) {
      if (tree.parent !== null) {
          treeUpdateChild(tree.parent, tree.name, tree);
      }
  }
  /**
   * Adds or removes the passed child to this tree node, depending on whether it's empty.
   *
   * @param childName - The name of the child to update.
   * @param child - The child to update.
   */
  function treeUpdateChild(tree, childName, child) {
      var childEmpty = treeIsEmpty(child);
      var childExists = util.contains(tree.node.children, childName);
      if (childEmpty && childExists) {
          delete tree.node.children[childName];
          tree.node.childCount--;
          treeUpdateParents(tree);
      }
      else if (!childEmpty && !childExists) {
          tree.node.children[childName] = child.node;
          tree.node.childCount++;
          treeUpdateParents(tree);
      }
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * True for invalid Firebase keys
   */
  var INVALID_KEY_REGEX_ = /[\[\].#$\/\u0000-\u001F\u007F]/;
  /**
   * True for invalid Firebase paths.
   * Allows '/' in paths.
   */
  var INVALID_PATH_REGEX_ = /[\[\].#$\u0000-\u001F\u007F]/;
  /**
   * Maximum number of characters to allow in leaf value
   */
  var MAX_LEAF_SIZE_ = 10 * 1024 * 1024;
  var isValidKey = function (key) {
      return (typeof key === 'string' && key.length !== 0 && !INVALID_KEY_REGEX_.test(key));
  };
  var isValidPathString = function (pathString) {
      return (typeof pathString === 'string' &&
          pathString.length !== 0 &&
          !INVALID_PATH_REGEX_.test(pathString));
  };
  var isValidRootPathString = function (pathString) {
      if (pathString) {
          // Allow '/.info/' at the beginning.
          pathString = pathString.replace(/^\/*\.info(\/|$)/, '/');
      }
      return isValidPathString(pathString);
  };
  var isValidPriority = function (priority) {
      return (priority === null ||
          typeof priority === 'string' ||
          (typeof priority === 'number' && !isInvalidJSONNumber(priority)) ||
          (priority &&
              typeof priority === 'object' &&
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              util.contains(priority, '.sv')));
  };
  /**
   * Pre-validate a datum passed as an argument to Firebase function.
   */
  var validateFirebaseDataArg = function (fnName, value, path, optional) {
      if (optional && value === undefined) {
          return;
      }
      validateFirebaseData(util.errorPrefix(fnName, 'value'), value, path);
  };
  /**
   * Validate a data object client-side before sending to server.
   */
  var validateFirebaseData = function (errorPrefix, data, path_) {
      var path = path_ instanceof Path ? new ValidationPath(path_, errorPrefix) : path_;
      if (data === undefined) {
          throw new Error(errorPrefix + 'contains undefined ' + validationPathToErrorString(path));
      }
      if (typeof data === 'function') {
          throw new Error(errorPrefix +
              'contains a function ' +
              validationPathToErrorString(path) +
              ' with contents = ' +
              data.toString());
      }
      if (isInvalidJSONNumber(data)) {
          throw new Error(errorPrefix +
              'contains ' +
              data.toString() +
              ' ' +
              validationPathToErrorString(path));
      }
      // Check max leaf size, but try to avoid the utf8 conversion if we can.
      if (typeof data === 'string' &&
          data.length > MAX_LEAF_SIZE_ / 3 &&
          util.stringLength(data) > MAX_LEAF_SIZE_) {
          throw new Error(errorPrefix +
              'contains a string greater than ' +
              MAX_LEAF_SIZE_ +
              ' utf8 bytes ' +
              validationPathToErrorString(path) +
              " ('" +
              data.substring(0, 50) +
              "...')");
      }
      // TODO = Perf = Consider combining the recursive validation of keys into NodeFromJSON
      // to save extra walking of large objects.
      if (data && typeof data === 'object') {
          var hasDotValue_1 = false;
          var hasActualChild_1 = false;
          each(data, function (key, value) {
              if (key === '.value') {
                  hasDotValue_1 = true;
              }
              else if (key !== '.priority' && key !== '.sv') {
                  hasActualChild_1 = true;
                  if (!isValidKey(key)) {
                      throw new Error(errorPrefix +
                          ' contains an invalid key (' +
                          key +
                          ') ' +
                          validationPathToErrorString(path) +
                          '.  Keys must be non-empty strings ' +
                          'and can\'t contain ".", "#", "$", "/", "[", or "]"');
                  }
              }
              validationPathPush(path, key);
              validateFirebaseData(errorPrefix, value, path);
              validationPathPop(path);
          });
          if (hasDotValue_1 && hasActualChild_1) {
              throw new Error(errorPrefix +
                  ' contains ".value" child ' +
                  validationPathToErrorString(path) +
                  ' in addition to actual children.');
          }
      }
  };
  /**
   * Pre-validate paths passed in the firebase function.
   */
  var validateFirebaseMergePaths = function (errorPrefix, mergePaths) {
      var i, curPath;
      for (i = 0; i < mergePaths.length; i++) {
          curPath = mergePaths[i];
          var keys = pathSlice(curPath);
          for (var j = 0; j < keys.length; j++) {
              if (keys[j] === '.priority' && j === keys.length - 1) ;
              else if (!isValidKey(keys[j])) {
                  throw new Error(errorPrefix +
                      'contains an invalid key (' +
                      keys[j] +
                      ') in path ' +
                      curPath.toString() +
                      '. Keys must be non-empty strings ' +
                      'and can\'t contain ".", "#", "$", "/", "[", or "]"');
              }
          }
      }
      // Check that update keys are not descendants of each other.
      // We rely on the property that sorting guarantees that ancestors come
      // right before descendants.
      mergePaths.sort(pathCompare);
      var prevPath = null;
      for (i = 0; i < mergePaths.length; i++) {
          curPath = mergePaths[i];
          if (prevPath !== null && pathContains(prevPath, curPath)) {
              throw new Error(errorPrefix +
                  'contains a path ' +
                  prevPath.toString() +
                  ' that is ancestor of another path ' +
                  curPath.toString());
          }
          prevPath = curPath;
      }
  };
  /**
   * pre-validate an object passed as an argument to firebase function (
   * must be an object - e.g. for firebase.update()).
   */
  var validateFirebaseMergeDataArg = function (fnName, data, path, optional) {
      if (optional && data === undefined) {
          return;
      }
      var errorPrefix = util.errorPrefix(fnName, 'values');
      if (!(data && typeof data === 'object') || Array.isArray(data)) {
          throw new Error(errorPrefix + ' must be an object containing the children to replace.');
      }
      var mergePaths = [];
      each(data, function (key, value) {
          var curPath = new Path(key);
          validateFirebaseData(errorPrefix, value, pathChild(path, curPath));
          if (pathGetBack(curPath) === '.priority') {
              if (!isValidPriority(value)) {
                  throw new Error(errorPrefix +
                      "contains an invalid value for '" +
                      curPath.toString() +
                      "', which must be a valid " +
                      'Firebase priority (a string, finite number, server value, or null).');
              }
          }
          mergePaths.push(curPath);
      });
      validateFirebaseMergePaths(errorPrefix, mergePaths);
  };
  var validatePriority = function (fnName, priority, optional) {
      if (optional && priority === undefined) {
          return;
      }
      if (isInvalidJSONNumber(priority)) {
          throw new Error(util.errorPrefix(fnName, 'priority') +
              'is ' +
              priority.toString() +
              ', but must be a valid Firebase priority (a string, finite number, ' +
              'server value, or null).');
      }
      // Special case to allow importing data with a .sv.
      if (!isValidPriority(priority)) {
          throw new Error(util.errorPrefix(fnName, 'priority') +
              'must be a valid Firebase priority ' +
              '(a string, finite number, server value, or null).');
      }
  };
  var validateKey = function (fnName, argumentName, key, optional) {
      if (optional && key === undefined) {
          return;
      }
      if (!isValidKey(key)) {
          throw new Error(util.errorPrefix(fnName, argumentName) +
              'was an invalid key = "' +
              key +
              '".  Firebase keys must be non-empty strings and ' +
              'can\'t contain ".", "#", "$", "/", "[", or "]").');
      }
  };
  /**
   * @internal
   */
  var validatePathString = function (fnName, argumentName, pathString, optional) {
      if (optional && pathString === undefined) {
          return;
      }
      if (!isValidPathString(pathString)) {
          throw new Error(util.errorPrefix(fnName, argumentName) +
              'was an invalid path = "' +
              pathString +
              '". Paths must be non-empty strings and ' +
              'can\'t contain ".", "#", "$", "[", or "]"');
      }
  };
  var validateRootPathString = function (fnName, argumentName, pathString, optional) {
      if (pathString) {
          // Allow '/.info/' at the beginning.
          pathString = pathString.replace(/^\/*\.info(\/|$)/, '/');
      }
      validatePathString(fnName, argumentName, pathString, optional);
  };
  /**
   * @internal
   */
  var validateWritablePath = function (fnName, path) {
      if (pathGetFront(path) === '.info') {
          throw new Error(fnName + " failed = Can't modify data under /.info/");
      }
  };
  var validateUrl = function (fnName, parsedUrl) {
      // TODO = Validate server better.
      var pathString = parsedUrl.path.toString();
      if (!(typeof parsedUrl.repoInfo.host === 'string') ||
          parsedUrl.repoInfo.host.length === 0 ||
          (!isValidKey(parsedUrl.repoInfo.namespace) &&
              parsedUrl.repoInfo.host.split(':')[0] !== 'localhost') ||
          (pathString.length !== 0 && !isValidRootPathString(pathString))) {
          throw new Error(util.errorPrefix(fnName, 'url') +
              'must be a valid firebase URL and ' +
              'the path can\'t contain ".", "#", "$", "[", or "]".');
      }
  };
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * The event queue serves a few purposes:
   * 1. It ensures we maintain event order in the face of event callbacks doing operations that result in more
   *    events being queued.
   * 2. raiseQueuedEvents() handles being called reentrantly nicely.  That is, if in the course of raising events,
   *    raiseQueuedEvents() is called again, the "inner" call will pick up raising events where the "outer" call
   *    left off, ensuring that the events are still raised synchronously and in order.
   * 3. You can use raiseEventsAtPath and raiseEventsForChangedPath to ensure only relevant previously-queued
   *    events are raised synchronously.
   *
   * NOTE: This can all go away if/when we move to async events.
   *
   */
  var EventQueue = /** @class */ (function () {
      function EventQueue() {
          this.eventLists_ = [];
          /**
           * Tracks recursion depth of raiseQueuedEvents_, for debugging purposes.
           */
          this.recursionDepth_ = 0;
      }
      return EventQueue;
  }());
  /**
   * @param eventDataList - The new events to queue.
   */
  function eventQueueQueueEvents(eventQueue, eventDataList) {
      // We group events by path, storing them in a single EventList, to make it easier to skip over them quickly.
      var currList = null;
      for (var i = 0; i < eventDataList.length; i++) {
          var data = eventDataList[i];
          var path = data.getPath();
          if (currList !== null && !pathEquals(path, currList.path)) {
              eventQueue.eventLists_.push(currList);
              currList = null;
          }
          if (currList === null) {
              currList = { events: [], path: path };
          }
          currList.events.push(data);
      }
      if (currList) {
          eventQueue.eventLists_.push(currList);
      }
  }
  /**
   * Queues the specified events and synchronously raises all events (including previously queued ones)
   * for the specified path.
   *
   * It is assumed that the new events are all for the specified path.
   *
   * @param path - The path to raise events for.
   * @param eventDataList - The new events to raise.
   */
  function eventQueueRaiseEventsAtPath(eventQueue, path, eventDataList) {
      eventQueueQueueEvents(eventQueue, eventDataList);
      eventQueueRaiseQueuedEventsMatchingPredicate(eventQueue, function (eventPath) {
          return pathEquals(eventPath, path);
      });
  }
  /**
   * Queues the specified events and synchronously raises all events (including previously queued ones) for
   * locations related to the specified change path (i.e. all ancestors and descendants).
   *
   * It is assumed that the new events are all related (ancestor or descendant) to the specified path.
   *
   * @param changedPath - The path to raise events for.
   * @param eventDataList - The events to raise
   */
  function eventQueueRaiseEventsForChangedPath(eventQueue, changedPath, eventDataList) {
      eventQueueQueueEvents(eventQueue, eventDataList);
      eventQueueRaiseQueuedEventsMatchingPredicate(eventQueue, function (eventPath) {
          return pathContains(eventPath, changedPath) ||
              pathContains(changedPath, eventPath);
      });
  }
  function eventQueueRaiseQueuedEventsMatchingPredicate(eventQueue, predicate) {
      eventQueue.recursionDepth_++;
      var sentAll = true;
      for (var i = 0; i < eventQueue.eventLists_.length; i++) {
          var eventList = eventQueue.eventLists_[i];
          if (eventList) {
              var eventPath = eventList.path;
              if (predicate(eventPath)) {
                  eventListRaise(eventQueue.eventLists_[i]);
                  eventQueue.eventLists_[i] = null;
              }
              else {
                  sentAll = false;
              }
          }
      }
      if (sentAll) {
          eventQueue.eventLists_ = [];
      }
      eventQueue.recursionDepth_--;
  }
  /**
   * Iterates through the list and raises each event
   */
  function eventListRaise(eventList) {
      for (var i = 0; i < eventList.events.length; i++) {
          var eventData = eventList.events[i];
          if (eventData !== null) {
              eventList.events[i] = null;
              var eventFn = eventData.getEventRunner();
              if (logger) {
                  log('event: ' + eventData.toString());
              }
              exceptionGuard(eventFn);
          }
      }
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var INTERRUPT_REASON = 'repo_interrupt';
  /**
   * If a transaction does not succeed after 25 retries, we abort it. Among other
   * things this ensure that if there's ever a bug causing a mismatch between
   * client / server hashes for some data, we won't retry indefinitely.
   */
  var MAX_TRANSACTION_RETRIES = 25;
  /**
   * A connection to a single data repository.
   */
  var Repo = /** @class */ (function () {
      function Repo(repoInfo_, forceRestClient_, authTokenProvider_, appCheckProvider_) {
          this.repoInfo_ = repoInfo_;
          this.forceRestClient_ = forceRestClient_;
          this.authTokenProvider_ = authTokenProvider_;
          this.appCheckProvider_ = appCheckProvider_;
          this.dataUpdateCount = 0;
          this.statsListener_ = null;
          this.eventQueue_ = new EventQueue();
          this.nextWriteId_ = 1;
          this.interceptServerDataCallback_ = null;
          /** A list of data pieces and paths to be set when this client disconnects. */
          this.onDisconnect_ = newSparseSnapshotTree();
          /** Stores queues of outstanding transactions for Firebase locations. */
          this.transactionQueueTree_ = new Tree();
          // TODO: This should be @private but it's used by test_access.js and internal.js
          this.persistentConnection_ = null;
          // This key is intentionally not updated if RepoInfo is later changed or replaced
          this.key = this.repoInfo_.toURLString();
      }
      /**
       * @returns The URL corresponding to the root of this Firebase.
       */
      Repo.prototype.toString = function () {
          return ((this.repoInfo_.secure ? 'https://' : 'http://') + this.repoInfo_.host);
      };
      return Repo;
  }());
  function repoStart(repo, appId, authOverride) {
      repo.stats_ = statsManagerGetCollection(repo.repoInfo_);
      if (repo.forceRestClient_ || beingCrawled()) {
          repo.server_ = new ReadonlyRestClient(repo.repoInfo_, function (pathString, data, isMerge, tag) {
              repoOnDataUpdate(repo, pathString, data, isMerge, tag);
          }, repo.authTokenProvider_, repo.appCheckProvider_);
          // Minor hack: Fire onConnect immediately, since there's no actual connection.
          setTimeout(function () { return repoOnConnectStatus(repo, /* connectStatus= */ true); }, 0);
      }
      else {
          // Validate authOverride
          if (typeof authOverride !== 'undefined' && authOverride !== null) {
              if (typeof authOverride !== 'object') {
                  throw new Error('Only objects are supported for option databaseAuthVariableOverride');
              }
              try {
                  util.stringify(authOverride);
              }
              catch (e) {
                  throw new Error('Invalid authOverride provided: ' + e);
              }
          }
          repo.persistentConnection_ = new PersistentConnection(repo.repoInfo_, appId, function (pathString, data, isMerge, tag) {
              repoOnDataUpdate(repo, pathString, data, isMerge, tag);
          }, function (connectStatus) {
              repoOnConnectStatus(repo, connectStatus);
          }, function (updates) {
              repoOnServerInfoUpdate(repo, updates);
          }, repo.authTokenProvider_, repo.appCheckProvider_, authOverride);
          repo.server_ = repo.persistentConnection_;
      }
      repo.authTokenProvider_.addTokenChangeListener(function (token) {
          repo.server_.refreshAuthToken(token);
      });
      repo.appCheckProvider_.addTokenChangeListener(function (result) {
          repo.server_.refreshAppCheckToken(result.token);
      });
      // In the case of multiple Repos for the same repoInfo (i.e. there are multiple Firebase.Contexts being used),
      // we only want to create one StatsReporter.  As such, we'll report stats over the first Repo created.
      repo.statsReporter_ = statsManagerGetOrCreateReporter(repo.repoInfo_, function () { return new StatsReporter(repo.stats_, repo.server_); });
      // Used for .info.
      repo.infoData_ = new SnapshotHolder();
      repo.infoSyncTree_ = new SyncTree({
          startListening: function (query, tag, currentHashFn, onComplete) {
              var infoEvents = [];
              var node = repo.infoData_.getNode(query._path);
              // This is possibly a hack, but we have different semantics for .info endpoints. We don't raise null events
              // on initial data...
              if (!node.isEmpty()) {
                  infoEvents = syncTreeApplyServerOverwrite(repo.infoSyncTree_, query._path, node);
                  setTimeout(function () {
                      onComplete('ok');
                  }, 0);
              }
              return infoEvents;
          },
          stopListening: function () { }
      });
      repoUpdateInfo(repo, 'connected', false);
      repo.serverSyncTree_ = new SyncTree({
          startListening: function (query, tag, currentHashFn, onComplete) {
              repo.server_.listen(query, currentHashFn, tag, function (status, data) {
                  var events = onComplete(status, data);
                  eventQueueRaiseEventsForChangedPath(repo.eventQueue_, query._path, events);
              });
              // No synchronous events for network-backed sync trees
              return [];
          },
          stopListening: function (query, tag) {
              repo.server_.unlisten(query, tag);
          }
      });
  }
  /**
   * @returns The time in milliseconds, taking the server offset into account if we have one.
   */
  function repoServerTime(repo) {
      var offsetNode = repo.infoData_.getNode(new Path('.info/serverTimeOffset'));
      var offset = offsetNode.val() || 0;
      return new Date().getTime() + offset;
  }
  /**
   * Generate ServerValues using some variables from the repo object.
   */
  function repoGenerateServerValues(repo) {
      return generateWithValues({
          timestamp: repoServerTime(repo)
      });
  }
  /**
   * Called by realtime when we get new messages from the server.
   */
  function repoOnDataUpdate(repo, pathString, data, isMerge, tag) {
      // For testing.
      repo.dataUpdateCount++;
      var path = new Path(pathString);
      data = repo.interceptServerDataCallback_
          ? repo.interceptServerDataCallback_(pathString, data)
          : data;
      var events = [];
      if (tag) {
          if (isMerge) {
              var taggedChildren = util.map(data, function (raw) { return nodeFromJSON(raw); });
              events = syncTreeApplyTaggedQueryMerge(repo.serverSyncTree_, path, taggedChildren, tag);
          }
          else {
              var taggedSnap = nodeFromJSON(data);
              events = syncTreeApplyTaggedQueryOverwrite(repo.serverSyncTree_, path, taggedSnap, tag);
          }
      }
      else if (isMerge) {
          var changedChildren = util.map(data, function (raw) { return nodeFromJSON(raw); });
          events = syncTreeApplyServerMerge(repo.serverSyncTree_, path, changedChildren);
      }
      else {
          var snap = nodeFromJSON(data);
          events = syncTreeApplyServerOverwrite(repo.serverSyncTree_, path, snap);
      }
      var affectedPath = path;
      if (events.length > 0) {
          // Since we have a listener outstanding for each transaction, receiving any events
          // is a proxy for some change having occurred.
          affectedPath = repoRerunTransactions(repo, path);
      }
      eventQueueRaiseEventsForChangedPath(repo.eventQueue_, affectedPath, events);
  }
  function repoOnConnectStatus(repo, connectStatus) {
      repoUpdateInfo(repo, 'connected', connectStatus);
      if (connectStatus === false) {
          repoRunOnDisconnectEvents(repo);
      }
  }
  function repoOnServerInfoUpdate(repo, updates) {
      each(updates, function (key, value) {
          repoUpdateInfo(repo, key, value);
      });
  }
  function repoUpdateInfo(repo, pathString, value) {
      var path = new Path('/.info/' + pathString);
      var newNode = nodeFromJSON(value);
      repo.infoData_.updateSnapshot(path, newNode);
      var events = syncTreeApplyServerOverwrite(repo.infoSyncTree_, path, newNode);
      eventQueueRaiseEventsForChangedPath(repo.eventQueue_, path, events);
  }
  function repoGetNextWriteId(repo) {
      return repo.nextWriteId_++;
  }
  /**
   * The purpose of `getValue` is to return the latest known value
   * satisfying `query`.
   *
   * This method will first check for in-memory cached values
   * belonging to active listeners. If they are found, such values
   * are considered to be the most up-to-date.
   *
   * If the client is not connected, this method will try to
   * establish a connection and request the value for `query`. If
   * the client is not able to retrieve the query result, it reports
   * an error.
   *
   * @param query - The query to surface a value for.
   */
  function repoGetValue(repo, query) {
      // Only active queries are cached. There is no persisted cache.
      var cached = syncTreeGetServerValue(repo.serverSyncTree_, query);
      if (cached != null) {
          return Promise.resolve(cached);
      }
      return repo.server_.get(query).then(function (payload) {
          var node = nodeFromJSON(payload).withIndex(query._queryParams.getIndex());
          var events = syncTreeApplyServerOverwrite(repo.serverSyncTree_, query._path, node);
          eventQueueRaiseEventsAtPath(repo.eventQueue_, query._path, events);
          return Promise.resolve(node);
      }, function (err) {
          repoLog(repo, 'get for query ' + util.stringify(query) + ' failed: ' + err);
          return Promise.reject(new Error(err));
      });
  }
  function repoSetWithPriority(repo, path, newVal, newPriority, onComplete) {
      repoLog(repo, 'set', {
          path: path.toString(),
          value: newVal,
          priority: newPriority
      });
      // TODO: Optimize this behavior to either (a) store flag to skip resolving where possible and / or
      // (b) store unresolved paths on JSON parse
      var serverValues = repoGenerateServerValues(repo);
      var newNodeUnresolved = nodeFromJSON(newVal, newPriority);
      var existing = syncTreeCalcCompleteEventCache(repo.serverSyncTree_, path);
      var newNode = resolveDeferredValueSnapshot(newNodeUnresolved, existing, serverValues);
      var writeId = repoGetNextWriteId(repo);
      var events = syncTreeApplyUserOverwrite(repo.serverSyncTree_, path, newNode, writeId, true);
      eventQueueQueueEvents(repo.eventQueue_, events);
      repo.server_.put(path.toString(), newNodeUnresolved.val(/*export=*/ true), function (status, errorReason) {
          var success = status === 'ok';
          if (!success) {
              warn('set at ' + path + ' failed: ' + status);
          }
          var clearEvents = syncTreeAckUserWrite(repo.serverSyncTree_, writeId, !success);
          eventQueueRaiseEventsForChangedPath(repo.eventQueue_, path, clearEvents);
          repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
      });
      var affectedPath = repoAbortTransactions(repo, path);
      repoRerunTransactions(repo, affectedPath);
      // We queued the events above, so just flush the queue here
      eventQueueRaiseEventsForChangedPath(repo.eventQueue_, affectedPath, []);
  }
  function repoUpdate(repo, path, childrenToMerge, onComplete) {
      repoLog(repo, 'update', { path: path.toString(), value: childrenToMerge });
      // Start with our existing data and merge each child into it.
      var empty = true;
      var serverValues = repoGenerateServerValues(repo);
      var changedChildren = {};
      each(childrenToMerge, function (changedKey, changedValue) {
          empty = false;
          changedChildren[changedKey] = resolveDeferredValueTree(pathChild(path, changedKey), nodeFromJSON(changedValue), repo.serverSyncTree_, serverValues);
      });
      if (!empty) {
          var writeId_1 = repoGetNextWriteId(repo);
          var events = syncTreeApplyUserMerge(repo.serverSyncTree_, path, changedChildren, writeId_1);
          eventQueueQueueEvents(repo.eventQueue_, events);
          repo.server_.merge(path.toString(), childrenToMerge, function (status, errorReason) {
              var success = status === 'ok';
              if (!success) {
                  warn('update at ' + path + ' failed: ' + status);
              }
              var clearEvents = syncTreeAckUserWrite(repo.serverSyncTree_, writeId_1, !success);
              var affectedPath = clearEvents.length > 0 ? repoRerunTransactions(repo, path) : path;
              eventQueueRaiseEventsForChangedPath(repo.eventQueue_, affectedPath, clearEvents);
              repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
          });
          each(childrenToMerge, function (changedPath) {
              var affectedPath = repoAbortTransactions(repo, pathChild(path, changedPath));
              repoRerunTransactions(repo, affectedPath);
          });
          // We queued the events above, so just flush the queue here
          eventQueueRaiseEventsForChangedPath(repo.eventQueue_, path, []);
      }
      else {
          log("update() called with empty data.  Don't do anything.");
          repoCallOnCompleteCallback(repo, onComplete, 'ok', undefined);
      }
  }
  /**
   * Applies all of the changes stored up in the onDisconnect_ tree.
   */
  function repoRunOnDisconnectEvents(repo) {
      repoLog(repo, 'onDisconnectEvents');
      var serverValues = repoGenerateServerValues(repo);
      var resolvedOnDisconnectTree = newSparseSnapshotTree();
      sparseSnapshotTreeForEachTree(repo.onDisconnect_, newEmptyPath(), function (path, node) {
          var resolved = resolveDeferredValueTree(path, node, repo.serverSyncTree_, serverValues);
          sparseSnapshotTreeRemember(resolvedOnDisconnectTree, path, resolved);
      });
      var events = [];
      sparseSnapshotTreeForEachTree(resolvedOnDisconnectTree, newEmptyPath(), function (path, snap) {
          events = events.concat(syncTreeApplyServerOverwrite(repo.serverSyncTree_, path, snap));
          var affectedPath = repoAbortTransactions(repo, path);
          repoRerunTransactions(repo, affectedPath);
      });
      repo.onDisconnect_ = newSparseSnapshotTree();
      eventQueueRaiseEventsForChangedPath(repo.eventQueue_, newEmptyPath(), events);
  }
  function repoOnDisconnectCancel(repo, path, onComplete) {
      repo.server_.onDisconnectCancel(path.toString(), function (status, errorReason) {
          if (status === 'ok') {
              sparseSnapshotTreeForget(repo.onDisconnect_, path);
          }
          repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
      });
  }
  function repoOnDisconnectSet(repo, path, value, onComplete) {
      var newNode = nodeFromJSON(value);
      repo.server_.onDisconnectPut(path.toString(), newNode.val(/*export=*/ true), function (status, errorReason) {
          if (status === 'ok') {
              sparseSnapshotTreeRemember(repo.onDisconnect_, path, newNode);
          }
          repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
      });
  }
  function repoOnDisconnectSetWithPriority(repo, path, value, priority, onComplete) {
      var newNode = nodeFromJSON(value, priority);
      repo.server_.onDisconnectPut(path.toString(), newNode.val(/*export=*/ true), function (status, errorReason) {
          if (status === 'ok') {
              sparseSnapshotTreeRemember(repo.onDisconnect_, path, newNode);
          }
          repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
      });
  }
  function repoOnDisconnectUpdate(repo, path, childrenToMerge, onComplete) {
      if (util.isEmpty(childrenToMerge)) {
          log("onDisconnect().update() called with empty data.  Don't do anything.");
          repoCallOnCompleteCallback(repo, onComplete, 'ok', undefined);
          return;
      }
      repo.server_.onDisconnectMerge(path.toString(), childrenToMerge, function (status, errorReason) {
          if (status === 'ok') {
              each(childrenToMerge, function (childName, childNode) {
                  var newChildNode = nodeFromJSON(childNode);
                  sparseSnapshotTreeRemember(repo.onDisconnect_, pathChild(path, childName), newChildNode);
              });
          }
          repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
      });
  }
  function repoAddEventCallbackForQuery(repo, query, eventRegistration) {
      var events;
      if (pathGetFront(query._path) === '.info') {
          events = syncTreeAddEventRegistration(repo.infoSyncTree_, query, eventRegistration);
      }
      else {
          events = syncTreeAddEventRegistration(repo.serverSyncTree_, query, eventRegistration);
      }
      eventQueueRaiseEventsAtPath(repo.eventQueue_, query._path, events);
  }
  function repoRemoveEventCallbackForQuery(repo, query, eventRegistration) {
      // These are guaranteed not to raise events, since we're not passing in a cancelError. However, we can future-proof
      // a little bit by handling the return values anyways.
      var events;
      if (pathGetFront(query._path) === '.info') {
          events = syncTreeRemoveEventRegistration(repo.infoSyncTree_, query, eventRegistration);
      }
      else {
          events = syncTreeRemoveEventRegistration(repo.serverSyncTree_, query, eventRegistration);
      }
      eventQueueRaiseEventsAtPath(repo.eventQueue_, query._path, events);
  }
  function repoInterrupt(repo) {
      if (repo.persistentConnection_) {
          repo.persistentConnection_.interrupt(INTERRUPT_REASON);
      }
  }
  function repoResume(repo) {
      if (repo.persistentConnection_) {
          repo.persistentConnection_.resume(INTERRUPT_REASON);
      }
  }
  function repoLog(repo) {
      var varArgs = [];
      for (var _i = 1; _i < arguments.length; _i++) {
          varArgs[_i - 1] = arguments[_i];
      }
      var prefix = '';
      if (repo.persistentConnection_) {
          prefix = repo.persistentConnection_.id + ':';
      }
      log.apply(void 0, tslib.__spreadArray([prefix], tslib.__read(varArgs)));
  }
  function repoCallOnCompleteCallback(repo, callback, status, errorReason) {
      if (callback) {
          exceptionGuard(function () {
              if (status === 'ok') {
                  callback(null);
              }
              else {
                  var code = (status || 'error').toUpperCase();
                  var message = code;
                  if (errorReason) {
                      message += ': ' + errorReason;
                  }
                  var error = new Error(message);
                  // eslint-disable-next-line @typescript-eslint/no-explicit-any
                  error.code = code;
                  callback(error);
              }
          });
      }
  }
  /**
   * Creates a new transaction, adds it to the transactions we're tracking, and
   * sends it to the server if possible.
   *
   * @param path - Path at which to do transaction.
   * @param transactionUpdate - Update callback.
   * @param onComplete - Completion callback.
   * @param unwatcher - Function that will be called when the transaction no longer
   * need data updates for `path`.
   * @param applyLocally - Whether or not to make intermediate results visible
   */
  function repoStartTransaction(repo, path, transactionUpdate, onComplete, unwatcher, applyLocally) {
      repoLog(repo, 'transaction on ' + path);
      // Initialize transaction.
      var transaction = {
          path: path,
          update: transactionUpdate,
          onComplete: onComplete,
          // One of TransactionStatus enums.
          status: null,
          // Used when combining transactions at different locations to figure out
          // which one goes first.
          order: LUIDGenerator(),
          // Whether to raise local events for this transaction.
          applyLocally: applyLocally,
          // Count of how many times we've retried the transaction.
          retryCount: 0,
          // Function to call to clean up our .on() listener.
          unwatcher: unwatcher,
          // Stores why a transaction was aborted.
          abortReason: null,
          currentWriteId: null,
          currentInputSnapshot: null,
          currentOutputSnapshotRaw: null,
          currentOutputSnapshotResolved: null
      };
      // Run transaction initially.
      var currentState = repoGetLatestState(repo, path, undefined);
      transaction.currentInputSnapshot = currentState;
      var newVal = transaction.update(currentState.val());
      if (newVal === undefined) {
          // Abort transaction.
          transaction.unwatcher();
          transaction.currentOutputSnapshotRaw = null;
          transaction.currentOutputSnapshotResolved = null;
          if (transaction.onComplete) {
              transaction.onComplete(null, false, transaction.currentInputSnapshot);
          }
      }
      else {
          validateFirebaseData('transaction failed: Data returned ', newVal, transaction.path);
          // Mark as run and add to our queue.
          transaction.status = 0 /* RUN */;
          var queueNode = treeSubTree(repo.transactionQueueTree_, path);
          var nodeQueue = treeGetValue(queueNode) || [];
          nodeQueue.push(transaction);
          treeSetValue(queueNode, nodeQueue);
          // Update visibleData and raise events
          // Note: We intentionally raise events after updating all of our
          // transaction state, since the user could start new transactions from the
          // event callbacks.
          var priorityForNode = void 0;
          if (typeof newVal === 'object' &&
              newVal !== null &&
              util.contains(newVal, '.priority')) {
              // eslint-disable-next-line @typescript-eslint/no-explicit-any
              priorityForNode = util.safeGet(newVal, '.priority');
              util.assert(isValidPriority(priorityForNode), 'Invalid priority returned by transaction. ' +
                  'Priority must be a valid string, finite number, server value, or null.');
          }
          else {
              var currentNode = syncTreeCalcCompleteEventCache(repo.serverSyncTree_, path) ||
                  ChildrenNode.EMPTY_NODE;
              priorityForNode = currentNode.getPriority().val();
          }
          var serverValues = repoGenerateServerValues(repo);
          var newNodeUnresolved = nodeFromJSON(newVal, priorityForNode);
          var newNode = resolveDeferredValueSnapshot(newNodeUnresolved, currentState, serverValues);
          transaction.currentOutputSnapshotRaw = newNodeUnresolved;
          transaction.currentOutputSnapshotResolved = newNode;
          transaction.currentWriteId = repoGetNextWriteId(repo);
          var events = syncTreeApplyUserOverwrite(repo.serverSyncTree_, path, newNode, transaction.currentWriteId, transaction.applyLocally);
          eventQueueRaiseEventsForChangedPath(repo.eventQueue_, path, events);
          repoSendReadyTransactions(repo, repo.transactionQueueTree_);
      }
  }
  /**
   * @param excludeSets - A specific set to exclude
   */
  function repoGetLatestState(repo, path, excludeSets) {
      return (syncTreeCalcCompleteEventCache(repo.serverSyncTree_, path, excludeSets) ||
          ChildrenNode.EMPTY_NODE);
  }
  /**
   * Sends any already-run transactions that aren't waiting for outstanding
   * transactions to complete.
   *
   * Externally it's called with no arguments, but it calls itself recursively
   * with a particular transactionQueueTree node to recurse through the tree.
   *
   * @param node - transactionQueueTree node to start at.
   */
  function repoSendReadyTransactions(repo, node) {
      if (node === void 0) { node = repo.transactionQueueTree_; }
      // Before recursing, make sure any completed transactions are removed.
      if (!node) {
          repoPruneCompletedTransactionsBelowNode(repo, node);
      }
      if (treeGetValue(node)) {
          var queue = repoBuildTransactionQueue(repo, node);
          util.assert(queue.length > 0, 'Sending zero length transaction queue');
          var allRun = queue.every(function (transaction) { return transaction.status === 0 /* RUN */; });
          // If they're all run (and not sent), we can send them.  Else, we must wait.
          if (allRun) {
              repoSendTransactionQueue(repo, treeGetPath(node), queue);
          }
      }
      else if (treeHasChildren(node)) {
          treeForEachChild(node, function (childNode) {
              repoSendReadyTransactions(repo, childNode);
          });
      }
  }
  /**
   * Given a list of run transactions, send them to the server and then handle
   * the result (success or failure).
   *
   * @param path - The location of the queue.
   * @param queue - Queue of transactions under the specified location.
   */
  function repoSendTransactionQueue(repo, path, queue) {
      // Mark transactions as sent and increment retry count!
      var setsToIgnore = queue.map(function (txn) {
          return txn.currentWriteId;
      });
      var latestState = repoGetLatestState(repo, path, setsToIgnore);
      var snapToSend = latestState;
      var latestHash = latestState.hash();
      for (var i = 0; i < queue.length; i++) {
          var txn = queue[i];
          util.assert(txn.status === 0 /* RUN */, 'tryToSendTransactionQueue_: items in queue should all be run.');
          txn.status = 1 /* SENT */;
          txn.retryCount++;
          var relativePath = newRelativePath(path, txn.path);
          // If we've gotten to this point, the output snapshot must be defined.
          snapToSend = snapToSend.updateChild(relativePath /** @type {!Node} */, txn.currentOutputSnapshotRaw);
      }
      var dataToSend = snapToSend.val(true);
      var pathToSend = path;
      // Send the put.
      repo.server_.put(pathToSend.toString(), dataToSend, function (status) {
          repoLog(repo, 'transaction put response', {
              path: pathToSend.toString(),
              status: status
          });
          var events = [];
          if (status === 'ok') {
              // Queue up the callbacks and fire them after cleaning up all of our
              // transaction state, since the callback could trigger more
              // transactions or sets.
              var callbacks = [];
              var _loop_1 = function (i) {
                  queue[i].status = 2 /* COMPLETED */;
                  events = events.concat(syncTreeAckUserWrite(repo.serverSyncTree_, queue[i].currentWriteId));
                  if (queue[i].onComplete) {
                      // We never unset the output snapshot, and given that this
                      // transaction is complete, it should be set
                      callbacks.push(function () {
                          return queue[i].onComplete(null, true, queue[i].currentOutputSnapshotResolved);
                      });
                  }
                  queue[i].unwatcher();
              };
              for (var i = 0; i < queue.length; i++) {
                  _loop_1(i);
              }
              // Now remove the completed transactions.
              repoPruneCompletedTransactionsBelowNode(repo, treeSubTree(repo.transactionQueueTree_, path));
              // There may be pending transactions that we can now send.
              repoSendReadyTransactions(repo, repo.transactionQueueTree_);
              eventQueueRaiseEventsForChangedPath(repo.eventQueue_, path, events);
              // Finally, trigger onComplete callbacks.
              for (var i = 0; i < callbacks.length; i++) {
                  exceptionGuard(callbacks[i]);
              }
          }
          else {
              // transactions are no longer sent.  Update their status appropriately.
              if (status === 'datastale') {
                  for (var i = 0; i < queue.length; i++) {
                      if (queue[i].status === 3 /* SENT_NEEDS_ABORT */) {
                          queue[i].status = 4 /* NEEDS_ABORT */;
                      }
                      else {
                          queue[i].status = 0 /* RUN */;
                      }
                  }
              }
              else {
                  warn('transaction at ' + pathToSend.toString() + ' failed: ' + status);
                  for (var i = 0; i < queue.length; i++) {
                      queue[i].status = 4 /* NEEDS_ABORT */;
                      queue[i].abortReason = status;
                  }
              }
              repoRerunTransactions(repo, path);
          }
      }, latestHash);
  }
  /**
   * Finds all transactions dependent on the data at changedPath and reruns them.
   *
   * Should be called any time cached data changes.
   *
   * Return the highest path that was affected by rerunning transactions. This
   * is the path at which events need to be raised for.
   *
   * @param changedPath - The path in mergedData that changed.
   * @returns The rootmost path that was affected by rerunning transactions.
   */
  function repoRerunTransactions(repo, changedPath) {
      var rootMostTransactionNode = repoGetAncestorTransactionNode(repo, changedPath);
      var path = treeGetPath(rootMostTransactionNode);
      var queue = repoBuildTransactionQueue(repo, rootMostTransactionNode);
      repoRerunTransactionQueue(repo, queue, path);
      return path;
  }
  /**
   * Does all the work of rerunning transactions (as well as cleans up aborted
   * transactions and whatnot).
   *
   * @param queue - The queue of transactions to run.
   * @param path - The path the queue is for.
   */
  function repoRerunTransactionQueue(repo, queue, path) {
      if (queue.length === 0) {
          return; // Nothing to do!
      }
      // Queue up the callbacks and fire them after cleaning up all of our
      // transaction state, since the callback could trigger more transactions or
      // sets.
      var callbacks = [];
      var events = [];
      // Ignore all of the sets we're going to re-run.
      var txnsToRerun = queue.filter(function (q) {
          return q.status === 0 /* RUN */;
      });
      var setsToIgnore = txnsToRerun.map(function (q) {
          return q.currentWriteId;
      });
      var _loop_2 = function (i) {
          var transaction = queue[i];
          var relativePath = newRelativePath(path, transaction.path);
          var abortTransaction = false, abortReason;
          util.assert(relativePath !== null, 'rerunTransactionsUnderNode_: relativePath should not be null.');
          if (transaction.status === 4 /* NEEDS_ABORT */) {
              abortTransaction = true;
              abortReason = transaction.abortReason;
              events = events.concat(syncTreeAckUserWrite(repo.serverSyncTree_, transaction.currentWriteId, true));
          }
          else if (transaction.status === 0 /* RUN */) {
              if (transaction.retryCount >= MAX_TRANSACTION_RETRIES) {
                  abortTransaction = true;
                  abortReason = 'maxretry';
                  events = events.concat(syncTreeAckUserWrite(repo.serverSyncTree_, transaction.currentWriteId, true));
              }
              else {
                  // This code reruns a transaction
                  var currentNode = repoGetLatestState(repo, transaction.path, setsToIgnore);
                  transaction.currentInputSnapshot = currentNode;
                  var newData = queue[i].update(currentNode.val());
                  if (newData !== undefined) {
                      validateFirebaseData('transaction failed: Data returned ', newData, transaction.path);
                      var newDataNode = nodeFromJSON(newData);
                      var hasExplicitPriority = typeof newData === 'object' &&
                          newData != null &&
                          util.contains(newData, '.priority');
                      if (!hasExplicitPriority) {
                          // Keep the old priority if there wasn't a priority explicitly specified.
                          newDataNode = newDataNode.updatePriority(currentNode.getPriority());
                      }
                      var oldWriteId = transaction.currentWriteId;
                      var serverValues = repoGenerateServerValues(repo);
                      var newNodeResolved = resolveDeferredValueSnapshot(newDataNode, currentNode, serverValues);
                      transaction.currentOutputSnapshotRaw = newDataNode;
                      transaction.currentOutputSnapshotResolved = newNodeResolved;
                      transaction.currentWriteId = repoGetNextWriteId(repo);
                      // Mutates setsToIgnore in place
                      setsToIgnore.splice(setsToIgnore.indexOf(oldWriteId), 1);
                      events = events.concat(syncTreeApplyUserOverwrite(repo.serverSyncTree_, transaction.path, newNodeResolved, transaction.currentWriteId, transaction.applyLocally));
                      events = events.concat(syncTreeAckUserWrite(repo.serverSyncTree_, oldWriteId, true));
                  }
                  else {
                      abortTransaction = true;
                      abortReason = 'nodata';
                      events = events.concat(syncTreeAckUserWrite(repo.serverSyncTree_, transaction.currentWriteId, true));
                  }
              }
          }
          eventQueueRaiseEventsForChangedPath(repo.eventQueue_, path, events);
          events = [];
          if (abortTransaction) {
              // Abort.
              queue[i].status = 2 /* COMPLETED */;
              // Removing a listener can trigger pruning which can muck with
              // mergedData/visibleData (as it prunes data). So defer the unwatcher
              // until we're done.
              (function (unwatcher) {
                  setTimeout(unwatcher, Math.floor(0));
              })(queue[i].unwatcher);
              if (queue[i].onComplete) {
                  if (abortReason === 'nodata') {
                      callbacks.push(function () {
                          return queue[i].onComplete(null, false, queue[i].currentInputSnapshot);
                      });
                  }
                  else {
                      callbacks.push(function () {
                          return queue[i].onComplete(new Error(abortReason), false, null);
                      });
                  }
              }
          }
      };
      for (var i = 0; i < queue.length; i++) {
          _loop_2(i);
      }
      // Clean up completed transactions.
      repoPruneCompletedTransactionsBelowNode(repo, repo.transactionQueueTree_);
      // Now fire callbacks, now that we're in a good, known state.
      for (var i = 0; i < callbacks.length; i++) {
          exceptionGuard(callbacks[i]);
      }
      // Try to send the transaction result to the server.
      repoSendReadyTransactions(repo, repo.transactionQueueTree_);
  }
  /**
   * Returns the rootmost ancestor node of the specified path that has a pending
   * transaction on it, or just returns the node for the given path if there are
   * no pending transactions on any ancestor.
   *
   * @param path - The location to start at.
   * @returns The rootmost node with a transaction.
   */
  function repoGetAncestorTransactionNode(repo, path) {
      var front;
      // Start at the root and walk deeper into the tree towards path until we
      // find a node with pending transactions.
      var transactionNode = repo.transactionQueueTree_;
      front = pathGetFront(path);
      while (front !== null && treeGetValue(transactionNode) === undefined) {
          transactionNode = treeSubTree(transactionNode, front);
          path = pathPopFront(path);
          front = pathGetFront(path);
      }
      return transactionNode;
  }
  /**
   * Builds the queue of all transactions at or below the specified
   * transactionNode.
   *
   * @param transactionNode
   * @returns The generated queue.
   */
  function repoBuildTransactionQueue(repo, transactionNode) {
      // Walk any child transaction queues and aggregate them into a single queue.
      var transactionQueue = [];
      repoAggregateTransactionQueuesForNode(repo, transactionNode, transactionQueue);
      // Sort them by the order the transactions were created.
      transactionQueue.sort(function (a, b) { return a.order - b.order; });
      return transactionQueue;
  }
  function repoAggregateTransactionQueuesForNode(repo, node, queue) {
      var nodeQueue = treeGetValue(node);
      if (nodeQueue) {
          for (var i = 0; i < nodeQueue.length; i++) {
              queue.push(nodeQueue[i]);
          }
      }
      treeForEachChild(node, function (child) {
          repoAggregateTransactionQueuesForNode(repo, child, queue);
      });
  }
  /**
   * Remove COMPLETED transactions at or below this node in the transactionQueueTree_.
   */
  function repoPruneCompletedTransactionsBelowNode(repo, node) {
      var queue = treeGetValue(node);
      if (queue) {
          var to = 0;
          for (var from = 0; from < queue.length; from++) {
              if (queue[from].status !== 2 /* COMPLETED */) {
                  queue[to] = queue[from];
                  to++;
              }
          }
          queue.length = to;
          treeSetValue(node, queue.length > 0 ? queue : undefined);
      }
      treeForEachChild(node, function (childNode) {
          repoPruneCompletedTransactionsBelowNode(repo, childNode);
      });
  }
  /**
   * Aborts all transactions on ancestors or descendants of the specified path.
   * Called when doing a set() or update() since we consider them incompatible
   * with transactions.
   *
   * @param path - Path for which we want to abort related transactions.
   */
  function repoAbortTransactions(repo, path) {
      var affectedPath = treeGetPath(repoGetAncestorTransactionNode(repo, path));
      var transactionNode = treeSubTree(repo.transactionQueueTree_, path);
      treeForEachAncestor(transactionNode, function (node) {
          repoAbortTransactionsOnNode(repo, node);
      });
      repoAbortTransactionsOnNode(repo, transactionNode);
      treeForEachDescendant(transactionNode, function (node) {
          repoAbortTransactionsOnNode(repo, node);
      });
      return affectedPath;
  }
  /**
   * Abort transactions stored in this transaction queue node.
   *
   * @param node - Node to abort transactions for.
   */
  function repoAbortTransactionsOnNode(repo, node) {
      var queue = treeGetValue(node);
      if (queue) {
          // Queue up the callbacks and fire them after cleaning up all of our
          // transaction state, since the callback could trigger more transactions
          // or sets.
          var callbacks = [];
          // Go through queue.  Any already-sent transactions must be marked for
          // abort, while the unsent ones can be immediately aborted and removed.
          var events = [];
          var lastSent = -1;
          for (var i = 0; i < queue.length; i++) {
              if (queue[i].status === 3 /* SENT_NEEDS_ABORT */) ;
              else if (queue[i].status === 1 /* SENT */) {
                  util.assert(lastSent === i - 1, 'All SENT items should be at beginning of queue.');
                  lastSent = i;
                  // Mark transaction for abort when it comes back.
                  queue[i].status = 3 /* SENT_NEEDS_ABORT */;
                  queue[i].abortReason = 'set';
              }
              else {
                  util.assert(queue[i].status === 0 /* RUN */, 'Unexpected transaction status in abort');
                  // We can abort it immediately.
                  queue[i].unwatcher();
                  events = events.concat(syncTreeAckUserWrite(repo.serverSyncTree_, queue[i].currentWriteId, true));
                  if (queue[i].onComplete) {
                      callbacks.push(queue[i].onComplete.bind(null, new Error('set'), false, null));
                  }
              }
          }
          if (lastSent === -1) {
              // We're not waiting for any sent transactions.  We can clear the queue.
              treeSetValue(node, undefined);
          }
          else {
              // Remove the transactions we aborted.
              queue.length = lastSent + 1;
          }
          // Now fire the callbacks.
          eventQueueRaiseEventsForChangedPath(repo.eventQueue_, treeGetPath(node), events);
          for (var i = 0; i < callbacks.length; i++) {
              exceptionGuard(callbacks[i]);
          }
      }
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function decodePath(pathString) {
      var pathStringDecoded = '';
      var pieces = pathString.split('/');
      for (var i = 0; i < pieces.length; i++) {
          if (pieces[i].length > 0) {
              var piece = pieces[i];
              try {
                  piece = decodeURIComponent(piece.replace(/\+/g, ' '));
              }
              catch (e) { }
              pathStringDecoded += '/' + piece;
          }
      }
      return pathStringDecoded;
  }
  /**
   * @returns key value hash
   */
  function decodeQuery(queryString) {
      var e_1, _a;
      var results = {};
      if (queryString.charAt(0) === '?') {
          queryString = queryString.substring(1);
      }
      try {
          for (var _b = tslib.__values(queryString.split('&')), _c = _b.next(); !_c.done; _c = _b.next()) {
              var segment = _c.value;
              if (segment.length === 0) {
                  continue;
              }
              var kv = segment.split('=');
              if (kv.length === 2) {
                  results[decodeURIComponent(kv[0])] = decodeURIComponent(kv[1]);
              }
              else {
                  warn("Invalid query segment '" + segment + "' in query '" + queryString + "'");
              }
          }
      }
      catch (e_1_1) { e_1 = { error: e_1_1 }; }
      finally {
          try {
              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
          }
          finally { if (e_1) throw e_1.error; }
      }
      return results;
  }
  var parseRepoInfo = function (dataURL, nodeAdmin) {
      var parsedUrl = parseDatabaseURL(dataURL), namespace = parsedUrl.namespace;
      if (parsedUrl.domain === 'firebase.com') {
          fatal(parsedUrl.host +
              ' is no longer supported. ' +
              'Please use <YOUR FIREBASE>.firebaseio.com instead');
      }
      // Catch common error of uninitialized namespace value.
      if ((!namespace || namespace === 'undefined') &&
          parsedUrl.domain !== 'localhost') {
          fatal('Cannot parse Firebase url. Please use https://<YOUR FIREBASE>.firebaseio.com');
      }
      if (!parsedUrl.secure) {
          warnIfPageIsSecure();
      }
      var webSocketOnly = parsedUrl.scheme === 'ws' || parsedUrl.scheme === 'wss';
      return {
          repoInfo: new RepoInfo(parsedUrl.host, parsedUrl.secure, namespace, webSocketOnly, nodeAdmin, 
          /*persistenceKey=*/ '', 
          /*includeNamespaceInQueryParams=*/ namespace !== parsedUrl.subdomain),
          path: new Path(parsedUrl.pathString)
      };
  };
  var parseDatabaseURL = function (dataURL) {
      // Default to empty strings in the event of a malformed string.
      var host = '', domain = '', subdomain = '', pathString = '', namespace = '';
      // Always default to SSL, unless otherwise specified.
      var secure = true, scheme = 'https', port = 443;
      // Don't do any validation here. The caller is responsible for validating the result of parsing.
      if (typeof dataURL === 'string') {
          // Parse scheme.
          var colonInd = dataURL.indexOf('//');
          if (colonInd >= 0) {
              scheme = dataURL.substring(0, colonInd - 1);
              dataURL = dataURL.substring(colonInd + 2);
          }
          // Parse host, path, and query string.
          var slashInd = dataURL.indexOf('/');
          if (slashInd === -1) {
              slashInd = dataURL.length;
          }
          var questionMarkInd = dataURL.indexOf('?');
          if (questionMarkInd === -1) {
              questionMarkInd = dataURL.length;
          }
          host = dataURL.substring(0, Math.min(slashInd, questionMarkInd));
          if (slashInd < questionMarkInd) {
              // For pathString, questionMarkInd will always come after slashInd
              pathString = decodePath(dataURL.substring(slashInd, questionMarkInd));
          }
          var queryParams = decodeQuery(dataURL.substring(Math.min(dataURL.length, questionMarkInd)));
          // If we have a port, use scheme for determining if it's secure.
          colonInd = host.indexOf(':');
          if (colonInd >= 0) {
              secure = scheme === 'https' || scheme === 'wss';
              port = parseInt(host.substring(colonInd + 1), 10);
          }
          else {
              colonInd = host.length;
          }
          var hostWithoutPort = host.slice(0, colonInd);
          if (hostWithoutPort.toLowerCase() === 'localhost') {
              domain = 'localhost';
          }
          else if (hostWithoutPort.split('.').length <= 2) {
              domain = hostWithoutPort;
          }
          else {
              // Interpret the subdomain of a 3 or more component URL as the namespace name.
              var dotInd = host.indexOf('.');
              subdomain = host.substring(0, dotInd).toLowerCase();
              domain = host.substring(dotInd + 1);
              // Normalize namespaces to lowercase to share storage / connection.
              namespace = subdomain;
          }
          // Always treat the value of the `ns` as the namespace name if it is present.
          if ('ns' in queryParams) {
              namespace = queryParams['ns'];
          }
      }
      return {
          host: host,
          port: port,
          domain: domain,
          subdomain: subdomain,
          secure: secure,
          scheme: scheme,
          pathString: pathString,
          namespace: namespace
      };
  };
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * Encapsulates the data needed to raise an event
   */
  var DataEvent = /** @class */ (function () {
      /**
       * @param eventType - One of: value, child_added, child_changed, child_moved, child_removed
       * @param eventRegistration - The function to call to with the event data. User provided
       * @param snapshot - The data backing the event
       * @param prevName - Optional, the name of the previous child for child_* events.
       */
      function DataEvent(eventType, eventRegistration, snapshot, prevName) {
          this.eventType = eventType;
          this.eventRegistration = eventRegistration;
          this.snapshot = snapshot;
          this.prevName = prevName;
      }
      DataEvent.prototype.getPath = function () {
          var ref = this.snapshot.ref;
          if (this.eventType === 'value') {
              return ref._path;
          }
          else {
              return ref.parent._path;
          }
      };
      DataEvent.prototype.getEventType = function () {
          return this.eventType;
      };
      DataEvent.prototype.getEventRunner = function () {
          return this.eventRegistration.getEventRunner(this);
      };
      DataEvent.prototype.toString = function () {
          return (this.getPath().toString() +
              ':' +
              this.eventType +
              ':' +
              util.stringify(this.snapshot.exportVal()));
      };
      return DataEvent;
  }());
  var CancelEvent = /** @class */ (function () {
      function CancelEvent(eventRegistration, error, path) {
          this.eventRegistration = eventRegistration;
          this.error = error;
          this.path = path;
      }
      CancelEvent.prototype.getPath = function () {
          return this.path;
      };
      CancelEvent.prototype.getEventType = function () {
          return 'cancel';
      };
      CancelEvent.prototype.getEventRunner = function () {
          return this.eventRegistration.getEventRunner(this);
      };
      CancelEvent.prototype.toString = function () {
          return this.path.toString() + ':cancel';
      };
      return CancelEvent;
  }());
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * A wrapper class that converts events from the database@exp SDK to the legacy
   * Database SDK. Events are not converted directly as event registration relies
   * on reference comparison of the original user callback (see `matches()`) and
   * relies on equality of the legacy SDK's `context` object.
   */
  var CallbackContext = /** @class */ (function () {
      function CallbackContext(snapshotCallback, cancelCallback) {
          this.snapshotCallback = snapshotCallback;
          this.cancelCallback = cancelCallback;
      }
      CallbackContext.prototype.onValue = function (expDataSnapshot, previousChildName) {
          this.snapshotCallback.call(null, expDataSnapshot, previousChildName);
      };
      CallbackContext.prototype.onCancel = function (error) {
          util.assert(this.hasCancelCallback, 'Raising a cancel event on a listener with no cancel callback');
          return this.cancelCallback.call(null, error);
      };
      Object.defineProperty(CallbackContext.prototype, "hasCancelCallback", {
          get: function () {
              return !!this.cancelCallback;
          },
          enumerable: false,
          configurable: true
      });
      CallbackContext.prototype.matches = function (other) {
          return (this.snapshotCallback === other.snapshotCallback ||
              (this.snapshotCallback.userCallback !== undefined &&
                  this.snapshotCallback.userCallback ===
                      other.snapshotCallback.userCallback &&
                  this.snapshotCallback.context === other.snapshotCallback.context));
      };
      return CallbackContext;
  }());
  
  /**
   * @license
   * Copyright 2021 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * The `onDisconnect` class allows you to write or clear data when your client
   * disconnects from the Database server. These updates occur whether your
   * client disconnects cleanly or not, so you can rely on them to clean up data
   * even if a connection is dropped or a client crashes.
   *
   * The `onDisconnect` class is most commonly used to manage presence in
   * applications where it is useful to detect how many clients are connected and
   * when other clients disconnect. See
   * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
   * for more information.
   *
   * To avoid problems when a connection is dropped before the requests can be
   * transferred to the Database server, these functions should be called before
   * writing any data.
   *
   * Note that `onDisconnect` operations are only triggered once. If you want an
   * operation to occur each time a disconnect occurs, you'll need to re-establish
   * the `onDisconnect` operations each time you reconnect.
   */
  var OnDisconnect = /** @class */ (function () {
      /** @hideconstructor */
      function OnDisconnect(_repo, _path) {
          this._repo = _repo;
          this._path = _path;
      }
      /**
       * Cancels all previously queued `onDisconnect()` set or update events for this
       * location and all children.
       *
       * If a write has been queued for this location via a `set()` or `update()` at a
       * parent location, the write at this location will be canceled, though writes
       * to sibling locations will still occur.
       *
       * @returns Resolves when synchronization to the server is complete.
       */
      OnDisconnect.prototype.cancel = function () {
          var deferred = new util.Deferred();
          repoOnDisconnectCancel(this._repo, this._path, deferred.wrapCallback(function () { }));
          return deferred.promise;
      };
      /**
       * Ensures the data at this location is deleted when the client is disconnected
       * (due to closing the browser, navigating to a new page, or network issues).
       *
       * @returns Resolves when synchronization to the server is complete.
       */
      OnDisconnect.prototype.remove = function () {
          validateWritablePath('OnDisconnect.remove', this._path);
          var deferred = new util.Deferred();
          repoOnDisconnectSet(this._repo, this._path, null, deferred.wrapCallback(function () { }));
          return deferred.promise;
      };
      /**
       * Ensures the data at this location is set to the specified value when the
       * client is disconnected (due to closing the browser, navigating to a new page,
       * or network issues).
       *
       * `set()` is especially useful for implementing "presence" systems, where a
       * value should be changed or cleared when a user disconnects so that they
       * appear "offline" to other users. See
       * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
       * for more information.
       *
       * Note that `onDisconnect` operations are only triggered once. If you want an
       * operation to occur each time a disconnect occurs, you'll need to re-establish
       * the `onDisconnect` operations each time.
       *
       * @param value - The value to be written to this location on disconnect (can
       * be an object, array, string, number, boolean, or null).
       * @returns Resolves when synchronization to the Database is complete.
       */
      OnDisconnect.prototype.set = function (value) {
          validateWritablePath('OnDisconnect.set', this._path);
          validateFirebaseDataArg('OnDisconnect.set', value, this._path, false);
          var deferred = new util.Deferred();
          repoOnDisconnectSet(this._repo, this._path, value, deferred.wrapCallback(function () { }));
          return deferred.promise;
      };
      /**
       * Ensures the data at this location is set to the specified value and priority
       * when the client is disconnected (due to closing the browser, navigating to a
       * new page, or network issues).
       *
       * @param value - The value to be written to this location on disconnect (can
       * be an object, array, string, number, boolean, or null).
       * @param priority - The priority to be written (string, number, or null).
       * @returns Resolves when synchronization to the Database is complete.
       */
      OnDisconnect.prototype.setWithPriority = function (value, priority) {
          validateWritablePath('OnDisconnect.setWithPriority', this._path);
          validateFirebaseDataArg('OnDisconnect.setWithPriority', value, this._path, false);
          validatePriority('OnDisconnect.setWithPriority', priority, false);
          var deferred = new util.Deferred();
          repoOnDisconnectSetWithPriority(this._repo, this._path, value, priority, deferred.wrapCallback(function () { }));
          return deferred.promise;
      };
      /**
       * Writes multiple values at this location when the client is disconnected (due
       * to closing the browser, navigating to a new page, or network issues).
       *
       * The `values` argument contains multiple property-value pairs that will be
       * written to the Database together. Each child property can either be a simple
       * property (for example, "name") or a relative path (for example, "name/first")
       * from the current location to the data to update.
       *
       * As opposed to the `set()` method, `update()` can be use to selectively update
       * only the referenced properties at the current location (instead of replacing
       * all the child properties at the current location).
       *
       * @param values - Object containing multiple values.
       * @returns Resolves when synchronization to the Database is complete.
       */
      OnDisconnect.prototype.update = function (values) {
          validateWritablePath('OnDisconnect.update', this._path);
          validateFirebaseMergeDataArg('OnDisconnect.update', values, this._path, false);
          var deferred = new util.Deferred();
          repoOnDisconnectUpdate(this._repo, this._path, values, deferred.wrapCallback(function () { }));
          return deferred.promise;
      };
      return OnDisconnect;
  }());
  
  /**
   * @license
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * @internal
   */
  var QueryImpl = /** @class */ (function () {
      /**
       * @hideconstructor
       */
      function QueryImpl(_repo, _path, _queryParams, _orderByCalled) {
          this._repo = _repo;
          this._path = _path;
          this._queryParams = _queryParams;
          this._orderByCalled = _orderByCalled;
      }
      Object.defineProperty(QueryImpl.prototype, "key", {
          get: function () {
              if (pathIsEmpty(this._path)) {
                  return null;
              }
              else {
                  return pathGetBack(this._path);
              }
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(QueryImpl.prototype, "ref", {
          get: function () {
              return new ReferenceImpl(this._repo, this._path);
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(QueryImpl.prototype, "_queryIdentifier", {
          get: function () {
              var obj = queryParamsGetQueryObject(this._queryParams);
              var id = ObjectToUniqueKey(obj);
              return id === '{}' ? 'default' : id;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(QueryImpl.prototype, "_queryObject", {
          /**
           * An object representation of the query parameters used by this Query.
           */
          get: function () {
              return queryParamsGetQueryObject(this._queryParams);
          },
          enumerable: false,
          configurable: true
      });
      QueryImpl.prototype.isEqual = function (other) {
          other = util.getModularInstance(other);
          if (!(other instanceof QueryImpl)) {
              return false;
          }
          var sameRepo = this._repo === other._repo;
          var samePath = pathEquals(this._path, other._path);
          var sameQueryIdentifier = this._queryIdentifier === other._queryIdentifier;
          return sameRepo && samePath && sameQueryIdentifier;
      };
      QueryImpl.prototype.toJSON = function () {
          return this.toString();
      };
      QueryImpl.prototype.toString = function () {
          return this._repo.toString() + pathToUrlEncodedString(this._path);
      };
      return QueryImpl;
  }());
  /**
   * Validates that no other order by call has been made
   */
  function validateNoPreviousOrderByCall(query, fnName) {
      if (query._orderByCalled === true) {
          throw new Error(fnName + ": You can't combine multiple orderBy calls.");
      }
  }
  /**
   * Validates start/end values for queries.
   */
  function validateQueryEndpoints(params) {
      var startNode = null;
      var endNode = null;
      if (params.hasStart()) {
          startNode = params.getIndexStartValue();
      }
      if (params.hasEnd()) {
          endNode = params.getIndexEndValue();
      }
      if (params.getIndex() === KEY_INDEX) {
          var tooManyArgsError = 'Query: When ordering by key, you may only pass one argument to ' +
              'startAt(), endAt(), or equalTo().';
          var wrongArgTypeError = 'Query: When ordering by key, the argument passed to startAt(), startAfter(), ' +
              'endAt(), endBefore(), or equalTo() must be a string.';
          if (params.hasStart()) {
              var startName = params.getIndexStartName();
              if (startName !== MIN_NAME) {
                  throw new Error(tooManyArgsError);
              }
              else if (typeof startNode !== 'string') {
                  throw new Error(wrongArgTypeError);
              }
          }
          if (params.hasEnd()) {
              var endName = params.getIndexEndName();
              if (endName !== MAX_NAME) {
                  throw new Error(tooManyArgsError);
              }
              else if (typeof endNode !== 'string') {
                  throw new Error(wrongArgTypeError);
              }
          }
      }
      else if (params.getIndex() === PRIORITY_INDEX) {
          if ((startNode != null && !isValidPriority(startNode)) ||
              (endNode != null && !isValidPriority(endNode))) {
              throw new Error('Query: When ordering by priority, the first argument passed to startAt(), ' +
                  'startAfter() endAt(), endBefore(), or equalTo() must be a valid priority value ' +
                  '(null, a number, or a string).');
          }
      }
      else {
          util.assert(params.getIndex() instanceof PathIndex ||
              params.getIndex() === VALUE_INDEX, 'unknown index type.');
          if ((startNode != null && typeof startNode === 'object') ||
              (endNode != null && typeof endNode === 'object')) {
              throw new Error('Query: First argument passed to startAt(), startAfter(), endAt(), endBefore(), or ' +
                  'equalTo() cannot be an object.');
          }
      }
  }
  /**
   * Validates that limit* has been called with the correct combination of parameters
   */
  function validateLimit(params) {
      if (params.hasStart() &&
          params.hasEnd() &&
          params.hasLimit() &&
          !params.hasAnchoredLimit()) {
          throw new Error("Query: Can't combine startAt(), startAfter(), endAt(), endBefore(), and limit(). Use " +
              'limitToFirst() or limitToLast() instead.');
      }
  }
  /**
   * @internal
   */
  var ReferenceImpl = /** @class */ (function (_super) {
      tslib.__extends(ReferenceImpl, _super);
      /** @hideconstructor */
      function ReferenceImpl(repo, path) {
          return _super.call(this, repo, path, new QueryParams(), false) || this;
      }
      Object.defineProperty(ReferenceImpl.prototype, "parent", {
          get: function () {
              var parentPath = pathParent(this._path);
              return parentPath === null
                  ? null
                  : new ReferenceImpl(this._repo, parentPath);
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(ReferenceImpl.prototype, "root", {
          get: function () {
              var ref = this;
              while (ref.parent !== null) {
                  ref = ref.parent;
              }
              return ref;
          },
          enumerable: false,
          configurable: true
      });
      return ReferenceImpl;
  }(QueryImpl));
  /**
   * A `DataSnapshot` contains data from a Database location.
   *
   * Any time you read data from the Database, you receive the data as a
   * `DataSnapshot`. A `DataSnapshot` is passed to the event callbacks you attach
   * with `on()` or `once()`. You can extract the contents of the snapshot as a
   * JavaScript object by calling the `val()` method. Alternatively, you can
   * traverse into the snapshot by calling `child()` to return child snapshots
   * (which you could then call `val()` on).
   *
   * A `DataSnapshot` is an efficiently generated, immutable copy of the data at
   * a Database location. It cannot be modified and will never change (to modify
   * data, you always call the `set()` method on a `Reference` directly).
   */
  var DataSnapshot = /** @class */ (function () {
      /**
       * @param _node - A SnapshotNode to wrap.
       * @param ref - The location this snapshot came from.
       * @param _index - The iteration order for this snapshot
       * @hideconstructor
       */
      function DataSnapshot(_node, 
      /**
       * The location of this DataSnapshot.
       */
      ref, _index) {
          this._node = _node;
          this.ref = ref;
          this._index = _index;
      }
      Object.defineProperty(DataSnapshot.prototype, "priority", {
          /**
           * Gets the priority value of the data in this `DataSnapshot`.
           *
           * Applications need not use priority but can order collections by
           * ordinary properties (see
           * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data |Sorting and filtering data}
           * ).
           */
          get: function () {
              // typecast here because we never return deferred values or internal priorities (MAX_PRIORITY)
              return this._node.getPriority().val();
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(DataSnapshot.prototype, "key", {
          /**
           * The key (last part of the path) of the location of this `DataSnapshot`.
           *
           * The last token in a Database location is considered its key. For example,
           * "ada" is the key for the /users/ada/ node. Accessing the key on any
           * `DataSnapshot` will return the key for the location that generated it.
           * However, accessing the key on the root URL of a Database will return
           * `null`.
           */
          get: function () {
              return this.ref.key;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(DataSnapshot.prototype, "size", {
          /** Returns the number of child properties of this `DataSnapshot`. */
          get: function () {
              return this._node.numChildren();
          },
          enumerable: false,
          configurable: true
      });
      /**
       * Gets another `DataSnapshot` for the location at the specified relative path.
       *
       * Passing a relative path to the `child()` method of a DataSnapshot returns
       * another `DataSnapshot` for the location at the specified relative path. The
       * relative path can either be a simple child name (for example, "ada") or a
       * deeper, slash-separated path (for example, "ada/name/first"). If the child
       * location has no data, an empty `DataSnapshot` (that is, a `DataSnapshot`
       * whose value is `null`) is returned.
       *
       * @param path - A relative path to the location of child data.
       */
      DataSnapshot.prototype.child = function (path) {
          var childPath = new Path(path);
          var childRef = child(this.ref, path);
          return new DataSnapshot(this._node.getChild(childPath), childRef, PRIORITY_INDEX);
      };
      /**
       * Returns true if this `DataSnapshot` contains any data. It is slightly more
       * efficient than using `snapshot.val() !== null`.
       */
      DataSnapshot.prototype.exists = function () {
          return !this._node.isEmpty();
      };
      /**
       * Exports the entire contents of the DataSnapshot as a JavaScript object.
       *
       * The `exportVal()` method is similar to `val()`, except priority information
       * is included (if available), making it suitable for backing up your data.
       *
       * @returns The DataSnapshot's contents as a JavaScript value (Object,
       *   Array, string, number, boolean, or `null`).
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      DataSnapshot.prototype.exportVal = function () {
          return this._node.val(true);
      };
      /**
       * Enumerates the top-level children in the `DataSnapshot`.
       *
       * Because of the way JavaScript objects work, the ordering of data in the
       * JavaScript object returned by `val()` is not guaranteed to match the
       * ordering on the server nor the ordering of `onChildAdded()` events. That is
       * where `forEach()` comes in handy. It guarantees the children of a
       * `DataSnapshot` will be iterated in their query order.
       *
       * If no explicit `orderBy*()` method is used, results are returned
       * ordered by key (unless priorities are used, in which case, results are
       * returned by priority).
       *
       * @param action - A function that will be called for each child DataSnapshot.
       * The callback can return true to cancel further enumeration.
       * @returns true if enumeration was canceled due to your callback returning
       * true.
       */
      DataSnapshot.prototype.forEach = function (action) {
          var _this = this;
          if (this._node.isLeafNode()) {
              return false;
          }
          var childrenNode = this._node;
          // Sanitize the return value to a boolean. ChildrenNode.forEachChild has a weird return type...
          return !!childrenNode.forEachChild(this._index, function (key, node) {
              return action(new DataSnapshot(node, child(_this.ref, key), PRIORITY_INDEX));
          });
      };
      /**
       * Returns true if the specified child path has (non-null) data.
       *
       * @param path - A relative path to the location of a potential child.
       * @returns `true` if data exists at the specified child path; else
       *  `false`.
       */
      DataSnapshot.prototype.hasChild = function (path) {
          var childPath = new Path(path);
          return !this._node.getChild(childPath).isEmpty();
      };
      /**
       * Returns whether or not the `DataSnapshot` has any non-`null` child
       * properties.
       *
       * You can use `hasChildren()` to determine if a `DataSnapshot` has any
       * children. If it does, you can enumerate them using `forEach()`. If it
       * doesn't, then either this snapshot contains a primitive value (which can be
       * retrieved with `val()`) or it is empty (in which case, `val()` will return
       * `null`).
       *
       * @returns true if this snapshot has any children; else false.
       */
      DataSnapshot.prototype.hasChildren = function () {
          if (this._node.isLeafNode()) {
              return false;
          }
          else {
              return !this._node.isEmpty();
          }
      };
      /**
       * Returns a JSON-serializable representation of this object.
       */
      DataSnapshot.prototype.toJSON = function () {
          return this.exportVal();
      };
      /**
       * Extracts a JavaScript value from a `DataSnapshot`.
       *
       * Depending on the data in a `DataSnapshot`, the `val()` method may return a
       * scalar type (string, number, or boolean), an array, or an object. It may
       * also return null, indicating that the `DataSnapshot` is empty (contains no
       * data).
       *
       * @returns The DataSnapshot's contents as a JavaScript value (Object,
       *   Array, string, number, boolean, or `null`).
       */
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      DataSnapshot.prototype.val = function () {
          return this._node.val();
      };
      return DataSnapshot;
  }());
  /**
   *
   * Returns a `Reference` representing the location in the Database
   * corresponding to the provided path. If no path is provided, the `Reference`
   * will point to the root of the Database.
   *
   * @param db - The database instance to obtain a reference for.
   * @param path - Optional path representing the location the returned
   *   `Reference` will point. If not provided, the returned `Reference` will
   *   point to the root of the Database.
   * @returns If a path is provided, a `Reference`
   *   pointing to the provided path. Otherwise, a `Reference` pointing to the
   *   root of the Database.
   */
  function ref(db, path) {
      db = util.getModularInstance(db);
      db._checkNotDeleted('ref');
      return path !== undefined ? child(db._root, path) : db._root;
  }
  /**
   * Returns a `Reference` representing the location in the Database
   * corresponding to the provided Firebase URL.
   *
   * An exception is thrown if the URL is not a valid Firebase Database URL or it
   * has a different domain than the current `Database` instance.
   *
   * Note that all query parameters (`orderBy`, `limitToLast`, etc.) are ignored
   * and are not applied to the returned `Reference`.
   *
   * @param db - The database instance to obtain a reference for.
   * @param url - The Firebase URL at which the returned `Reference` will
   *   point.
   * @returns A `Reference` pointing to the provided
   *   Firebase URL.
   */
  function refFromURL(db, url) {
      db = util.getModularInstance(db);
      db._checkNotDeleted('refFromURL');
      var parsedURL = parseRepoInfo(url, db._repo.repoInfo_.nodeAdmin);
      validateUrl('refFromURL', parsedURL);
      var repoInfo = parsedURL.repoInfo;
      if (!db._repo.repoInfo_.isCustomHost() &&
          repoInfo.host !== db._repo.repoInfo_.host) {
          fatal('refFromURL' +
              ': Host name does not match the current database: ' +
              '(found ' +
              repoInfo.host +
              ' but expected ' +
              db._repo.repoInfo_.host +
              ')');
      }
      return ref(db, parsedURL.path.toString());
  }
  /**
   * Gets a `Reference` for the location at the specified relative path.
   *
   * The relative path can either be a simple child name (for example, "ada") or
   * a deeper slash-separated path (for example, "ada/name/first").
   *
   * @param parent - The parent location.
   * @param path - A relative path from this location to the desired child
   *   location.
   * @returns The specified child location.
   */
  function child(parent, path) {
      parent = util.getModularInstance(parent);
      if (pathGetFront(parent._path) === null) {
          validateRootPathString('child', 'path', path, false);
      }
      else {
          validatePathString('child', 'path', path, false);
      }
      return new ReferenceImpl(parent._repo, pathChild(parent._path, path));
  }
  /**
   * Returns an `OnDisconnect` object - see
   * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
   * for more information on how to use it.
   *
   * @param ref - The reference to add OnDisconnect triggers for.
   */
  function onDisconnect(ref) {
      ref = util.getModularInstance(ref);
      return new OnDisconnect(ref._repo, ref._path);
  }
  /**
   * Generates a new child location using a unique key and returns its
   * `Reference`.
   *
   * This is the most common pattern for adding data to a collection of items.
   *
   * If you provide a value to `push()`, the value is written to the
   * generated location. If you don't pass a value, nothing is written to the
   * database and the child remains empty (but you can use the `Reference`
   * elsewhere).
   *
   * The unique keys generated by `push()` are ordered by the current time, so the
   * resulting list of items is chronologically sorted. The keys are also
   * designed to be unguessable (they contain 72 random bits of entropy).
   *
   * See {@link https://firebase.google.com/docs/database/web/lists-of-data#append_to_a_list_of_data | Append to a list of data}
   * </br>See {@link ttps://firebase.googleblog.com/2015/02/the-2120-ways-to-ensure-unique_68.html | The 2^120 Ways to Ensure Unique Identifiers}
   *
   * @param parent - The parent location.
   * @param value - Optional value to be written at the generated location.
   * @returns Combined `Promise` and `Reference`; resolves when write is complete,
   * but can be used immediately as the `Reference` to the child location.
   */
  function push(parent, value) {
      parent = util.getModularInstance(parent);
      validateWritablePath('push', parent._path);
      validateFirebaseDataArg('push', value, parent._path, true);
      var now = repoServerTime(parent._repo);
      var name = nextPushId(now);
      // push() returns a ThennableReference whose promise is fulfilled with a
      // regular Reference. We use child() to create handles to two different
      // references. The first is turned into a ThennableReference below by adding
      // then() and catch() methods and is used as the return value of push(). The
      // second remains a regular Reference and is used as the fulfilled value of
      // the first ThennableReference.
      var thennablePushRef = child(parent, name);
      var pushRef = child(parent, name);
      var promise;
      if (value != null) {
          promise = set(pushRef, value).then(function () { return pushRef; });
      }
      else {
          promise = Promise.resolve(pushRef);
      }
      thennablePushRef.then = promise.then.bind(promise);
      thennablePushRef.catch = promise.then.bind(promise, undefined);
      return thennablePushRef;
  }
  /**
   * Removes the data at this Database location.
   *
   * Any data at child locations will also be deleted.
   *
   * The effect of the remove will be visible immediately and the corresponding
   * event 'value' will be triggered. Synchronization of the remove to the
   * Firebase servers will also be started, and the returned Promise will resolve
   * when complete. If provided, the onComplete callback will be called
   * asynchronously after synchronization has finished.
   *
   * @param ref - The location to remove.
   * @returns Resolves when remove on server is complete.
   */
  function remove(ref) {
      validateWritablePath('remove', ref._path);
      return set(ref, null);
  }
  /**
   * Writes data to this Database location.
   *
   * This will overwrite any data at this location and all child locations.
   *
   * The effect of the write will be visible immediately, and the corresponding
   * events ("value", "child_added", etc.) will be triggered. Synchronization of
   * the data to the Firebase servers will also be started, and the returned
   * Promise will resolve when complete. If provided, the `onComplete` callback
   * will be called asynchronously after synchronization has finished.
   *
   * Passing `null` for the new value is equivalent to calling `remove()`; namely,
   * all data at this location and all child locations will be deleted.
   *
   * `set()` will remove any priority stored at this location, so if priority is
   * meant to be preserved, you need to use `setWithPriority()` instead.
   *
   * Note that modifying data with `set()` will cancel any pending transactions
   * at that location, so extreme care should be taken if mixing `set()` and
   * `transaction()` to modify the same data.
   *
   * A single `set()` will generate a single "value" event at the location where
   * the `set()` was performed.
   *
   * @param ref - The location to write to.
   * @param value - The value to be written (string, number, boolean, object,
   *   array, or null).
   * @returns Resolves when write to server is complete.
   */
  function set(ref, value) {
      ref = util.getModularInstance(ref);
      validateWritablePath('set', ref._path);
      validateFirebaseDataArg('set', value, ref._path, false);
      var deferred = new util.Deferred();
      repoSetWithPriority(ref._repo, ref._path, value, 
      /*priority=*/ null, deferred.wrapCallback(function () { }));
      return deferred.promise;
  }
  /**
   * Sets a priority for the data at this Database location.
   *
   * Applications need not use priority but can order collections by
   * ordinary properties (see
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}
   * ).
   *
   * @param ref - The location to write to.
   * @param priority - The priority to be written (string, number, or null).
   * @returns Resolves when write to server is complete.
   */
  function setPriority(ref, priority) {
      ref = util.getModularInstance(ref);
      validateWritablePath('setPriority', ref._path);
      validatePriority('setPriority', priority, false);
      var deferred = new util.Deferred();
      repoSetWithPriority(ref._repo, pathChild(ref._path, '.priority'), priority, null, deferred.wrapCallback(function () { }));
      return deferred.promise;
  }
  /**
   * Writes data the Database location. Like `set()` but also specifies the
   * priority for that data.
   *
   * Applications need not use priority but can order collections by
   * ordinary properties (see
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}
   * ).
   *
   * @param ref - The location to write to.
   * @param value - The value to be written (string, number, boolean, object,
   *   array, or null).
   * @param priority - The priority to be written (string, number, or null).
   * @returns Resolves when write to server is complete.
   */
  function setWithPriority(ref, value, priority) {
      validateWritablePath('setWithPriority', ref._path);
      validateFirebaseDataArg('setWithPriority', value, ref._path, false);
      validatePriority('setWithPriority', priority, false);
      if (ref.key === '.length' || ref.key === '.keys') {
          throw 'setWithPriority failed: ' + ref.key + ' is a read-only object.';
      }
      var deferred = new util.Deferred();
      repoSetWithPriority(ref._repo, ref._path, value, priority, deferred.wrapCallback(function () { }));
      return deferred.promise;
  }
  /**
   * Writes multiple values to the Database at once.
   *
   * The `values` argument contains multiple property-value pairs that will be
   * written to the Database together. Each child property can either be a simple
   * property (for example, "name") or a relative path (for example,
   * "name/first") from the current location to the data to update.
   *
   * As opposed to the `set()` method, `update()` can be use to selectively update
   * only the referenced properties at the current location (instead of replacing
   * all the child properties at the current location).
   *
   * The effect of the write will be visible immediately, and the corresponding
   * events ('value', 'child_added', etc.) will be triggered. Synchronization of
   * the data to the Firebase servers will also be started, and the returned
   * Promise will resolve when complete. If provided, the `onComplete` callback
   * will be called asynchronously after synchronization has finished.
   *
   * A single `update()` will generate a single "value" event at the location
   * where the `update()` was performed, regardless of how many children were
   * modified.
   *
   * Note that modifying data with `update()` will cancel any pending
   * transactions at that location, so extreme care should be taken if mixing
   * `update()` and `transaction()` to modify the same data.
   *
   * Passing `null` to `update()` will remove the data at this location.
   *
   * See
   * {@link https://firebase.googleblog.com/2015/09/introducing-multi-location-updates-and_86.html | Introducing multi-location updates and more}.
   *
   * @param ref - The location to write to.
   * @param values - Object containing multiple values.
   * @returns Resolves when update on server is complete.
   */
  function update(ref, values) {
      validateFirebaseMergeDataArg('update', values, ref._path, false);
      var deferred = new util.Deferred();
      repoUpdate(ref._repo, ref._path, values, deferred.wrapCallback(function () { }));
      return deferred.promise;
  }
  /**
   * Gets the most up-to-date result for this query.
   *
   * @param query - The query to run.
   * @returns A `Promise` which resolves to the resulting DataSnapshot if a value is
   * available, or rejects if the client is unable to return a value (e.g., if the
   * server is unreachable and there is nothing cached).
   */
  function get(query) {
      query = util.getModularInstance(query);
      return repoGetValue(query._repo, query).then(function (node) {
          return new DataSnapshot(node, new ReferenceImpl(query._repo, query._path), query._queryParams.getIndex());
      });
  }
  /**
   * Represents registration for 'value' events.
   */
  var ValueEventRegistration = /** @class */ (function () {
      function ValueEventRegistration(callbackContext) {
          this.callbackContext = callbackContext;
      }
      ValueEventRegistration.prototype.respondsTo = function (eventType) {
          return eventType === 'value';
      };
      ValueEventRegistration.prototype.createEvent = function (change, query) {
          var index = query._queryParams.getIndex();
          return new DataEvent('value', this, new DataSnapshot(change.snapshotNode, new ReferenceImpl(query._repo, query._path), index));
      };
      ValueEventRegistration.prototype.getEventRunner = function (eventData) {
          var _this = this;
          if (eventData.getEventType() === 'cancel') {
              return function () {
                  return _this.callbackContext.onCancel(eventData.error);
              };
          }
          else {
              return function () {
                  return _this.callbackContext.onValue(eventData.snapshot, null);
              };
          }
      };
      ValueEventRegistration.prototype.createCancelEvent = function (error, path) {
          if (this.callbackContext.hasCancelCallback) {
              return new CancelEvent(this, error, path);
          }
          else {
              return null;
          }
      };
      ValueEventRegistration.prototype.matches = function (other) {
          if (!(other instanceof ValueEventRegistration)) {
              return false;
          }
          else if (!other.callbackContext || !this.callbackContext) {
              // If no callback specified, we consider it to match any callback.
              return true;
          }
          else {
              return other.callbackContext.matches(this.callbackContext);
          }
      };
      ValueEventRegistration.prototype.hasAnyCallback = function () {
          return this.callbackContext !== null;
      };
      return ValueEventRegistration;
  }());
  /**
   * Represents the registration of a child_x event.
   */
  var ChildEventRegistration = /** @class */ (function () {
      function ChildEventRegistration(eventType, callbackContext) {
          this.eventType = eventType;
          this.callbackContext = callbackContext;
      }
      ChildEventRegistration.prototype.respondsTo = function (eventType) {
          var eventToCheck = eventType === 'children_added' ? 'child_added' : eventType;
          eventToCheck =
              eventToCheck === 'children_removed' ? 'child_removed' : eventToCheck;
          return this.eventType === eventToCheck;
      };
      ChildEventRegistration.prototype.createCancelEvent = function (error, path) {
          if (this.callbackContext.hasCancelCallback) {
              return new CancelEvent(this, error, path);
          }
          else {
              return null;
          }
      };
      ChildEventRegistration.prototype.createEvent = function (change, query) {
          util.assert(change.childName != null, 'Child events should have a childName.');
          var childRef = child(new ReferenceImpl(query._repo, query._path), change.childName);
          var index = query._queryParams.getIndex();
          return new DataEvent(change.type, this, new DataSnapshot(change.snapshotNode, childRef, index), change.prevName);
      };
      ChildEventRegistration.prototype.getEventRunner = function (eventData) {
          var _this = this;
          if (eventData.getEventType() === 'cancel') {
              return function () {
                  return _this.callbackContext.onCancel(eventData.error);
              };
          }
          else {
              return function () {
                  return _this.callbackContext.onValue(eventData.snapshot, eventData.prevName);
              };
          }
      };
      ChildEventRegistration.prototype.matches = function (other) {
          if (other instanceof ChildEventRegistration) {
              return (this.eventType === other.eventType &&
                  (!this.callbackContext ||
                      !other.callbackContext ||
                      this.callbackContext.matches(other.callbackContext)));
          }
          return false;
      };
      ChildEventRegistration.prototype.hasAnyCallback = function () {
          return !!this.callbackContext;
      };
      return ChildEventRegistration;
  }());
  function addEventListener(query, eventType, callback, cancelCallbackOrListenOptions, options) {
      var cancelCallback;
      if (typeof cancelCallbackOrListenOptions === 'object') {
          cancelCallback = undefined;
          options = cancelCallbackOrListenOptions;
      }
      if (typeof cancelCallbackOrListenOptions === 'function') {
          cancelCallback = cancelCallbackOrListenOptions;
      }
      if (options && options.onlyOnce) {
          var userCallback_1 = callback;
          var onceCallback = function (dataSnapshot, previousChildName) {
              repoRemoveEventCallbackForQuery(query._repo, query, container);
              userCallback_1(dataSnapshot, previousChildName);
          };
          onceCallback.userCallback = callback.userCallback;
          onceCallback.context = callback.context;
          callback = onceCallback;
      }
      var callbackContext = new CallbackContext(callback, cancelCallback || undefined);
      var container = eventType === 'value'
          ? new ValueEventRegistration(callbackContext)
          : new ChildEventRegistration(eventType, callbackContext);
      repoAddEventCallbackForQuery(query._repo, query, container);
      return function () { return repoRemoveEventCallbackForQuery(query._repo, query, container); };
  }
  function onValue(query, callback, cancelCallbackOrListenOptions, options) {
      return addEventListener(query, 'value', callback, cancelCallbackOrListenOptions, options);
  }
  function onChildAdded(query, callback, cancelCallbackOrListenOptions, options) {
      return addEventListener(query, 'child_added', callback, cancelCallbackOrListenOptions, options);
  }
  function onChildChanged(query, callback, cancelCallbackOrListenOptions, options) {
      return addEventListener(query, 'child_changed', callback, cancelCallbackOrListenOptions, options);
  }
  function onChildMoved(query, callback, cancelCallbackOrListenOptions, options) {
      return addEventListener(query, 'child_moved', callback, cancelCallbackOrListenOptions, options);
  }
  function onChildRemoved(query, callback, cancelCallbackOrListenOptions, options) {
      return addEventListener(query, 'child_removed', callback, cancelCallbackOrListenOptions, options);
  }
  /**
   * Detaches a callback previously attached with `on()`.
   *
   * Detach a callback previously attached with `on()`. Note that if `on()` was
   * called multiple times with the same eventType and callback, the callback
   * will be called multiple times for each event, and `off()` must be called
   * multiple times to remove the callback. Calling `off()` on a parent listener
   * will not automatically remove listeners registered on child nodes, `off()`
   * must also be called on any child listeners to remove the callback.
   *
   * If a callback is not specified, all callbacks for the specified eventType
   * will be removed. Similarly, if no eventType is specified, all callbacks
   * for the `Reference` will be removed.
   *
   * Individual listeners can also be removed by invoking their unsubscribe
   * callbacks.
   *
   * @param query - The query that the listener was registered with.
   * @param eventType - One of the following strings: "value", "child_added",
   * "child_changed", "child_removed", or "child_moved." If omitted, all callbacks
   * for the `Reference` will be removed.
   * @param callback - The callback function that was passed to `on()` or
   * `undefined` to remove all callbacks.
   */
  function off(query, eventType, callback) {
      var container = null;
      var expCallback = callback ? new CallbackContext(callback) : null;
      if (eventType === 'value') {
          container = new ValueEventRegistration(expCallback);
      }
      else if (eventType) {
          container = new ChildEventRegistration(eventType, expCallback);
      }
      repoRemoveEventCallbackForQuery(query._repo, query, container);
  }
  /**
   * A `QueryConstraint` is used to narrow the set of documents returned by a
   * Database query. `QueryConstraint`s are created by invoking {@link endAt},
   * {@link endBefore}, {@link startAt}, {@link startAfter}, {@link
   * limitToFirst}, {@link limitToLast}, {@link orderByChild},
   * {@link orderByChild}, {@link orderByKey} , {@link orderByPriority} ,
   * {@link orderByValue}  or {@link equalTo} and
   * can then be passed to {@link query} to create a new query instance that
   * also contains this `QueryConstraint`.
   */
  var QueryConstraint = /** @class */ (function () {
      function QueryConstraint() {
      }
      return QueryConstraint;
  }());
  var QueryEndAtConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryEndAtConstraint, _super);
      function QueryEndAtConstraint(_value, _key) {
          var _this = _super.call(this) || this;
          _this._value = _value;
          _this._key = _key;
          return _this;
      }
      QueryEndAtConstraint.prototype._apply = function (query) {
          validateFirebaseDataArg('endAt', this._value, query._path, true);
          var newParams = queryParamsEndAt(query._queryParams, this._value, this._key);
          validateLimit(newParams);
          validateQueryEndpoints(newParams);
          if (query._queryParams.hasEnd()) {
              throw new Error('endAt: Starting point was already set (by another call to endAt, ' +
                  'endBefore or equalTo).');
          }
          return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
      };
      return QueryEndAtConstraint;
  }(QueryConstraint));
  /**
   * Creates a `QueryConstraint` with the specified ending point.
   *
   * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
   * allows you to choose arbitrary starting and ending points for your queries.
   *
   * The ending point is inclusive, so children with exactly the specified value
   * will be included in the query. The optional key argument can be used to
   * further limit the range of the query. If it is specified, then children that
   * have exactly the specified value must also have a key name less than or equal
   * to the specified key.
   *
   * You can read more about `endAt()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
   *
   * @param value - The value to end at. The argument type depends on which
   * `orderBy*()` function was used in this query. Specify a value that matches
   * the `orderBy*()` type. When used in combination with `orderByKey()`, the
   * value must be a string.
   * @param key - The child key to end at, among the children with the previously
   * specified priority. This argument is only allowed if ordering by child,
   * value, or priority.
   */
  function endAt(value, key) {
      validateKey('endAt', 'key', key, true);
      return new QueryEndAtConstraint(value, key);
  }
  var QueryEndBeforeConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryEndBeforeConstraint, _super);
      function QueryEndBeforeConstraint(_value, _key) {
          var _this = _super.call(this) || this;
          _this._value = _value;
          _this._key = _key;
          return _this;
      }
      QueryEndBeforeConstraint.prototype._apply = function (query) {
          validateFirebaseDataArg('endBefore', this._value, query._path, false);
          var newParams = queryParamsEndBefore(query._queryParams, this._value, this._key);
          validateLimit(newParams);
          validateQueryEndpoints(newParams);
          if (query._queryParams.hasEnd()) {
              throw new Error('endBefore: Starting point was already set (by another call to endAt, ' +
                  'endBefore or equalTo).');
          }
          return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
      };
      return QueryEndBeforeConstraint;
  }(QueryConstraint));
  /**
   * Creates a `QueryConstraint` with the specified ending point (exclusive).
   *
   * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
   * allows you to choose arbitrary starting and ending points for your queries.
   *
   * The ending point is exclusive. If only a value is provided, children
   * with a value less than the specified value will be included in the query.
   * If a key is specified, then children must have a value lesss than or equal
   * to the specified value and a a key name less than the specified key.
   *
   * @param value - The value to end before. The argument type depends on which
   * `orderBy*()` function was used in this query. Specify a value that matches
   * the `orderBy*()` type. When used in combination with `orderByKey()`, the
   * value must be a string.
   * @param key - The child key to end before, among the children with the
   * previously specified priority. This argument is only allowed if ordering by
   * child, value, or priority.
   */
  function endBefore(value, key) {
      validateKey('endBefore', 'key', key, true);
      return new QueryEndBeforeConstraint(value, key);
  }
  var QueryStartAtConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryStartAtConstraint, _super);
      function QueryStartAtConstraint(_value, _key) {
          var _this = _super.call(this) || this;
          _this._value = _value;
          _this._key = _key;
          return _this;
      }
      QueryStartAtConstraint.prototype._apply = function (query) {
          validateFirebaseDataArg('startAt', this._value, query._path, true);
          var newParams = queryParamsStartAt(query._queryParams, this._value, this._key);
          validateLimit(newParams);
          validateQueryEndpoints(newParams);
          if (query._queryParams.hasStart()) {
              throw new Error('startAt: Starting point was already set (by another call to startAt, ' +
                  'startBefore or equalTo).');
          }
          return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
      };
      return QueryStartAtConstraint;
  }(QueryConstraint));
  /**
   * Creates a `QueryConstraint` with the specified starting point.
   *
   * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
   * allows you to choose arbitrary starting and ending points for your queries.
   *
   * The starting point is inclusive, so children with exactly the specified value
   * will be included in the query. The optional key argument can be used to
   * further limit the range of the query. If it is specified, then children that
   * have exactly the specified value must also have a key name greater than or
   * equal to the specified key.
   *
   * You can read more about `startAt()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
   *
   * @param value - The value to start at. The argument type depends on which
   * `orderBy*()` function was used in this query. Specify a value that matches
   * the `orderBy*()` type. When used in combination with `orderByKey()`, the
   * value must be a string.
   * @param key - The child key to start at. This argument is only allowed if
   * ordering by child, value, or priority.
   */
  function startAt(value, key) {
      if (value === void 0) { value = null; }
      validateKey('startAt', 'key', key, true);
      return new QueryStartAtConstraint(value, key);
  }
  var QueryStartAfterConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryStartAfterConstraint, _super);
      function QueryStartAfterConstraint(_value, _key) {
          var _this = _super.call(this) || this;
          _this._value = _value;
          _this._key = _key;
          return _this;
      }
      QueryStartAfterConstraint.prototype._apply = function (query) {
          validateFirebaseDataArg('startAfter', this._value, query._path, false);
          var newParams = queryParamsStartAfter(query._queryParams, this._value, this._key);
          validateLimit(newParams);
          validateQueryEndpoints(newParams);
          if (query._queryParams.hasStart()) {
              throw new Error('startAfter: Starting point was already set (by another call to startAt, ' +
                  'startAfter, or equalTo).');
          }
          return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
      };
      return QueryStartAfterConstraint;
  }(QueryConstraint));
  /**
   * Creates a `QueryConstraint` with the specified starting point (exclusive).
   *
   * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
   * allows you to choose arbitrary starting and ending points for your queries.
   *
   * The starting point is exclusive. If only a value is provided, children
   * with a value greater than the specified value will be included in the query.
   * If a key is specified, then children must have a value greater than or equal
   * to the specified value and a a key name greater than the specified key.
   *
   * @param value - The value to start after. The argument type depends on which
   * `orderBy*()` function was used in this query. Specify a value that matches
   * the `orderBy*()` type. When used in combination with `orderByKey()`, the
   * value must be a string.
   * @param key - The child key to start after. This argument is only allowed if
   * ordering by child, value, or priority.
   */
  function startAfter(value, key) {
      validateKey('startAfter', 'key', key, true);
      return new QueryStartAfterConstraint(value, key);
  }
  var QueryLimitToFirstConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryLimitToFirstConstraint, _super);
      function QueryLimitToFirstConstraint(_limit) {
          var _this = _super.call(this) || this;
          _this._limit = _limit;
          return _this;
      }
      QueryLimitToFirstConstraint.prototype._apply = function (query) {
          if (query._queryParams.hasLimit()) {
              throw new Error('limitToFirst: Limit was already set (by another call to limitToFirst ' +
                  'or limitToLast).');
          }
          return new QueryImpl(query._repo, query._path, queryParamsLimitToFirst(query._queryParams, this._limit), query._orderByCalled);
      };
      return QueryLimitToFirstConstraint;
  }(QueryConstraint));
  /**
   * Creates a new `QueryConstraint` that if limited to the first specific number
   * of children.
   *
   * The `limitToFirst()` method is used to set a maximum number of children to be
   * synced for a given callback. If we set a limit of 100, we will initially only
   * receive up to 100 `child_added` events. If we have fewer than 100 messages
   * stored in our Database, a `child_added` event will fire for each message.
   * However, if we have over 100 messages, we will only receive a `child_added`
   * event for the first 100 ordered messages. As items change, we will receive
   * `child_removed` events for each item that drops out of the active list so
   * that the total number stays at 100.
   *
   * You can read more about `limitToFirst()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
   *
   * @param limit - The maximum number of nodes to include in this query.
   */
  function limitToFirst(limit) {
      if (typeof limit !== 'number' || Math.floor(limit) !== limit || limit <= 0) {
          throw new Error('limitToFirst: First argument must be a positive integer.');
      }
      return new QueryLimitToFirstConstraint(limit);
  }
  var QueryLimitToLastConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryLimitToLastConstraint, _super);
      function QueryLimitToLastConstraint(_limit) {
          var _this = _super.call(this) || this;
          _this._limit = _limit;
          return _this;
      }
      QueryLimitToLastConstraint.prototype._apply = function (query) {
          if (query._queryParams.hasLimit()) {
              throw new Error('limitToLast: Limit was already set (by another call to limitToFirst ' +
                  'or limitToLast).');
          }
          return new QueryImpl(query._repo, query._path, queryParamsLimitToLast(query._queryParams, this._limit), query._orderByCalled);
      };
      return QueryLimitToLastConstraint;
  }(QueryConstraint));
  /**
   * Creates a new `QueryConstraint` that is limited to return only the last
   * specified number of children.
   *
   * The `limitToLast()` method is used to set a maximum number of children to be
   * synced for a given callback. If we set a limit of 100, we will initially only
   * receive up to 100 `child_added` events. If we have fewer than 100 messages
   * stored in our Database, a `child_added` event will fire for each message.
   * However, if we have over 100 messages, we will only receive a `child_added`
   * event for the last 100 ordered messages. As items change, we will receive
   * `child_removed` events for each item that drops out of the active list so
   * that the total number stays at 100.
   *
   * You can read more about `limitToLast()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
   *
   * @param limit - The maximum number of nodes to include in this query.
   */
  function limitToLast(limit) {
      if (typeof limit !== 'number' || Math.floor(limit) !== limit || limit <= 0) {
          throw new Error('limitToLast: First argument must be a positive integer.');
      }
      return new QueryLimitToLastConstraint(limit);
  }
  var QueryOrderByChildConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryOrderByChildConstraint, _super);
      function QueryOrderByChildConstraint(_path) {
          var _this = _super.call(this) || this;
          _this._path = _path;
          return _this;
      }
      QueryOrderByChildConstraint.prototype._apply = function (query) {
          validateNoPreviousOrderByCall(query, 'orderByChild');
          var parsedPath = new Path(this._path);
          if (pathIsEmpty(parsedPath)) {
              throw new Error('orderByChild: cannot pass in empty path. Use orderByValue() instead.');
          }
          var index = new PathIndex(parsedPath);
          var newParams = queryParamsOrderBy(query._queryParams, index);
          validateQueryEndpoints(newParams);
          return new QueryImpl(query._repo, query._path, newParams, 
          /*orderByCalled=*/ true);
      };
      return QueryOrderByChildConstraint;
  }(QueryConstraint));
  /**
   * Creates a new `QueryConstraint` that orders by the specified child key.
   *
   * Queries can only order by one key at a time. Calling `orderByChild()`
   * multiple times on the same query is an error.
   *
   * Firebase queries allow you to order your data by any child key on the fly.
   * However, if you know in advance what your indexes will be, you can define
   * them via the .indexOn rule in your Security Rules for better performance. See
   * the{@link https://firebase.google.com/docs/database/security/indexing-data}
   * rule for more information.
   *
   * You can read more about `orderByChild()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
   *
   * @param path - The path to order by.
   */
  function orderByChild(path) {
      if (path === '$key') {
          throw new Error('orderByChild: "$key" is invalid.  Use orderByKey() instead.');
      }
      else if (path === '$priority') {
          throw new Error('orderByChild: "$priority" is invalid.  Use orderByPriority() instead.');
      }
      else if (path === '$value') {
          throw new Error('orderByChild: "$value" is invalid.  Use orderByValue() instead.');
      }
      validatePathString('orderByChild', 'path', path, false);
      return new QueryOrderByChildConstraint(path);
  }
  var QueryOrderByKeyConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryOrderByKeyConstraint, _super);
      function QueryOrderByKeyConstraint() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      QueryOrderByKeyConstraint.prototype._apply = function (query) {
          validateNoPreviousOrderByCall(query, 'orderByKey');
          var newParams = queryParamsOrderBy(query._queryParams, KEY_INDEX);
          validateQueryEndpoints(newParams);
          return new QueryImpl(query._repo, query._path, newParams, 
          /*orderByCalled=*/ true);
      };
      return QueryOrderByKeyConstraint;
  }(QueryConstraint));
  /**
   * Creates a new `QueryConstraint` that orders by the key.
   *
   * Sorts the results of a query by their (ascending) key values.
   *
   * You can read more about `orderByKey()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
   */
  function orderByKey() {
      return new QueryOrderByKeyConstraint();
  }
  var QueryOrderByPriorityConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryOrderByPriorityConstraint, _super);
      function QueryOrderByPriorityConstraint() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      QueryOrderByPriorityConstraint.prototype._apply = function (query) {
          validateNoPreviousOrderByCall(query, 'orderByPriority');
          var newParams = queryParamsOrderBy(query._queryParams, PRIORITY_INDEX);
          validateQueryEndpoints(newParams);
          return new QueryImpl(query._repo, query._path, newParams, 
          /*orderByCalled=*/ true);
      };
      return QueryOrderByPriorityConstraint;
  }(QueryConstraint));
  /**
   * Creates a new `QueryConstraint` that orders by priority.
   *
   * Applications need not use priority but can order collections by
   * ordinary properties (see
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}
   * for alternatives to priority.
   */
  function orderByPriority() {
      return new QueryOrderByPriorityConstraint();
  }
  var QueryOrderByValueConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryOrderByValueConstraint, _super);
      function QueryOrderByValueConstraint() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      QueryOrderByValueConstraint.prototype._apply = function (query) {
          validateNoPreviousOrderByCall(query, 'orderByValue');
          var newParams = queryParamsOrderBy(query._queryParams, VALUE_INDEX);
          validateQueryEndpoints(newParams);
          return new QueryImpl(query._repo, query._path, newParams, 
          /*orderByCalled=*/ true);
      };
      return QueryOrderByValueConstraint;
  }(QueryConstraint));
  /**
   * Creates a new `QueryConstraint` that orders by value.
   *
   * If the children of a query are all scalar values (string, number, or
   * boolean), you can order the results by their (ascending) values.
   *
   * You can read more about `orderByValue()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
   */
  function orderByValue() {
      return new QueryOrderByValueConstraint();
  }
  var QueryEqualToValueConstraint = /** @class */ (function (_super) {
      tslib.__extends(QueryEqualToValueConstraint, _super);
      function QueryEqualToValueConstraint(_value, _key) {
          var _this = _super.call(this) || this;
          _this._value = _value;
          _this._key = _key;
          return _this;
      }
      QueryEqualToValueConstraint.prototype._apply = function (query) {
          validateFirebaseDataArg('equalTo', this._value, query._path, false);
          if (query._queryParams.hasStart()) {
              throw new Error('equalTo: Starting point was already set (by another call to startAt/startAfter or ' +
                  'equalTo).');
          }
          if (query._queryParams.hasEnd()) {
              throw new Error('equalTo: Ending point was already set (by another call to endAt/endBefore or ' +
                  'equalTo).');
          }
          return new QueryEndAtConstraint(this._value, this._key)._apply(new QueryStartAtConstraint(this._value, this._key)._apply(query));
      };
      return QueryEqualToValueConstraint;
  }(QueryConstraint));
  /**
   * Creates a `QueryConstraint` that includes children that match the specified
   * value.
   *
   * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
   * allows you to choose arbitrary starting and ending points for your queries.
   *
   * The optional key argument can be used to further limit the range of the
   * query. If it is specified, then children that have exactly the specified
   * value must also have exactly the specified key as their key name. This can be
   * used to filter result sets with many matches for the same value.
   *
   * You can read more about `equalTo()` in
   * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
   *
   * @param value - The value to match for. The argument type depends on which
   * `orderBy*()` function was used in this query. Specify a value that matches
   * the `orderBy*()` type. When used in combination with `orderByKey()`, the
   * value must be a string.
   * @param key - The child key to start at, among the children with the
   * previously specified priority. This argument is only allowed if ordering by
   * child, value, or priority.
   */
  function equalTo(value, key) {
      validateKey('equalTo', 'key', key, true);
      return new QueryEqualToValueConstraint(value, key);
  }
  /**
   * Creates a new immutable instance of `Query` that is extended to also include
   * additional query constraints.
   *
   * @param query - The Query instance to use as a base for the new constraints.
   * @param queryConstraints - The list of `QueryConstraint`s to apply.
   * @throws if any of the provided query constraints cannot be combined with the
   * existing or new constraints.
   */
  function query(query) {
      var e_1, _a;
      var queryConstraints = [];
      for (var _i = 1; _i < arguments.length; _i++) {
          queryConstraints[_i - 1] = arguments[_i];
      }
      var queryImpl = util.getModularInstance(query);
      try {
          for (var queryConstraints_1 = tslib.__values(queryConstraints), queryConstraints_1_1 = queryConstraints_1.next(); !queryConstraints_1_1.done; queryConstraints_1_1 = queryConstraints_1.next()) {
              var constraint = queryConstraints_1_1.value;
              queryImpl = constraint._apply(queryImpl);
          }
      }
      catch (e_1_1) { e_1 = { error: e_1_1 }; }
      finally {
          try {
              if (queryConstraints_1_1 && !queryConstraints_1_1.done && (_a = queryConstraints_1.return)) _a.call(queryConstraints_1);
          }
          finally { if (e_1) throw e_1.error; }
      }
      return queryImpl;
  }
  /**
   * Define reference constructor in various modules
   *
   * We are doing this here to avoid several circular
   * dependency issues
   */
  syncPointSetReferenceConstructor(ReferenceImpl);
  syncTreeSetReferenceConstructor(ReferenceImpl);
  
  /**
   * @license
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * This variable is also defined in the firebase Node.js Admin SDK. Before
   * modifying this definition, consult the definition in:
   *
   * https://github.com/firebase/firebase-admin-node
   *
   * and make sure the two are consistent.
   */
  var FIREBASE_DATABASE_EMULATOR_HOST_VAR = 'FIREBASE_DATABASE_EMULATOR_HOST';
  /**
   * Creates and caches `Repo` instances.
   */
  var repos = {};
  /**
   * If true, any new `Repo` will be created to use `ReadonlyRestClient` (for testing purposes).
   */
  var useRestClient = false;
  /**
   * Update an existing `Repo` in place to point to a new host/port.
   */
  function repoManagerApplyEmulatorSettings(repo, host, port, tokenProvider) {
      repo.repoInfo_ = new RepoInfo(host + ":" + port, 
      /* secure= */ false, repo.repoInfo_.namespace, repo.repoInfo_.webSocketOnly, repo.repoInfo_.nodeAdmin, repo.repoInfo_.persistenceKey, repo.repoInfo_.includeNamespaceInQueryParams);
      if (tokenProvider) {
          repo.authTokenProvider_ = tokenProvider;
      }
  }
  /**
   * This function should only ever be called to CREATE a new database instance.
   * @internal
   */
  function repoManagerDatabaseFromApp(app, authProvider, appCheckProvider, url, nodeAdmin) {
      var dbUrl = url || app.options.databaseURL;
      if (dbUrl === undefined) {
          if (!app.options.projectId) {
              fatal("Can't determine Firebase Database URL. Be sure to include " +
                  ' a Project ID when calling firebase.initializeApp().');
          }
          log('Using default host for project ', app.options.projectId);
          dbUrl = app.options.projectId + "-default-rtdb.firebaseio.com";
      }
      var parsedUrl = parseRepoInfo(dbUrl, nodeAdmin);
      var repoInfo = parsedUrl.repoInfo;
      var isEmulator;
      var dbEmulatorHost = undefined;
      if (typeof process !== 'undefined' && process.env) {
          dbEmulatorHost = process.env[FIREBASE_DATABASE_EMULATOR_HOST_VAR];
      }
      if (dbEmulatorHost) {
          isEmulator = true;
          dbUrl = "http://" + dbEmulatorHost + "?ns=" + repoInfo.namespace;
          parsedUrl = parseRepoInfo(dbUrl, nodeAdmin);
          repoInfo = parsedUrl.repoInfo;
      }
      else {
          isEmulator = !parsedUrl.repoInfo.secure;
      }
      var authTokenProvider = nodeAdmin && isEmulator
          ? new EmulatorTokenProvider(EmulatorTokenProvider.OWNER)
          : new FirebaseAuthTokenProvider(app.name, app.options, authProvider);
      validateUrl('Invalid Firebase Database URL', parsedUrl);
      if (!pathIsEmpty(parsedUrl.path)) {
          fatal('Database URL must point to the root of a Firebase Database ' +
              '(not including a child path).');
      }
      var repo = repoManagerCreateRepo(repoInfo, app, authTokenProvider, new AppCheckTokenProvider(app.name, appCheckProvider));
      return new Database(repo, app);
  }
  /**
   * Remove the repo and make sure it is disconnected.
   *
   */
  function repoManagerDeleteRepo(repo, appName) {
      var appRepos = repos[appName];
      // This should never happen...
      if (!appRepos || appRepos[repo.key] !== repo) {
          fatal("Database " + appName + "(" + repo.repoInfo_ + ") has already been deleted.");
      }
      repoInterrupt(repo);
      delete appRepos[repo.key];
  }
  /**
   * Ensures a repo doesn't already exist and then creates one using the
   * provided app.
   *
   * @param repoInfo - The metadata about the Repo
   * @returns The Repo object for the specified server / repoName.
   */
  function repoManagerCreateRepo(repoInfo, app, authTokenProvider, appCheckProvider) {
      var appRepos = repos[app.name];
      if (!appRepos) {
          appRepos = {};
          repos[app.name] = appRepos;
      }
      var repo = appRepos[repoInfo.toURLString()];
      if (repo) {
          fatal('Database initialized multiple times. Please make sure the format of the database URL matches with each database() call.');
      }
      repo = new Repo(repoInfo, useRestClient, authTokenProvider, appCheckProvider);
      appRepos[repoInfo.toURLString()] = repo;
      return repo;
  }
  /**
   * Forces us to use ReadonlyRestClient instead of PersistentConnection for new Repos.
   */
  function repoManagerForceRestClient(forceRestClient) {
      useRestClient = forceRestClient;
  }
  /**
   * Class representing a Firebase Realtime Database.
   */
  var Database = /** @class */ (function () {
      /** @hideconstructor */
      function Database(_repoInternal, 
      /** The {@link @firebase/app#FirebaseApp} associated with this Realtime Database instance. */
      app) {
          this._repoInternal = _repoInternal;
          this.app = app;
          /** Represents a `Database` instance. */
          this['type'] = 'database';
          /** Track if the instance has been used (root or repo accessed) */
          this._instanceStarted = false;
      }
      Object.defineProperty(Database.prototype, "_repo", {
          get: function () {
              if (!this._instanceStarted) {
                  repoStart(this._repoInternal, this.app.options.appId, this.app.options['databaseAuthVariableOverride']);
                  this._instanceStarted = true;
              }
              return this._repoInternal;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Database.prototype, "_root", {
          get: function () {
              if (!this._rootInternal) {
                  this._rootInternal = new ReferenceImpl(this._repo, newEmptyPath());
              }
              return this._rootInternal;
          },
          enumerable: false,
          configurable: true
      });
      Database.prototype._delete = function () {
          if (this._rootInternal !== null) {
              repoManagerDeleteRepo(this._repo, this.app.name);
              this._repoInternal = null;
              this._rootInternal = null;
          }
          return Promise.resolve();
      };
      Database.prototype._checkNotDeleted = function (apiName) {
          if (this._rootInternal === null) {
              fatal('Cannot call ' + apiName + ' on a deleted database.');
          }
      };
      return Database;
  }());
  /**
   * Returns the instance of the Realtime Database SDK that is associated
   * with the provided {@link @firebase/app#FirebaseApp}. Initializes a new instance with
   * with default settings if no instance exists or if the existing instance uses
   * a custom database URL.
   *
   * @param app - The {@link @firebase/app#FirebaseApp} instance that the returned Realtime
   * Database instance is associated with.
   * @param url - The URL of the Realtime Database instance to connect to. If not
   * provided, the SDK connects to the default instance of the Firebase App.
   * @returns The `Database` instance of the provided app.
   */
  function getDatabase(app$1, url) {
      if (app$1 === void 0) { app$1 = app.getApp(); }
      return app._getProvider(app$1, 'database').getImmediate({
          identifier: url
      });
  }
  /**
   * Modify the provided instance to communicate with the Realtime Database
   * emulator.
   *
   * <p>Note: This method must be called before performing any other operation.
   *
   * @param db - The instance to modify.
   * @param host - The emulator host (ex: localhost)
   * @param port - The emulator port (ex: 8080)
   * @param options.mockUserToken - the mock auth token to use for unit testing Security Rules
   */
  function connectDatabaseEmulator(db, host, port, options) {
      if (options === void 0) { options = {}; }
      db = util.getModularInstance(db);
      db._checkNotDeleted('useEmulator');
      if (db._instanceStarted) {
          fatal('Cannot call useEmulator() after instance has already been initialized.');
      }
      var repo = db._repoInternal;
      var tokenProvider = undefined;
      if (repo.repoInfo_.nodeAdmin) {
          if (options.mockUserToken) {
              fatal('mockUserToken is not supported by the Admin SDK. For client access with mock users, please use the "firebase" package instead of "firebase-admin".');
          }
          tokenProvider = new EmulatorTokenProvider(EmulatorTokenProvider.OWNER);
      }
      else if (options.mockUserToken) {
          var token = typeof options.mockUserToken === 'string'
              ? options.mockUserToken
              : util.createMockUserToken(options.mockUserToken, db.app.options.projectId);
          tokenProvider = new EmulatorTokenProvider(token);
      }
      // Modify the repo to apply emulator settings
      repoManagerApplyEmulatorSettings(repo, host, port, tokenProvider);
  }
  /**
   * Disconnects from the server (all Database operations will be completed
   * offline).
   *
   * The client automatically maintains a persistent connection to the Database
   * server, which will remain active indefinitely and reconnect when
   * disconnected. However, the `goOffline()` and `goOnline()` methods may be used
   * to control the client connection in cases where a persistent connection is
   * undesirable.
   *
   * While offline, the client will no longer receive data updates from the
   * Database. However, all Database operations performed locally will continue to
   * immediately fire events, allowing your application to continue behaving
   * normally. Additionally, each operation performed locally will automatically
   * be queued and retried upon reconnection to the Database server.
   *
   * To reconnect to the Database and begin receiving remote events, see
   * `goOnline()`.
   *
   * @param db - The instance to disconnect.
   */
  function goOffline(db) {
      db = util.getModularInstance(db);
      db._checkNotDeleted('goOffline');
      repoInterrupt(db._repo);
  }
  /**
   * Reconnects to the server and synchronizes the offline Database state
   * with the server state.
   *
   * This method should be used after disabling the active connection with
   * `goOffline()`. Once reconnected, the client will transmit the proper data
   * and fire the appropriate events so that your client "catches up"
   * automatically.
   *
   * @param db - The instance to reconnect.
   */
  function goOnline(db) {
      db = util.getModularInstance(db);
      db._checkNotDeleted('goOnline');
      repoResume(db._repo);
  }
  function enableLogging(logger, persistent) {
      enableLogging$1(logger, persistent);
  }
  
  /**
   * @license
   * Copyright 2021 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function registerDatabase(variant) {
      setSDKVersion(app.SDK_VERSION);
      app._registerComponent(new component.Component('database', function (container, _a) {
          var url = _a.instanceIdentifier;
          var app = container.getProvider('app').getImmediate();
          var authProvider = container.getProvider('auth-internal');
          var appCheckProvider = container.getProvider('app-check-internal');
          return repoManagerDatabaseFromApp(app, authProvider, appCheckProvider, url);
      }, "PUBLIC" /* PUBLIC */).setMultipleInstances(true));
      app.registerVersion(name, version, variant);
      // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
      app.registerVersion(name, version, 'cjs5');
  }
  
  /**
   * @license
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  var SERVER_TIMESTAMP = {
      '.sv': 'timestamp'
  };
  /**
   * Returns a placeholder value for auto-populating the current timestamp (time
   * since the Unix epoch, in milliseconds) as determined by the Firebase
   * servers.
   */
  function serverTimestamp() {
      return SERVER_TIMESTAMP;
  }
  /**
   * Returns a placeholder value that can be used to atomically increment the
   * current database value by the provided delta.
   *
   * @param delta - the amount to modify the current value atomically.
   * @returns A placeholder value for modifying data atomically server-side.
   */
  function increment(delta) {
      return {
          '.sv': {
              'increment': delta
          }
      };
  }
  
  /**
   * @license
   * Copyright 2020 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * A type for the resolve value of {@link runTransaction}.
   */
  var TransactionResult = /** @class */ (function () {
      /** @hideconstructor */
      function TransactionResult(
      /** Whether the transaction was successfully committed. */
      committed, 
      /** The resulting data snapshot. */
      snapshot) {
          this.committed = committed;
          this.snapshot = snapshot;
      }
      /** Returns a JSON-serializable representation of this object. */
      TransactionResult.prototype.toJSON = function () {
          return { committed: this.committed, snapshot: this.snapshot.toJSON() };
      };
      return TransactionResult;
  }());
  /**
   * Atomically modifies the data at this location.
   *
   * Atomically modify the data at this location. Unlike a normal `set()`, which
   * just overwrites the data regardless of its previous value, `runTransaction()` is
   * used to modify the existing value to a new value, ensuring there are no
   * conflicts with other clients writing to the same location at the same time.
   *
   * To accomplish this, you pass `runTransaction()` an update function which is
   * used to transform the current value into a new value. If another client
   * writes to the location before your new value is successfully written, your
   * update function will be called again with the new current value, and the
   * write will be retried. This will happen repeatedly until your write succeeds
   * without conflict or you abort the transaction by not returning a value from
   * your update function.
   *
   * Note: Modifying data with `set()` will cancel any pending transactions at
   * that location, so extreme care should be taken if mixing `set()` and
   * `runTransaction()` to update the same data.
   *
   * Note: When using transactions with Security and Firebase Rules in place, be
   * aware that a client needs `.read` access in addition to `.write` access in
   * order to perform a transaction. This is because the client-side nature of
   * transactions requires the client to read the data in order to transactionally
   * update it.
   *
   * @param ref - The location to atomically modify.
   * @param transactionUpdate - A developer-supplied function which will be passed
   * the current data stored at this location (as a JavaScript object). The
   * function should return the new value it would like written (as a JavaScript
   * object). If `undefined` is returned (i.e. you return with no arguments) the
   * transaction will be aborted and the data at this location will not be
   * modified.
   * @param options - An options object to configure transactions.
   * @returns A `Promise` that can optionally be used instead of the `onComplete`
   * callback to handle success and failure.
   */
  function runTransaction(ref, 
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  transactionUpdate, options) {
      var _a;
      ref = util.getModularInstance(ref);
      validateWritablePath('Reference.transaction', ref._path);
      if (ref.key === '.length' || ref.key === '.keys') {
          throw ('Reference.transaction failed: ' + ref.key + ' is a read-only object.');
      }
      var applyLocally = (_a = options === null || options === void 0 ? void 0 : options.applyLocally) !== null && _a !== void 0 ? _a : true;
      var deferred = new util.Deferred();
      var promiseComplete = function (error, committed, node) {
          var dataSnapshot = null;
          if (error) {
              deferred.reject(error);
          }
          else {
              dataSnapshot = new DataSnapshot(node, new ReferenceImpl(ref._repo, ref._path), PRIORITY_INDEX);
              deferred.resolve(new TransactionResult(committed, dataSnapshot));
          }
      };
      // Add a watch to make sure we get server updates.
      var unwatcher = onValue(ref, function () { });
      repoStartTransaction(ref._repo, ref._path, transactionUpdate, promiseComplete, unwatcher, applyLocally);
      return deferred.promise;
  }
  
  /**
   * @license
   * Copyright 2017 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  PersistentConnection.prototype.simpleListen = function (pathString, onComplete) {
      this.sendRequest('q', { p: pathString }, onComplete);
  };
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  PersistentConnection.prototype.echo = function (data, onEcho) {
      this.sendRequest('echo', { d: data }, onEcho);
  };
  /**
   * @internal
   */
  var hijackHash = function (newHash) {
      var oldPut = PersistentConnection.prototype.put;
      PersistentConnection.prototype.put = function (pathString, data, onComplete, hash) {
          if (hash !== undefined) {
              hash = newHash();
          }
          oldPut.call(this, pathString, data, onComplete, hash);
      };
      return function () {
          PersistentConnection.prototype.put = oldPut;
      };
  };
  /**
   * Forces the RepoManager to create Repos that use ReadonlyRestClient instead of PersistentConnection.
   * @internal
   */
  var forceRestClient = function (forceRestClient) {
      repoManagerForceRestClient(forceRestClient);
  };
  
  /**
   * @license
   * Copyright 2021 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  setWebSocketImpl(Websocket__default["default"].Client);
  registerDatabase('node');
  
  exports.DataSnapshot = DataSnapshot;
  exports.Database = Database;
  exports.OnDisconnect = OnDisconnect;
  exports.QueryConstraint = QueryConstraint;
  exports.TransactionResult = TransactionResult;
  exports._QueryImpl = QueryImpl;
  exports._QueryParams = QueryParams;
  exports._ReferenceImpl = ReferenceImpl;
  exports._TEST_ACCESS_forceRestClient = forceRestClient;
  exports._TEST_ACCESS_hijackHash = hijackHash;
  exports._repoManagerDatabaseFromApp = repoManagerDatabaseFromApp;
  exports._setSDKVersion = setSDKVersion;
  exports._validatePathString = validatePathString;
  exports._validateWritablePath = validateWritablePath;
  exports.child = child;
  exports.connectDatabaseEmulator = connectDatabaseEmulator;
  exports.enableLogging = enableLogging;
  exports.endAt = endAt;
  exports.endBefore = endBefore;
  exports.equalTo = equalTo;
  exports.get = get;
  exports.getDatabase = getDatabase;
  exports.goOffline = goOffline;
  exports.goOnline = goOnline;
  exports.increment = increment;
  exports.limitToFirst = limitToFirst;
  exports.limitToLast = limitToLast;
  exports.off = off;
  exports.onChildAdded = onChildAdded;
  exports.onChildChanged = onChildChanged;
  exports.onChildMoved = onChildMoved;
  exports.onChildRemoved = onChildRemoved;
  exports.onDisconnect = onDisconnect;
  exports.onValue = onValue;
  exports.orderByChild = orderByChild;
  exports.orderByKey = orderByKey;
  exports.orderByPriority = orderByPriority;
  exports.orderByValue = orderByValue;
  exports.push = push;
  exports.query = query;
  exports.ref = ref;
  exports.refFromURL = refFromURL;
  exports.remove = remove;
  exports.runTransaction = runTransaction;
  exports.serverTimestamp = serverTimestamp;
  exports.set = set;
  exports.setPriority = setPriority;
  exports.setWithPriority = setWithPriority;
  exports.startAfter = startAfter;
  exports.startAt = startAt;
  exports.update = update;
  //# sourceMappingURL=index.node.cjs.js.map
  