@firebase/database-compat 1.0.8 → 1.0.9-20241017211210

package/dist/index.js

@@ -4,15 +4,14 @@ var firebase = require('@firebase/app-compat');
 var component = require('@firebase/component');
 var database = require('@firebase/database');
 var util = require('@firebase/util');
-var tslib = require('tslib');
 var logger = require('@firebase/logger');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var firebase__default = /*#__PURE__*/_interopDefaultLegacy(firebase);
 
-var name = "@firebase/database-compat";
-var version = "1.0.8";
+const name = "@firebase/database-compat";
+const version = "1.0.9-20241017211210";
 
 /**
  * @license
@@ -30,9 +29,9 @@ var version = "1.0.8";
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var logClient = new logger.Logger('@firebase/database-compat');
-var warn = function (msg) {
-    var message = 'FIREBASE WARNING: ' + msg;
+const logClient = new logger.Logger('@firebase/database-compat');
+const warn = function (msg) {
+    const message = 'FIREBASE WARNING: ' + msg;
     logClient.warn(message);
 };
 
@@ -52,7 +51,7 @@ var warn = function (msg) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var validateBoolean = function (fnName, argumentName, bool, optional) {
+const validateBoolean = function (fnName, argumentName, bool, optional) {
     if (optional && bool === undefined) {
         return;
     }
@@ -60,7 +59,7 @@ var validateBoolean = function (fnName, argumentName, bool, optional) {
         throw new Error(util.errorPrefix(fnName, argumentName) + 'must be a boolean.');
     }
 };
-var validateEventType = function (fnName, eventType, optional) {
+const validateEventType = function (fnName, eventType, optional) {
     if (optional && eventType === undefined) {
         return;
     }
@@ -94,51 +93,51 @@ var validateEventType = function (fnName, eventType, optional) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var OnDisconnect = /** @class */ (function () {
-    function OnDisconnect(_delegate) {
+class OnDisconnect {
+    constructor(_delegate) {
         this._delegate = _delegate;
     }
-    OnDisconnect.prototype.cancel = function (onComplete) {
+    cancel(onComplete) {
         util.validateArgCount('OnDisconnect.cancel', 0, 1, arguments.length);
         util.validateCallback('OnDisconnect.cancel', 'onComplete', onComplete, true);
-        var result = this._delegate.cancel();
+        const result = this._delegate.cancel();
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    OnDisconnect.prototype.remove = function (onComplete) {
+    }
+    remove(onComplete) {
         util.validateArgCount('OnDisconnect.remove', 0, 1, arguments.length);
         util.validateCallback('OnDisconnect.remove', 'onComplete', onComplete, true);
-        var result = this._delegate.remove();
+        const result = this._delegate.remove();
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    OnDisconnect.prototype.set = function (value, onComplete) {
+    }
+    set(value, onComplete) {
         util.validateArgCount('OnDisconnect.set', 1, 2, arguments.length);
         util.validateCallback('OnDisconnect.set', 'onComplete', onComplete, true);
-        var result = this._delegate.set(value);
+        const result = this._delegate.set(value);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    OnDisconnect.prototype.setWithPriority = function (value, priority, onComplete) {
+    }
+    setWithPriority(value, priority, onComplete) {
         util.validateArgCount('OnDisconnect.setWithPriority', 2, 3, arguments.length);
         util.validateCallback('OnDisconnect.setWithPriority', 'onComplete', onComplete, true);
-        var result = this._delegate.setWithPriority(value, priority);
+        const result = this._delegate.setWithPriority(value, priority);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    OnDisconnect.prototype.update = function (objectToMerge, onComplete) {
+    }
+    update(objectToMerge, onComplete) {
         util.validateArgCount('OnDisconnect.update', 1, 2, arguments.length);
         if (Array.isArray(objectToMerge)) {
-            var newObjectToMerge = {};
-            for (var i = 0; i < objectToMerge.length; ++i) {
+            const newObjectToMerge = {};
+            for (let i = 0; i < objectToMerge.length; ++i) {
                 newObjectToMerge['' + i] = objectToMerge[i];
             }
             objectToMerge = newObjectToMerge;
@@ -146,14 +145,13 @@ var OnDisconnect = /** @class */ (function () {
                 'existing data, or an Object with integer keys if you really do want to only update some of the children.');
         }
         util.validateCallback('OnDisconnect.update', 'onComplete', onComplete, true);
-        var result = this._delegate.update(objectToMerge);
+        const result = this._delegate.update(objectToMerge);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    return OnDisconnect;
-}());
+    }
+}
 
 /**
  * @license
@@ -171,22 +169,21 @@ var OnDisconnect = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var TransactionResult = /** @class */ (function () {
+class TransactionResult {
     /**
      * A type for the resolve value of Firebase.transaction.
      */
-    function TransactionResult(committed, snapshot) {
+    constructor(committed, snapshot) {
         this.committed = committed;
         this.snapshot = snapshot;
     }
     // Do not create public documentation. This is intended to make JSON serialization work but is otherwise unnecessary
     // for end-users
-    TransactionResult.prototype.toJSON = function () {
+    toJSON() {
         util.validateArgCount('TransactionResult.toJSON', 0, 1, arguments.length);
         return { committed: this.committed, snapshot: this.snapshot.toJSON() };
-    };
-    return TransactionResult;
-}());
+    }
+}
 
 /**
  * @license
@@ -208,8 +205,8 @@ var TransactionResult = /** @class */ (function () {
  * Class representing a firebase data snapshot.  It wraps a SnapshotNode and
  * surfaces the public methods (val, forEach, etc.) we want to expose.
  */
-var DataSnapshot = /** @class */ (function () {
-    function DataSnapshot(_database, _delegate) {
+class DataSnapshot {
+    constructor(_database, _delegate) {
         this._database = _database;
         this._delegate = _delegate;
     }
@@ -219,68 +216,68 @@ var DataSnapshot = /** @class */ (function () {
      *
      * @returns JSON representation of the DataSnapshot contents, or null if empty.
      */
-    DataSnapshot.prototype.val = function () {
+    val() {
         util.validateArgCount('DataSnapshot.val', 0, 0, arguments.length);
         return this._delegate.val();
-    };
+    }
     /**
      * Returns the snapshot contents as JSON, including priorities of node.  Suitable for exporting
      * the entire node contents.
      * @returns JSON representation of the DataSnapshot contents, or null if empty.
      */
-    DataSnapshot.prototype.exportVal = function () {
+    exportVal() {
         util.validateArgCount('DataSnapshot.exportVal', 0, 0, arguments.length);
         return this._delegate.exportVal();
-    };
+    }
     // Do not create public documentation. This is intended to make JSON serialization work but is otherwise unnecessary
     // for end-users
-    DataSnapshot.prototype.toJSON = function () {
+    toJSON() {
         // Optional spacer argument is unnecessary because we're depending on recursion rather than stringifying the content
         util.validateArgCount('DataSnapshot.toJSON', 0, 1, arguments.length);
         return this._delegate.toJSON();
-    };
+    }
     /**
      * Returns whether the snapshot contains a non-null value.
      *
      * @returns Whether the snapshot contains a non-null value, or is empty.
      */
-    DataSnapshot.prototype.exists = function () {
+    exists() {
         util.validateArgCount('DataSnapshot.exists', 0, 0, arguments.length);
         return this._delegate.exists();
-    };
+    }
     /**
      * Returns a DataSnapshot of the specified child node's contents.
      *
      * @param path - Path to a child.
      * @returns DataSnapshot for child node.
      */
-    DataSnapshot.prototype.child = function (path) {
+    child(path) {
         util.validateArgCount('DataSnapshot.child', 0, 1, arguments.length);
         // Ensure the childPath is a string (can be a number)
         path = String(path);
         database._validatePathString('DataSnapshot.child', 'path', path, false);
         return new DataSnapshot(this._database, this._delegate.child(path));
-    };
+    }
     /**
      * Returns whether the snapshot contains a child at the specified path.
      *
      * @param path - Path to a child.
      * @returns Whether the child exists.
      */
-    DataSnapshot.prototype.hasChild = function (path) {
+    hasChild(path) {
         util.validateArgCount('DataSnapshot.hasChild', 1, 1, arguments.length);
         database._validatePathString('DataSnapshot.hasChild', 'path', path, false);
         return this._delegate.hasChild(path);
-    };
+    }
     /**
      * Returns the priority of the object, or null if no priority was set.
      *
      * @returns The priority.
      */
-    DataSnapshot.prototype.getPriority = function () {
+    getPriority() {
         util.validateArgCount('DataSnapshot.getPriority', 0, 0, arguments.length);
         return this._delegate.priority;
-    };
+    }
     /**
      * Iterates through child nodes and calls the specified action for each one.
      *
@@ -289,77 +286,64 @@ var DataSnapshot = /** @class */ (function () {
      * @returns True if forEach was canceled by action returning true for
      * one of the child nodes.
      */
-    DataSnapshot.prototype.forEach = function (action) {
-        var _this = this;
+    forEach(action) {
         util.validateArgCount('DataSnapshot.forEach', 1, 1, arguments.length);
         util.validateCallback('DataSnapshot.forEach', 'action', action, false);
-        return this._delegate.forEach(function (expDataSnapshot) {
-            return action(new DataSnapshot(_this._database, expDataSnapshot));
-        });
-    };
+        return this._delegate.forEach(expDataSnapshot => action(new DataSnapshot(this._database, expDataSnapshot)));
+    }
     /**
      * Returns whether this DataSnapshot has children.
      * @returns True if the DataSnapshot contains 1 or more child nodes.
      */
-    DataSnapshot.prototype.hasChildren = function () {
+    hasChildren() {
         util.validateArgCount('DataSnapshot.hasChildren', 0, 0, arguments.length);
         return this._delegate.hasChildren();
-    };
-    Object.defineProperty(DataSnapshot.prototype, "key", {
-        get: function () {
-            return this._delegate.key;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    get key() {
+        return this._delegate.key;
+    }
     /**
      * Returns the number of children for this DataSnapshot.
      * @returns The number of children that this DataSnapshot contains.
      */
-    DataSnapshot.prototype.numChildren = function () {
+    numChildren() {
         util.validateArgCount('DataSnapshot.numChildren', 0, 0, arguments.length);
         return this._delegate.size;
-    };
+    }
     /**
      * @returns The Firebase reference for the location this snapshot's data came
      * from.
      */
-    DataSnapshot.prototype.getRef = function () {
+    getRef() {
         util.validateArgCount('DataSnapshot.ref', 0, 0, arguments.length);
         return new Reference(this._database, this._delegate.ref);
-    };
-    Object.defineProperty(DataSnapshot.prototype, "ref", {
-        get: function () {
-            return this.getRef();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return DataSnapshot;
-}());
+    }
+    get ref() {
+        return this.getRef();
+    }
+}
 /**
  * A Query represents a filter to be applied to a firebase location.  This object purely represents the
  * query expression (and exposes our public API to build the query).  The actual query logic is in ViewBase.js.
  *
  * Since every Firebase reference is a query, Firebase inherits from this object.
  */
-var Query = /** @class */ (function () {
-    function Query(database, _delegate) {
+class Query {
+    constructor(database, _delegate) {
         this.database = database;
         this._delegate = _delegate;
     }
-    Query.prototype.on = function (eventType, callback, cancelCallbackOrContext, context) {
-        var _this = this;
+    on(eventType, callback, cancelCallbackOrContext, context) {
         var _a;
         util.validateArgCount('Query.on', 2, 4, arguments.length);
         util.validateCallback('Query.on', 'callback', callback, false);
-        var ret = Query.getCancelAndContextArgs_('Query.on', cancelCallbackOrContext, context);
-        var valueCallback = function (expSnapshot, previousChildName) {
-            callback.call(ret.context, new DataSnapshot(_this.database, expSnapshot), previousChildName);
+        const ret = Query.getCancelAndContextArgs_('Query.on', cancelCallbackOrContext, context);
+        const valueCallback = (expSnapshot, previousChildName) => {
+            callback.call(ret.context, new DataSnapshot(this.database, expSnapshot), previousChildName);
         };
         valueCallback.userCallback = callback;
         valueCallback.context = ret.context;
-        var cancelCallback = (_a = ret.cancel) === null || _a === void 0 ? void 0 : _a.bind(ret.context);
+        const cancelCallback = (_a = ret.cancel) === null || _a === void 0 ? void 0 : _a.bind(ret.context);
         switch (eventType) {
             case 'value':
                 database.onValue(this._delegate, valueCallback, cancelCallback);
@@ -381,14 +365,14 @@ var Query = /** @class */ (function () {
                     'must be a valid event type = "value", "child_added", "child_removed", ' +
                     '"child_changed", or "child_moved".');
         }
-    };
-    Query.prototype.off = function (eventType, callback, context) {
+    }
+    off(eventType, callback, context) {
         util.validateArgCount('Query.off', 0, 3, arguments.length);
         validateEventType('Query.off', eventType, true);
         util.validateCallback('Query.off', 'callback', callback, true);
         util.validateContextObject('Query.off', 'context', context, true);
         if (callback) {
-            var valueCallback = function () { };
+            const valueCallback = () => { };
             valueCallback.userCallback = callback;
             valueCallback.context = context;
             database.off(this._delegate, eventType, valueCallback);
@@ -396,27 +380,25 @@ var Query = /** @class */ (function () {
         else {
             database.off(this._delegate, eventType);
         }
-    };
+    }
     /**
      * Get the server-value for this query, or return a cached value if not connected.
      */
-    Query.prototype.get = function () {
-        var _this = this;
-        return database.get(this._delegate).then(function (expSnapshot) {
-            return new DataSnapshot(_this.database, expSnapshot);
+    get() {
+        return database.get(this._delegate).then(expSnapshot => {
+            return new DataSnapshot(this.database, expSnapshot);
         });
-    };
+    }
     /**
      * Attaches a listener, waits for the first event, and then removes the listener
      */
-    Query.prototype.once = function (eventType, callback, failureCallbackOrContext, context) {
-        var _this = this;
+    once(eventType, callback, failureCallbackOrContext, context) {
         util.validateArgCount('Query.once', 1, 4, arguments.length);
         util.validateCallback('Query.once', 'callback', callback, true);
-        var ret = Query.getCancelAndContextArgs_('Query.once', failureCallbackOrContext, context);
-        var deferred = new util.Deferred();
-        var valueCallback = function (expSnapshot, previousChildName) {
-            var result = new DataSnapshot(_this.database, expSnapshot);
+        const ret = Query.getCancelAndContextArgs_('Query.once', failureCallbackOrContext, context);
+        const deferred = new util.Deferred();
+        const valueCallback = (expSnapshot, previousChildName) => {
+            const result = new DataSnapshot(this.database, expSnapshot);
             if (callback) {
                 callback.call(ret.context, result, previousChildName);
             }
@@ -424,7 +406,7 @@ var Query = /** @class */ (function () {
         };
         valueCallback.userCallback = callback;
         valueCallback.context = ret.context;
-        var cancelCallback = function (error) {
+        const cancelCallback = (error) => {
             if (ret.cancel) {
                 ret.cancel.call(ret.context, error);
             }
@@ -462,109 +444,105 @@ var Query = /** @class */ (function () {
                     '"child_changed", or "child_moved".');
         }
         return deferred.promise;
-    };
+    }
     /**
      * Set a limit and anchor it to the start of the window.
      */
-    Query.prototype.limitToFirst = function (limit) {
+    limitToFirst(limit) {
         util.validateArgCount('Query.limitToFirst', 1, 1, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.limitToFirst(limit)));
-    };
+    }
     /**
      * Set a limit and anchor it to the end of the window.
      */
-    Query.prototype.limitToLast = function (limit) {
+    limitToLast(limit) {
         util.validateArgCount('Query.limitToLast', 1, 1, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.limitToLast(limit)));
-    };
+    }
     /**
      * Given a child path, return a new query ordered by the specified grandchild path.
      */
-    Query.prototype.orderByChild = function (path) {
+    orderByChild(path) {
         util.validateArgCount('Query.orderByChild', 1, 1, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.orderByChild(path)));
-    };
+    }
     /**
      * Return a new query ordered by the KeyIndex
      */
-    Query.prototype.orderByKey = function () {
+    orderByKey() {
         util.validateArgCount('Query.orderByKey', 0, 0, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.orderByKey()));
-    };
+    }
     /**
      * Return a new query ordered by the PriorityIndex
      */
-    Query.prototype.orderByPriority = function () {
+    orderByPriority() {
         util.validateArgCount('Query.orderByPriority', 0, 0, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.orderByPriority()));
-    };
+    }
     /**
      * Return a new query ordered by the ValueIndex
      */
-    Query.prototype.orderByValue = function () {
+    orderByValue() {
         util.validateArgCount('Query.orderByValue', 0, 0, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.orderByValue()));
-    };
-    Query.prototype.startAt = function (value, name) {
-        if (value === void 0) { value = null; }
+    }
+    startAt(value = null, name) {
         util.validateArgCount('Query.startAt', 0, 2, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.startAt(value, name)));
-    };
-    Query.prototype.startAfter = function (value, name) {
-        if (value === void 0) { value = null; }
+    }
+    startAfter(value = null, name) {
         util.validateArgCount('Query.startAfter', 0, 2, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.startAfter(value, name)));
-    };
-    Query.prototype.endAt = function (value, name) {
-        if (value === void 0) { value = null; }
+    }
+    endAt(value = null, name) {
         util.validateArgCount('Query.endAt', 0, 2, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.endAt(value, name)));
-    };
-    Query.prototype.endBefore = function (value, name) {
-        if (value === void 0) { value = null; }
+    }
+    endBefore(value = null, name) {
         util.validateArgCount('Query.endBefore', 0, 2, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.endBefore(value, name)));
-    };
+    }
     /**
      * Load the selection of children with exactly the specified value, and, optionally,
      * the specified name.
      */
-    Query.prototype.equalTo = function (value, name) {
+    equalTo(value, name) {
         util.validateArgCount('Query.equalTo', 1, 2, arguments.length);
         return new Query(this.database, database.query(this._delegate, database.equalTo(value, name)));
-    };
+    }
     /**
      * @returns URL for this location.
      */
-    Query.prototype.toString = function () {
+    toString() {
         util.validateArgCount('Query.toString', 0, 0, arguments.length);
         return this._delegate.toString();
-    };
+    }
     // Do not create public documentation. This is intended to make JSON serialization work but is otherwise unnecessary
     // for end-users.
-    Query.prototype.toJSON = function () {
+    toJSON() {
         // An optional spacer argument is unnecessary for a string.
         util.validateArgCount('Query.toJSON', 0, 1, arguments.length);
         return this._delegate.toJSON();
-    };
+    }
     /**
      * Return true if this query and the provided query are equivalent; otherwise, return false.
      */
-    Query.prototype.isEqual = function (other) {
+    isEqual(other) {
         util.validateArgCount('Query.isEqual', 1, 1, arguments.length);
         if (!(other instanceof Query)) {
-            var error = 'Query.isEqual failed: First argument must be an instance of firebase.database.Query.';
+            const error = 'Query.isEqual failed: First argument must be an instance of firebase.database.Query.';
             throw new Error(error);
         }
         return this._delegate.isEqual(other._delegate);
-    };
+    }
     /**
      * Helper used by .on and .once to extract the context and or cancel arguments.
      * @param fnName - The function name (on or once)
      *
      */
-    Query.getCancelAndContextArgs_ = function (fnName, cancelOrContext, context) {
-        var ret = { cancel: undefined, context: undefined };
+    static getCancelAndContextArgs_(fnName, cancelOrContext, context) {
+        const ret = { cancel: undefined, context: undefined };
         if (cancelOrContext && context) {
             ret.cancel = cancelOrContext;
             util.validateCallback(fnName, 'cancel', ret.cancel, true);
@@ -586,18 +564,12 @@ var Query = /** @class */ (function () {
             }
         }
         return ret;
-    };
-    Object.defineProperty(Query.prototype, "ref", {
-        get: function () {
-            return new Reference(this.database, new database._ReferenceImpl(this._delegate._repo, this._delegate._path));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Query;
-}());
-var Reference = /** @class */ (function (_super) {
-    tslib.__extends(Reference, _super);
+    }
+    get ref() {
+        return new Reference(this.database, new database._ReferenceImpl(this._delegate._repo, this._delegate._path));
+    }
+}
+class Reference extends Query {
     /**
      * Call options:
      *   new Reference(Repo, Path) or
@@ -605,49 +577,48 @@ var Reference = /** @class */ (function (_super) {
      *
      * Externally - this is the firebase.database.Reference type.
      */
-    function Reference(database$1, _delegate) {
-        var _this = _super.call(this, database$1, new database._QueryImpl(_delegate._repo, _delegate._path, new database._QueryParams(), false)) || this;
-        _this.database = database$1;
-        _this._delegate = _delegate;
-        return _this;
+    constructor(database$1, _delegate) {
+        super(database$1, new database._QueryImpl(_delegate._repo, _delegate._path, new database._QueryParams(), false));
+        this.database = database$1;
+        this._delegate = _delegate;
     }
     /** @returns {?string} */
-    Reference.prototype.getKey = function () {
+    getKey() {
         util.validateArgCount('Reference.key', 0, 0, arguments.length);
         return this._delegate.key;
-    };
-    Reference.prototype.child = function (pathString) {
+    }
+    child(pathString) {
         util.validateArgCount('Reference.child', 1, 1, arguments.length);
         if (typeof pathString === 'number') {
             pathString = String(pathString);
         }
         return new Reference(this.database, database.child(this._delegate, pathString));
-    };
+    }
     /** @returns {?Reference} */
-    Reference.prototype.getParent = function () {
+    getParent() {
         util.validateArgCount('Reference.parent', 0, 0, arguments.length);
-        var parent = this._delegate.parent;
+        const parent = this._delegate.parent;
         return parent ? new Reference(this.database, parent) : null;
-    };
+    }
     /** @returns {!Reference} */
-    Reference.prototype.getRoot = function () {
+    getRoot() {
         util.validateArgCount('Reference.root', 0, 0, arguments.length);
         return new Reference(this.database, this._delegate.root);
-    };
-    Reference.prototype.set = function (newVal, onComplete) {
+    }
+    set(newVal, onComplete) {
         util.validateArgCount('Reference.set', 1, 2, arguments.length);
         util.validateCallback('Reference.set', 'onComplete', onComplete, true);
-        var result = database.set(this._delegate, newVal);
+        const result = database.set(this._delegate, newVal);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    Reference.prototype.update = function (values, onComplete) {
+    }
+    update(values, onComplete) {
         util.validateArgCount('Reference.update', 1, 2, arguments.length);
         if (Array.isArray(values)) {
-            var newObjectToMerge = {};
-            for (var i = 0; i < values.length; ++i) {
+            const newObjectToMerge = {};
+            for (let i = 0; i < values.length; ++i) {
                 newObjectToMerge['' + i] = values[i];
             }
             values = newObjectToMerge;
@@ -658,98 +629,79 @@ var Reference = /** @class */ (function (_super) {
         }
         database._validateWritablePath('Reference.update', this._delegate._path);
         util.validateCallback('Reference.update', 'onComplete', onComplete, true);
-        var result = database.update(this._delegate, values);
+        const result = database.update(this._delegate, values);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    Reference.prototype.setWithPriority = function (newVal, newPriority, onComplete) {
+    }
+    setWithPriority(newVal, newPriority, onComplete) {
         util.validateArgCount('Reference.setWithPriority', 2, 3, arguments.length);
         util.validateCallback('Reference.setWithPriority', 'onComplete', onComplete, true);
-        var result = database.setWithPriority(this._delegate, newVal, newPriority);
+        const result = database.setWithPriority(this._delegate, newVal, newPriority);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    Reference.prototype.remove = function (onComplete) {
+    }
+    remove(onComplete) {
         util.validateArgCount('Reference.remove', 0, 1, arguments.length);
         util.validateCallback('Reference.remove', 'onComplete', onComplete, true);
-        var result = database.remove(this._delegate);
+        const result = database.remove(this._delegate);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    Reference.prototype.transaction = function (transactionUpdate, onComplete, applyLocally) {
-        var _this = this;
+    }
+    transaction(transactionUpdate, onComplete, applyLocally) {
         util.validateArgCount('Reference.transaction', 1, 3, arguments.length);
         util.validateCallback('Reference.transaction', 'transactionUpdate', transactionUpdate, false);
         util.validateCallback('Reference.transaction', 'onComplete', onComplete, true);
         validateBoolean('Reference.transaction', 'applyLocally', applyLocally, true);
-        var result = database.runTransaction(this._delegate, transactionUpdate, {
-            applyLocally: applyLocally
-        }).then(function (transactionResult) {
-            return new TransactionResult(transactionResult.committed, new DataSnapshot(_this.database, transactionResult.snapshot));
-        });
+        const result = database.runTransaction(this._delegate, transactionUpdate, {
+            applyLocally
+        }).then(transactionResult => new TransactionResult(transactionResult.committed, new DataSnapshot(this.database, transactionResult.snapshot)));
         if (onComplete) {
-            result.then(function (transactionResult) {
-                return onComplete(null, transactionResult.committed, transactionResult.snapshot);
-            }, function (error) { return onComplete(error, false, null); });
+            result.then(transactionResult => onComplete(null, transactionResult.committed, transactionResult.snapshot), error => onComplete(error, false, null));
         }
         return result;
-    };
-    Reference.prototype.setPriority = function (priority, onComplete) {
+    }
+    setPriority(priority, onComplete) {
         util.validateArgCount('Reference.setPriority', 1, 2, arguments.length);
         util.validateCallback('Reference.setPriority', 'onComplete', onComplete, true);
-        var result = database.setPriority(this._delegate, priority);
+        const result = database.setPriority(this._delegate, priority);
         if (onComplete) {
-            result.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            result.then(() => onComplete(null), error => onComplete(error));
         }
         return result;
-    };
-    Reference.prototype.push = function (value, onComplete) {
-        var _this = this;
+    }
+    push(value, onComplete) {
         util.validateArgCount('Reference.push', 0, 2, arguments.length);
         util.validateCallback('Reference.push', 'onComplete', onComplete, true);
-        var expPromise = database.push(this._delegate, value);
-        var promise = expPromise.then(function (expRef) { return new Reference(_this.database, expRef); });
+        const expPromise = database.push(this._delegate, value);
+        const promise = expPromise.then(expRef => new Reference(this.database, expRef));
         if (onComplete) {
-            promise.then(function () { return onComplete(null); }, function (error) { return onComplete(error); });
+            promise.then(() => onComplete(null), error => onComplete(error));
         }
-        var result = new Reference(this.database, expPromise);
+        const result = new Reference(this.database, expPromise);
         result.then = promise.then.bind(promise);
         result.catch = promise.catch.bind(promise, undefined);
         return result;
-    };
-    Reference.prototype.onDisconnect = function () {
+    }
+    onDisconnect() {
         database._validateWritablePath('Reference.onDisconnect', this._delegate._path);
         return new OnDisconnect(new database.OnDisconnect(this._delegate._repo, this._delegate._path));
-    };
-    Object.defineProperty(Reference.prototype, "key", {
-        get: function () {
-            return this.getKey();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Reference.prototype, "parent", {
-        get: function () {
-            return this.getParent();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Reference.prototype, "root", {
-        get: function () {
-            return this.getRoot();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Reference;
-}(Query));
+    }
+    get key() {
+        return this.getKey();
+    }
+    get parent() {
+        return this.getParent();
+    }
+    get root() {
+        return this.getRoot();
+    }
+}
 
 /**
  * @license
@@ -770,16 +722,15 @@ var Reference = /** @class */ (function (_super) {
 /**
  * Class representing a firebase database.
  */
-var Database = /** @class */ (function () {
+class Database {
     /**
      * The constructor should not be called by users of our public API.
      */
-    function Database(_delegate, app) {
-        var _this = this;
+    constructor(_delegate, app) {
         this._delegate = _delegate;
         this.app = app;
         this.INTERNAL = {
-            delete: function () { return _this._delegate._delete(); },
+            delete: () => this._delegate._delete(),
             forceWebSockets: database.forceWebSockets,
             forceLongPolling: database.forceLongPolling
         };
@@ -793,48 +744,46 @@ var Database = /** @class */ (function () {
      * @param port - the emulator port (ex: 8080)
      * @param options.mockUserToken - the mock auth token to use for unit testing Security Rules
      */
-    Database.prototype.useEmulator = function (host, port, options) {
-        if (options === void 0) { options = {}; }
+    useEmulator(host, port, options = {}) {
         database.connectDatabaseEmulator(this._delegate, host, port, options);
-    };
-    Database.prototype.ref = function (path) {
+    }
+    ref(path) {
         util.validateArgCount('database.ref', 0, 1, arguments.length);
         if (path instanceof Reference) {
-            var childRef = database.refFromURL(this._delegate, path.toString());
+            const childRef = database.refFromURL(this._delegate, path.toString());
             return new Reference(this, childRef);
         }
         else {
-            var childRef = database.ref(this._delegate, path);
+            const childRef = database.ref(this._delegate, path);
             return new Reference(this, childRef);
         }
-    };
+    }
     /**
      * Returns a reference to the root or the path specified in url.
      * We throw a exception if the url is not in the same domain as the
      * current repo.
      * @returns Firebase reference.
      */
-    Database.prototype.refFromURL = function (url) {
-        var apiName = 'database.refFromURL';
+    refFromURL(url) {
+        const apiName = 'database.refFromURL';
         util.validateArgCount(apiName, 1, 1, arguments.length);
-        var childRef = database.refFromURL(this._delegate, url);
+        const childRef = database.refFromURL(this._delegate, url);
         return new Reference(this, childRef);
-    };
+    }
     // Make individual repo go offline.
-    Database.prototype.goOffline = function () {
+    goOffline() {
         util.validateArgCount('database.goOffline', 0, 0, arguments.length);
         return database.goOffline(this._delegate);
-    };
-    Database.prototype.goOnline = function () {
+    }
+    goOnline() {
         util.validateArgCount('database.goOnline', 0, 0, arguments.length);
         return database.goOnline(this._delegate);
-    };
-    Database.ServerValue = {
-        TIMESTAMP: database.serverTimestamp(),
-        increment: function (delta) { return database.increment(delta); }
-    };
-    return Database;
-}());
+    }
+}
+Database.ServerValue = {
+    TIMESTAMP: database.serverTimestamp(),
+    increment: (delta) => database.increment(delta)
+};
 
 /**
  * Used by console to create a database based on the app,
@@ -845,24 +794,23 @@ var Database = /** @class */ (function () {
  * @param version - custom version e.g. firebase-admin version
  * @param customAuthImpl - custom auth implementation
  */
-function initStandalone(_a) {
-    var app = _a.app, url = _a.url, version = _a.version, customAuthImpl = _a.customAuthImpl, customAppCheckImpl = _a.customAppCheckImpl, namespace = _a.namespace, _b = _a.nodeAdmin, nodeAdmin = _b === void 0 ? false : _b;
+function initStandalone({ app, url, version, customAuthImpl, customAppCheckImpl, namespace, nodeAdmin = false }) {
     database._setSDKVersion(version);
-    var container = new component.ComponentContainer('database-standalone');
+    const container = new component.ComponentContainer('database-standalone');
     /**
      * ComponentContainer('database-standalone') is just a placeholder that doesn't perform
      * any actual function.
      */
-    var authProvider = new component.Provider('auth-internal', container);
-    authProvider.setComponent(new component.Component('auth-internal', function () { return customAuthImpl; }, "PRIVATE" /* ComponentType.PRIVATE */));
-    var appCheckProvider = undefined;
+    const authProvider = new component.Provider('auth-internal', container);
+    authProvider.setComponent(new component.Component('auth-internal', () => customAuthImpl, "PRIVATE" /* ComponentType.PRIVATE */));
+    let appCheckProvider = undefined;
     if (customAppCheckImpl) {
         appCheckProvider = new component.Provider('app-check-internal', container);
-        appCheckProvider.setComponent(new component.Component('app-check-internal', function () { return customAppCheckImpl; }, "PRIVATE" /* ComponentType.PRIVATE */));
+        appCheckProvider.setComponent(new component.Component('app-check-internal', () => customAppCheckImpl, "PRIVATE" /* ComponentType.PRIVATE */));
     }
     return {
         instance: new Database(database._repoManagerDatabaseFromApp(app, authProvider, appCheckProvider, url, nodeAdmin), app),
-        namespace: namespace
+        namespace
     };
 }
 
@@ -887,15 +835,14 @@ var INTERNAL = /*#__PURE__*/Object.freeze({
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var ServerValue = Database.ServerValue;
+const ServerValue = Database.ServerValue;
 function registerDatabase(instance) {
     // Register the Database Service with the 'firebase' namespace.
-    instance.INTERNAL.registerComponent(new component.Component('database-compat', function (container, _a) {
-        var url = _a.instanceIdentifier;
+    instance.INTERNAL.registerComponent(new component.Component('database-compat', (container, { instanceIdentifier: url }) => {
         /* Dependencies */
         // getImmediate for FirebaseApp will always succeed
-        var app = container.getProvider('app-compat').getImmediate();
-        var databaseExp = container
+        const app = container.getProvider('app-compat').getImmediate();
+        const databaseExp = container
             .getProvider('database')
             .getImmediate({ identifier: url });
         return new Database(databaseExp, app);
@@ -903,13 +850,13 @@ function registerDatabase(instance) {
         .setServiceProps(
     // firebase.database namespace properties
     {
-        Reference: Reference,
-        Query: Query,
-        Database: Database,
-        DataSnapshot: DataSnapshot,
+        Reference,
+        Query,
+        Database,
+        DataSnapshot,
         enableLogging: database.enableLogging,
-        INTERNAL: INTERNAL,
-        ServerValue: ServerValue
+        INTERNAL,
+        ServerValue
     })
         .setMultipleInstances(true));
     instance.registerVersion(name, version, 'node');