@firebase/util 1.10.0 → 1.10.1

package/dist/index.node.cjs.js

@@ -2,8 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -23,7 +21,7 @@ var tslib = require('tslib');
 /**
  * @fileoverview Firebase constants.  Some of these (@defines) can be overridden at compile-time.
  */
-var CONSTANTS = {
+const CONSTANTS = {
     /**
      * @define {boolean} Whether this is the client Node.js SDK.
      */
@@ -57,7 +55,7 @@ var CONSTANTS = {
 /**
  * Throws an error if the provided assertion is falsy
  */
-var assert = function (assertion, message) {
+const assert = function (assertion, message) {
     if (!assertion) {
         throw assertionError(message);
     }
@@ -65,7 +63,7 @@ var assert = function (assertion, message) {
 /**
  * Returns an Error object suitable for throwing.
  */
-var assertionError = function (message) {
+const assertionError = function (message) {
     return new Error('Firebase Database (' +
         CONSTANTS.SDK_VERSION +
         ') INTERNAL ASSERT FAILED: ' +
@@ -88,12 +86,12 @@ var assertionError = function (message) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var stringToByteArray$1 = function (str) {
+const stringToByteArray$1 = function (str) {
     // TODO(user): Use native implementations if/when available
-    var out = [];
-    var p = 0;
-    for (var i = 0; i < str.length; i++) {
-        var c = str.charCodeAt(i);
+    const out = [];
+    let p = 0;
+    for (let i = 0; i < str.length; i++) {
+        let c = str.charCodeAt(i);
         if (c < 128) {
             out[p++] = c;
         }
@@ -125,32 +123,32 @@ var stringToByteArray$1 = function (str) {
  * @param bytes Array of numbers representing characters.
  * @return Stringification of the array.
  */
-var byteArrayToString = function (bytes) {
+const byteArrayToString = function (bytes) {
     // TODO(user): Use native implementations if/when available
-    var out = [];
-    var pos = 0, c = 0;
+    const out = [];
+    let pos = 0, c = 0;
     while (pos < bytes.length) {
-        var c1 = bytes[pos++];
+        const c1 = bytes[pos++];
         if (c1 < 128) {
             out[c++] = String.fromCharCode(c1);
         }
         else if (c1 > 191 && c1 < 224) {
-            var c2 = bytes[pos++];
+            const c2 = bytes[pos++];
             out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
         }
         else if (c1 > 239 && c1 < 365) {
             // Surrogate Pair
-            var c2 = bytes[pos++];
-            var c3 = bytes[pos++];
-            var c4 = bytes[pos++];
-            var u = (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -
+            const c2 = bytes[pos++];
+            const c3 = bytes[pos++];
+            const c4 = bytes[pos++];
+            const u = (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -
                 0x10000;
             out[c++] = String.fromCharCode(0xd800 + (u >> 10));
             out[c++] = String.fromCharCode(0xdc00 + (u & 1023));
         }
         else {
-            var c2 = bytes[pos++];
-            var c3 = bytes[pos++];
+            const c2 = bytes[pos++];
+            const c3 = bytes[pos++];
             out[c++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
         }
     }
@@ -159,7 +157,8 @@ var byteArrayToString = function (bytes) {
 // We define it as an object literal instead of a class because a class compiled down to es5 can't
 // be treeshaked. https://github.com/rollup/rollup/issues/1691
 // Static lookup maps, lazily populated by init_()
-var base64 = {
+// TODO(dlarocque): Define this as a class, since we no longer target ES5.
+const base64 = {
     /**
      * Maps bytes to characters.
      */
@@ -212,25 +211,25 @@ var base64 = {
      *     alternative alphabet.
      * @return The base64 encoded string.
      */
-    encodeByteArray: function (input, webSafe) {
+    encodeByteArray(input, webSafe) {
         if (!Array.isArray(input)) {
             throw Error('encodeByteArray takes an array as a parameter');
         }
         this.init_();
-        var byteToCharMap = webSafe
+        const byteToCharMap = webSafe
             ? this.byteToCharMapWebSafe_
             : this.byteToCharMap_;
-        var output = [];
-        for (var i = 0; i < input.length; i += 3) {
-            var byte1 = input[i];
-            var haveByte2 = i + 1 < input.length;
-            var byte2 = haveByte2 ? input[i + 1] : 0;
-            var haveByte3 = i + 2 < input.length;
-            var byte3 = haveByte3 ? input[i + 2] : 0;
-            var outByte1 = byte1 >> 2;
-            var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
-            var outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
-            var outByte4 = byte3 & 0x3f;
+        const output = [];
+        for (let i = 0; i < input.length; i += 3) {
+            const byte1 = input[i];
+            const haveByte2 = i + 1 < input.length;
+            const byte2 = haveByte2 ? input[i + 1] : 0;
+            const haveByte3 = i + 2 < input.length;
+            const byte3 = haveByte3 ? input[i + 2] : 0;
+            const outByte1 = byte1 >> 2;
+            const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
+            let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
+            let outByte4 = byte3 & 0x3f;
             if (!haveByte3) {
                 outByte4 = 64;
                 if (!haveByte2) {
@@ -249,7 +248,7 @@ var base64 = {
      *     alternative alphabet.
      * @return The base64 encoded string.
      */
-    encodeString: function (input, webSafe) {
+    encodeString(input, webSafe) {
         // Shortcut for Mozilla browsers that implement
         // a native base64 encoder in the form of "btoa/atob"
         if (this.HAS_NATIVE_SUPPORT && !webSafe) {
@@ -265,7 +264,7 @@ var base64 = {
      *     alternative alphabet.
      * @return string representing the decoded value.
      */
-    decodeString: function (input, webSafe) {
+    decodeString(input, webSafe) {
         // Shortcut for Mozilla browsers that implement
         // a native base64 encoder in the form of "btoa/atob"
         if (this.HAS_NATIVE_SUPPORT && !webSafe) {
@@ -288,33 +287,33 @@ var base64 = {
      * @param webSafe True if we should use the web-safe alphabet.
      * @return bytes representing the decoded value.
      */
-    decodeStringToByteArray: function (input, webSafe) {
+    decodeStringToByteArray(input, webSafe) {
         this.init_();
-        var charToByteMap = webSafe
+        const charToByteMap = webSafe
             ? this.charToByteMapWebSafe_
             : this.charToByteMap_;
-        var output = [];
-        for (var i = 0; i < input.length;) {
-            var byte1 = charToByteMap[input.charAt(i++)];
-            var haveByte2 = i < input.length;
-            var byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
+        const output = [];
+        for (let i = 0; i < input.length;) {
+            const byte1 = charToByteMap[input.charAt(i++)];
+            const haveByte2 = i < input.length;
+            const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
             ++i;
-            var haveByte3 = i < input.length;
-            var byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
+            const haveByte3 = i < input.length;
+            const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
             ++i;
-            var haveByte4 = i < input.length;
-            var byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
+            const haveByte4 = i < input.length;
+            const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
             ++i;
             if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
                 throw new DecodeBase64StringError();
             }
-            var outByte1 = (byte1 << 2) | (byte2 >> 4);
+            const outByte1 = (byte1 << 2) | (byte2 >> 4);
             output.push(outByte1);
             if (byte3 !== 64) {
-                var outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);
+                const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);
                 output.push(outByte2);
                 if (byte4 !== 64) {
-                    var outByte3 = ((byte3 << 6) & 0xc0) | byte4;
+                    const outByte3 = ((byte3 << 6) & 0xc0) | byte4;
                     output.push(outByte3);
                 }
             }
@@ -326,14 +325,14 @@ var base64 = {
      * accessing any of the static map variables.
      * @private
      */
-    init_: function () {
+    init_() {
         if (!this.byteToCharMap_) {
             this.byteToCharMap_ = {};
             this.charToByteMap_ = {};
             this.byteToCharMapWebSafe_ = {};
             this.charToByteMapWebSafe_ = {};
             // We want quick mappings back and forth, so we precompute two maps.
-            for (var i = 0; i < this.ENCODED_VALS.length; i++) {
+            for (let i = 0; i < this.ENCODED_VALS.length; i++) {
                 this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
                 this.charToByteMap_[this.byteToCharMap_[i]] = i;
                 this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
@@ -350,27 +349,24 @@ var base64 = {
 /**
  * An error encountered while decoding base64 string.
  */
-var DecodeBase64StringError = /** @class */ (function (_super) {
-    tslib.__extends(DecodeBase64StringError, _super);
-    function DecodeBase64StringError() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.name = 'DecodeBase64StringError';
-        return _this;
+class DecodeBase64StringError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'DecodeBase64StringError';
     }
-    return DecodeBase64StringError;
-}(Error));
+}
 /**
  * URL-safe base64 encoding
  */
-var base64Encode = function (str) {
-    var utf8Bytes = stringToByteArray$1(str);
+const base64Encode = function (str) {
+    const utf8Bytes = stringToByteArray$1(str);
     return base64.encodeByteArray(utf8Bytes, true);
 };
 /**
  * URL-safe base64 encoding (without "." padding in the end).
  * e.g. Used in JSON Web Token (JWT) parts.
  */
-var base64urlEncodeWithoutPadding = function (str) {
+const base64urlEncodeWithoutPadding = function (str) {
     // Use base64url encoding and remove padding in the end (dot characters).
     return base64Encode(str).replace(/\./g, '');
 };
@@ -383,7 +379,7 @@ var base64urlEncodeWithoutPadding = function (str) {
  * @param str To be decoded
  * @return Decoded result, if possible
  */
-var base64Decode = function (str) {
+const base64Decode = function (str) {
     try {
         return base64.decodeString(str, true);
     }
@@ -437,7 +433,7 @@ function deepExtend(target, source) {
         case Date:
             // Treat Dates like scalars; if the target date object had any child
             // properties - they will be lost!
-            var dateValue = source;
+            const dateValue = source;
             return new Date(dateValue.getTime());
         case Object:
             if (target === undefined) {
@@ -452,7 +448,7 @@ function deepExtend(target, source) {
             // Not a plain Object - treat it as a scalar.
             return source;
     }
-    for (var prop in source) {
+    for (const prop in source) {
         // use isValidKey to guard against prototype pollution. See https://snyk.io/vuln/SNYK-JS-LODASH-450202
         if (!source.hasOwnProperty(prop) || !isValidKey(prop)) {
             continue;
@@ -515,9 +511,7 @@ function getGlobal() {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var getDefaultsFromGlobal = function () {
-    return getGlobal().__FIREBASE_DEFAULTS__;
-};
+const getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;
 /**
  * Attempt to read defaults from a JSON string provided to
  * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in
@@ -526,20 +520,20 @@ var getDefaultsFromGlobal = function () {
  * handle seeing that variable in comments.
  * See https://github.com/firebase/firebase-js-sdk/issues/6838
  */
-var getDefaultsFromEnvVariable = function () {
+const getDefaultsFromEnvVariable = () => {
     if (typeof process === 'undefined' || typeof process.env === 'undefined') {
         return;
     }
-    var defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;
+    const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;
     if (defaultsJsonString) {
         return JSON.parse(defaultsJsonString);
     }
 };
-var getDefaultsFromCookie = function () {
+const getDefaultsFromCookie = () => {
     if (typeof document === 'undefined') {
         return;
     }
-    var match;
+    let match;
     try {
         match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
     }
@@ -548,7 +542,7 @@ var getDefaultsFromCookie = function () {
         // `document` object but error on accessing `document.cookie`.
         return;
     }
-    var decoded = match && base64Decode(match[1]);
+    const decoded = match && base64Decode(match[1]);
     return decoded && JSON.parse(decoded);
 };
 /**
@@ -558,7 +552,7 @@ var getDefaultsFromCookie = function () {
  * (3) if such an object exists in a cookie
  * @public
  */
-var getDefaults = function () {
+const getDefaults = () => {
     try {
         return (getDefaultsFromGlobal() ||
             getDefaultsFromEnvVariable() ||
@@ -571,7 +565,7 @@ var getDefaults = function () {
          * info instead of swallowing so we can find these unknown cases
          * and add paths for them if needed.
          */
-        console.info("Unable to get __FIREBASE_DEFAULTS__ due to: ".concat(e));
+        console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);
         return;
     }
 };
@@ -581,24 +575,24 @@ var getDefaults = function () {
  * @returns a URL host formatted like `127.0.0.1:9999` or `[::1]:4000` if available
  * @public
  */
-var getDefaultEmulatorHost = function (productName) { var _a, _b; return (_b = (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.emulatorHosts) === null || _b === void 0 ? void 0 : _b[productName]; };
+const getDefaultEmulatorHost = (productName) => { var _a, _b; return (_b = (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.emulatorHosts) === null || _b === void 0 ? void 0 : _b[productName]; };
 /**
  * Returns emulator hostname and port stored in the __FIREBASE_DEFAULTS__ object
  * for the given product.
  * @returns a pair of hostname and port like `["::1", 4000]` if available
  * @public
  */
-var getDefaultEmulatorHostnameAndPort = function (productName) {
-    var host = getDefaultEmulatorHost(productName);
+const getDefaultEmulatorHostnameAndPort = (productName) => {
+    const host = getDefaultEmulatorHost(productName);
     if (!host) {
         return undefined;
     }
-    var separatorIndex = host.lastIndexOf(':'); // Finding the last since IPv6 addr also has colons.
+    const separatorIndex = host.lastIndexOf(':'); // Finding the last since IPv6 addr also has colons.
     if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {
-        throw new Error("Invalid host ".concat(host, " with no separate hostname and port!"));
+        throw new Error(`Invalid host ${host} with no separate hostname and port!`);
     }
     // eslint-disable-next-line no-restricted-globals
-    var port = parseInt(host.substring(separatorIndex + 1), 10);
+    const port = parseInt(host.substring(separatorIndex + 1), 10);
     if (host[0] === '[') {
         // Bracket-quoted `[ipv6addr]:port` => return "ipv6addr" (without brackets).
         return [host.substring(1, separatorIndex - 1), port];
@@ -611,13 +605,13 @@ var getDefaultEmulatorHostnameAndPort = function (productName) {
  * Returns Firebase app config stored in the __FIREBASE_DEFAULTS__ object.
  * @public
  */
-var getDefaultAppConfig = function () { var _a; return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.config; };
+const getDefaultAppConfig = () => { var _a; return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.config; };
 /**
  * Returns an experimental setting on the __FIREBASE_DEFAULTS__ object (properties
  * prefixed by "_")
  * @public
  */
-var getExperimentalSetting = function (name) { var _a; return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a["_".concat(name)]; };
+const getExperimentalSetting = (name) => { var _a; return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a[`_${name}`]; };
 
 /**
  * @license
@@ -635,14 +629,13 @@ var getExperimentalSetting = function (name) { var _a; return (_a = getDefaults(
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var Deferred = /** @class */ (function () {
-    function Deferred() {
-        var _this = this;
-        this.reject = function () { };
-        this.resolve = function () { };
-        this.promise = new Promise(function (resolve, reject) {
-            _this.resolve = resolve;
-            _this.reject = reject;
+class Deferred {
+    constructor() {
+        this.reject = () => { };
+        this.resolve = () => { };
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
         });
     }
     /**
@@ -650,19 +643,18 @@ var Deferred = /** @class */ (function () {
      * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback
      * and returns a node-style callback which will resolve or reject the Deferred's promise.
      */
-    Deferred.prototype.wrapCallback = function (callback) {
-        var _this = this;
-        return function (error, value) {
+    wrapCallback(callback) {
+        return (error, value) => {
             if (error) {
-                _this.reject(error);
+                this.reject(error);
             }
             else {
-                _this.resolve(value);
+                this.resolve(value);
             }
             if (typeof callback === 'function') {
                 // Attaching noop handler just in case developer wasn't expecting
                 // promises
-                _this.promise.catch(function () { });
+                this.promise.catch(() => { });
                 // Some of our callbacks don't expect a value and our own tests
                 // assert that the parameter length is 1
                 if (callback.length === 1) {
@@ -673,9 +665,8 @@ var Deferred = /** @class */ (function () {
                 }
             }
         };
-    };
-    return Deferred;
-}());
+    }
+}
 
 /**
  * @license
@@ -698,24 +689,24 @@ function createMockUserToken(token, projectId) {
         throw new Error('The "uid" field is no longer supported by mockUserToken. Please use "sub" instead for Firebase Auth User ID.');
     }
     // Unsecured JWTs use "none" as the algorithm.
-    var header = {
+    const header = {
         alg: 'none',
         type: 'JWT'
     };
-    var project = projectId || 'demo-project';
-    var iat = token.iat || 0;
-    var sub = token.sub || token.user_id;
+    const project = projectId || 'demo-project';
+    const iat = token.iat || 0;
+    const sub = token.sub || token.user_id;
     if (!sub) {
         throw new Error("mockUserToken must contain 'sub' or 'user_id' field!");
     }
-    var payload = tslib.__assign({ 
+    const payload = Object.assign({ 
         // Set all required fields to decent defaults
-        iss: "https://securetoken.google.com/".concat(project), aud: project, iat: iat, exp: iat + 3600, auth_time: iat, sub: sub, user_id: sub, firebase: {
+        iss: `https://securetoken.google.com/${project}`, aud: project, iat, exp: iat + 3600, auth_time: iat, sub, user_id: sub, firebase: {
             sign_in_provider: 'custom',
             identities: {}
         } }, token);
     // Unsecured JWTs use the empty string as a signature.
-    var signature = '';
+    const signature = '';
     return [
         base64urlEncodeWithoutPadding(JSON.stringify(header)),
         base64urlEncodeWithoutPadding(JSON.stringify(payload)),
@@ -774,7 +765,7 @@ function isMobileCordova() {
 // Node detection logic from: https://github.com/iliakan/detect-node/
 function isNode() {
     var _a;
-    var forceEnvironment = (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.forceEnvironment;
+    const forceEnvironment = (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.forceEnvironment;
     if (forceEnvironment === 'node') {
         return true;
     }
@@ -813,7 +804,7 @@ function isCloudflareWorker() {
         navigator.userAgent === 'Cloudflare-Workers');
 }
 function isBrowserExtension() {
-    var runtime = typeof chrome === 'object'
+    const runtime = typeof chrome === 'object'
         ? chrome.runtime
         : typeof browser === 'object'
             ? browser.runtime
@@ -834,7 +825,7 @@ function isElectron() {
 }
 /** Detects Internet Explorer. */
 function isIE() {
-    var ua = getUA();
+    const ua = getUA();
     return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;
 }
 /** Detects Universal Windows Platform apps. */
@@ -876,25 +867,25 @@ function isIndexedDBAvailable() {
  * private browsing)
  */
 function validateIndexedDBOpenable() {
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
         try {
-            var preExist_1 = true;
-            var DB_CHECK_NAME_1 = 'validate-browser-context-for-indexeddb-analytics-module';
-            var request_1 = self.indexedDB.open(DB_CHECK_NAME_1);
-            request_1.onsuccess = function () {
-                request_1.result.close();
+            let preExist = true;
+            const DB_CHECK_NAME = 'validate-browser-context-for-indexeddb-analytics-module';
+            const request = self.indexedDB.open(DB_CHECK_NAME);
+            request.onsuccess = () => {
+                request.result.close();
                 // delete database only when it doesn't pre-exist
-                if (!preExist_1) {
-                    self.indexedDB.deleteDatabase(DB_CHECK_NAME_1);
+                if (!preExist) {
+                    self.indexedDB.deleteDatabase(DB_CHECK_NAME);
                 }
                 resolve(true);
             };
-            request_1.onupgradeneeded = function () {
-                preExist_1 = false;
+            request.onupgradeneeded = () => {
+                preExist = false;
             };
-            request_1.onerror = function () {
+            request.onerror = () => {
                 var _a;
-                reject(((_a = request_1.error) === null || _a === void 0 ? void 0 : _a.message) || '');
+                reject(((_a = request.error) === null || _a === void 0 ? void 0 : _a.message) || '');
             };
         }
         catch (error) {
@@ -930,62 +921,96 @@ function areCookiesEnabled() {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var ERROR_NAME = 'FirebaseError';
+/**
+ * @fileoverview Standardized Firebase Error.
+ *
+ * Usage:
+ *
+ *   // TypeScript string literals for type-safe codes
+ *   type Err =
+ *     'unknown' |
+ *     'object-not-found'
+ *     ;
+ *
+ *   // Closure enum for type-safe error codes
+ *   // at-enum {string}
+ *   var Err = {
+ *     UNKNOWN: 'unknown',
+ *     OBJECT_NOT_FOUND: 'object-not-found',
+ *   }
+ *
+ *   let errors: Map<Err, string> = {
+ *     'generic-error': "Unknown error",
+ *     'file-not-found': "Could not find file: {$file}",
+ *   };
+ *
+ *   // Type-safe function - must pass a valid error code as param.
+ *   let error = new ErrorFactory<Err>('service', 'Service', errors);
+ *
+ *   ...
+ *   throw error.create(Err.GENERIC);
+ *   ...
+ *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});
+ *   ...
+ *   // Service: Could not file file: foo.txt (service/file-not-found).
+ *
+ *   catch (e) {
+ *     assert(e.message === "Could not find file: foo.txt.");
+ *     if ((e as FirebaseError)?.code === 'service/file-not-found') {
+ *       console.log("Could not read file: " + e['file']);
+ *     }
+ *   }
+ */
+const ERROR_NAME = 'FirebaseError';
 // Based on code from:
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types
-var FirebaseError = /** @class */ (function (_super) {
-    tslib.__extends(FirebaseError, _super);
-    function FirebaseError(
+class FirebaseError extends Error {
+    constructor(
     /** The error code for this error. */
     code, message, 
     /** Custom data for this error. */
     customData) {
-        var _this = _super.call(this, message) || this;
-        _this.code = code;
-        _this.customData = customData;
+        super(message);
+        this.code = code;
+        this.customData = customData;
         /** The custom name for all FirebaseErrors. */
-        _this.name = ERROR_NAME;
+        this.name = ERROR_NAME;
         // Fix For ES5
         // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        Object.setPrototypeOf(_this, FirebaseError.prototype);
+        // TODO(dlarocque): Replace this with `new.target`: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget
+        //                   which we can now use since we no longer target ES5.
+        Object.setPrototypeOf(this, FirebaseError.prototype);
         // Maintains proper stack trace for where our error was thrown.
         // Only available on V8.
         if (Error.captureStackTrace) {
-            Error.captureStackTrace(_this, ErrorFactory.prototype.create);
+            Error.captureStackTrace(this, ErrorFactory.prototype.create);
         }
-        return _this;
     }
-    return FirebaseError;
-}(Error));
-var ErrorFactory = /** @class */ (function () {
-    function ErrorFactory(service, serviceName, errors) {
+}
+class ErrorFactory {
+    constructor(service, serviceName, errors) {
         this.service = service;
         this.serviceName = serviceName;
         this.errors = errors;
     }
-    ErrorFactory.prototype.create = function (code) {
-        var data = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            data[_i - 1] = arguments[_i];
-        }
-        var customData = data[0] || {};
-        var fullCode = "".concat(this.service, "/").concat(code);
-        var template = this.errors[code];
-        var message = template ? replaceTemplate(template, customData) : 'Error';
+    create(code, ...data) {
+        const customData = data[0] || {};
+        const fullCode = `${this.service}/${code}`;
+        const template = this.errors[code];
+        const message = template ? replaceTemplate(template, customData) : 'Error';
         // Service Name: Error message (service/code).
-        var fullMessage = "".concat(this.serviceName, ": ").concat(message, " (").concat(fullCode, ").");
-        var error = new FirebaseError(fullCode, fullMessage, customData);
+        const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;
+        const error = new FirebaseError(fullCode, fullMessage, customData);
         return error;
-    };
-    return ErrorFactory;
-}());
+    }
+}
 function replaceTemplate(template, data) {
-    return template.replace(PATTERN, function (_, key) {
-        var value = data[key];
-        return value != null ? String(value) : "<".concat(key, "?>");
+    return template.replace(PATTERN, (_, key) => {
+        const value = data[key];
+        return value != null ? String(value) : `<${key}?>`;
     });
 }
-var PATTERN = /\{\$([^}]+)}/g;
+const PATTERN = /\{\$([^}]+)}/g;
 
 /**
  * @license
@@ -1044,10 +1069,10 @@ function stringify(data) {
  * - May return with invalid / incomplete claims if there's no native base64 decoding support.
  * - Doesn't check if the token is actually valid.
  */
-var decode = function (token) {
-    var header = {}, claims = {}, data = {}, signature = '';
+const decode = function (token) {
+    let header = {}, claims = {}, data = {}, signature = '';
     try {
-        var parts = token.split('.');
+        const parts = token.split('.');
         header = jsonEval(base64Decode(parts[0]) || '');
         claims = jsonEval(base64Decode(parts[1]) || '');
         signature = parts[2];
@@ -1056,10 +1081,10 @@ var decode = function (token) {
     }
     catch (e) { }
     return {
-        header: header,
-        claims: claims,
-        data: data,
-        signature: signature
+        header,
+        claims,
+        data,
+        signature
     };
 };
 /**
@@ -1070,10 +1095,10 @@ var decode = function (token) {
  * - May return a false negative if there's no native base64 decoding support.
  * - Doesn't check if the token is actually valid.
  */
-var isValidTimestamp = function (token) {
-    var claims = decode(token).claims;
-    var now = Math.floor(new Date().getTime() / 1000);
-    var validSince = 0, validUntil = 0;
+const isValidTimestamp = function (token) {
+    const claims = decode(token).claims;
+    const now = Math.floor(new Date().getTime() / 1000);
+    let validSince = 0, validUntil = 0;
     if (typeof claims === 'object') {
         if (claims.hasOwnProperty('nbf')) {
             validSince = claims['nbf'];
@@ -1102,8 +1127,8 @@ var isValidTimestamp = function (token) {
  * - May return null if there's no native base64 decoding support.
  * - Doesn't check if the token is actually valid.
  */
-var issuedAtTime = function (token) {
-    var claims = decode(token).claims;
+const issuedAtTime = function (token) {
+    const claims = decode(token).claims;
     if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {
         return claims['iat'];
     }
@@ -1116,8 +1141,8 @@ var issuedAtTime = function (token) {
  * - May return a false negative if there's no native base64 decoding support.
  * - Doesn't check if the token is actually valid.
  */
-var isValidFormat = function (token) {
-    var decoded = decode(token), claims = decoded.claims;
+const isValidFormat = function (token) {
+    const decoded = decode(token), claims = decoded.claims;
     return !!claims && typeof claims === 'object' && claims.hasOwnProperty('iat');
 };
 /**
@@ -1127,8 +1152,8 @@ var isValidFormat = function (token) {
  * - May return a false negative if there's no native base64 decoding support.
  * - Doesn't check if the token is actually valid.
  */
-var isAdmin = function (token) {
-    var claims = decode(token).claims;
+const isAdmin = function (token) {
+    const claims = decode(token).claims;
     return typeof claims === 'object' && claims['admin'] === true;
 };
 
@@ -1160,7 +1185,7 @@ function safeGet(obj, key) {
     }
 }
 function isEmpty(obj) {
-    for (var key in obj) {
+    for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
             return false;
         }
@@ -1168,8 +1193,8 @@ function isEmpty(obj) {
     return true;
 }
 function map(obj, fn, contextObj) {
-    var res = {};
-    for (var key in obj) {
+    const res = {};
+    for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
             res[key] = fn.call(contextObj, obj[key], key, obj);
         }
@@ -1183,15 +1208,14 @@ function deepEqual(a, b) {
     if (a === b) {
         return true;
     }
-    var aKeys = Object.keys(a);
-    var bKeys = Object.keys(b);
-    for (var _i = 0, aKeys_1 = aKeys; _i < aKeys_1.length; _i++) {
-        var k = aKeys_1[_i];
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    for (const k of aKeys) {
         if (!bKeys.includes(k)) {
             return false;
         }
-        var aProp = a[k];
-        var bProp = b[k];
+        const aProp = a[k];
+        const bProp = b[k];
         if (isObject(aProp) && isObject(bProp)) {
             if (!deepEqual(aProp, bProp)) {
                 return false;
@@ -1201,8 +1225,7 @@ function deepEqual(a, b) {
             return false;
         }
     }
-    for (var _a = 0, bKeys_1 = bKeys; _a < bKeys_1.length; _a++) {
-        var k = bKeys_1[_a];
+    for (const k of bKeys) {
         if (!aKeys.includes(k)) {
             return false;
         }
@@ -1233,10 +1256,9 @@ function isObject(thing) {
  * Rejects if the given promise doesn't resolve in timeInMS milliseconds.
  * @internal
  */
-function promiseWithTimeout(promise, timeInMS) {
-    if (timeInMS === void 0) { timeInMS = 2000; }
-    var deferredPromise = new Deferred();
-    setTimeout(function () { return deferredPromise.reject('timeout!'); }, timeInMS);
+function promiseWithTimeout(promise, timeInMS = 2000) {
+    const deferredPromise = new Deferred();
+    setTimeout(() => deferredPromise.reject('timeout!'), timeInMS);
     promise.then(deferredPromise.resolve, deferredPromise.reject);
     return deferredPromise.promise;
 }
@@ -1263,20 +1285,16 @@ function promiseWithTimeout(promise, timeInMS) {
  * Note: You must prepend it with ? when adding it to a URL.
  */
 function querystring(querystringParams) {
-    var params = [];
-    var _loop_1 = function (key, value) {
+    const params = [];
+    for (const [key, value] of Object.entries(querystringParams)) {
         if (Array.isArray(value)) {
-            value.forEach(function (arrayVal) {
+            value.forEach(arrayVal => {
                 params.push(encodeURIComponent(key) + '=' + encodeURIComponent(arrayVal));
             });
         }
         else {
             params.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
         }
-    };
-    for (var _i = 0, _a = Object.entries(querystringParams); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
-        _loop_1(key, value);
     }
     return params.length ? '&' + params.join('&') : '';
 }
@@ -1285,11 +1303,11 @@ function querystring(querystringParams) {
  * (e.g. {arg: 'val', arg2: 'val2'})
  */
 function querystringDecode(querystring) {
-    var obj = {};
-    var tokens = querystring.replace(/^\?/, '').split('&');
-    tokens.forEach(function (token) {
+    const obj = {};
+    const tokens = querystring.replace(/^\?/, '').split('&');
+    tokens.forEach(token => {
         if (token) {
-            var _a = token.split('='), key = _a[0], value = _a[1];
+            const [key, value] = token.split('=');
             obj[decodeURIComponent(key)] = decodeURIComponent(value);
         }
     });
@@ -1299,11 +1317,11 @@ function querystringDecode(querystring) {
  * Extract the query string part of a URL, including the leading question mark (if present).
  */
 function extractQuerystring(url) {
-    var queryStart = url.indexOf('?');
+    const queryStart = url.indexOf('?');
     if (!queryStart) {
         return '';
     }
-    var fragmentStart = url.indexOf('#', queryStart);
+    const fragmentStart = url.indexOf('#', queryStart);
     return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : undefined);
 }
 
@@ -1346,8 +1364,8 @@ function extractQuerystring(url) {
  * @final
  * @struct
  */
-var Sha1 = /** @class */ (function () {
-    function Sha1() {
+class Sha1 {
+    constructor() {
         /**
          * Holds the previous values of accumulated variables a-e in the compress_
          * function.
@@ -1380,12 +1398,12 @@ var Sha1 = /** @class */ (function () {
         this.total_ = 0;
         this.blockSize = 512 / 8;
         this.pad_[0] = 128;
-        for (var i = 1; i < this.blockSize; ++i) {
+        for (let i = 1; i < this.blockSize; ++i) {
             this.pad_[i] = 0;
         }
         this.reset();
     }
-    Sha1.prototype.reset = function () {
+    reset() {
         this.chain_[0] = 0x67452301;
         this.chain_[1] = 0xefcdab89;
         this.chain_[2] = 0x98badcfe;
@@ -1393,21 +1411,21 @@ var Sha1 = /** @class */ (function () {
         this.chain_[4] = 0xc3d2e1f0;
         this.inbuf_ = 0;
         this.total_ = 0;
-    };
+    }
     /**
      * Internal compress helper function.
      * @param buf Block to compress.
      * @param offset Offset of the block in the buffer.
      * @private
      */
-    Sha1.prototype.compress_ = function (buf, offset) {
+    compress_(buf, offset) {
         if (!offset) {
             offset = 0;
         }
-        var W = this.W_;
+        const W = this.W_;
         // get 16 big endian words
         if (typeof buf === 'string') {
-            for (var i = 0; i < 16; i++) {
+            for (let i = 0; i < 16; i++) {
                 // TODO(user): [bug 8140122] Recent versions of Safari for Mac OS and iOS
                 // have a bug that turns the post-increment ++ operator into pre-increment
                 // during JIT compilation.  We have code that depends heavily on SHA-1 for
@@ -1425,7 +1443,7 @@ var Sha1 = /** @class */ (function () {
             }
         }
         else {
-            for (var i = 0; i < 16; i++) {
+            for (let i = 0; i < 16; i++) {
                 W[i] =
                     (buf[offset] << 24) |
                         (buf[offset + 1] << 16) |
@@ -1435,18 +1453,18 @@ var Sha1 = /** @class */ (function () {
             }
         }
         // expand to 80 words
-        for (var i = 16; i < 80; i++) {
-            var t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+        for (let i = 16; i < 80; i++) {
+            const t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
             W[i] = ((t << 1) | (t >>> 31)) & 0xffffffff;
         }
-        var a = this.chain_[0];
-        var b = this.chain_[1];
-        var c = this.chain_[2];
-        var d = this.chain_[3];
-        var e = this.chain_[4];
-        var f, k;
+        let a = this.chain_[0];
+        let b = this.chain_[1];
+        let c = this.chain_[2];
+        let d = this.chain_[3];
+        let e = this.chain_[4];
+        let f, k;
         // TODO(user): Try to unroll this loop to speed up the computation.
-        for (var i = 0; i < 80; i++) {
+        for (let i = 0; i < 80; i++) {
             if (i < 40) {
                 if (i < 20) {
                     f = d ^ (b & (c ^ d));
@@ -1467,7 +1485,7 @@ var Sha1 = /** @class */ (function () {
                     k = 0xca62c1d6;
                 }
             }
-            var t = (((a << 5) | (a >>> 27)) + f + e + k + W[i]) & 0xffffffff;
+            const t = (((a << 5) | (a >>> 27)) + f + e + k + W[i]) & 0xffffffff;
             e = d;
             d = c;
             c = ((b << 30) | (b >>> 2)) & 0xffffffff;
@@ -1479,8 +1497,8 @@ var Sha1 = /** @class */ (function () {
         this.chain_[2] = (this.chain_[2] + c) & 0xffffffff;
         this.chain_[3] = (this.chain_[3] + d) & 0xffffffff;
         this.chain_[4] = (this.chain_[4] + e) & 0xffffffff;
-    };
-    Sha1.prototype.update = function (bytes, length) {
+    }
+    update(bytes, length) {
         // TODO(johnlenz): tighten the function signature and remove this check
         if (bytes == null) {
             return;
@@ -1488,11 +1506,11 @@ var Sha1 = /** @class */ (function () {
         if (length === undefined) {
             length = bytes.length;
         }
-        var lengthMinusBlock = length - this.blockSize;
-        var n = 0;
+        const lengthMinusBlock = length - this.blockSize;
+        let n = 0;
         // Using local instead of member variables gives ~5% speedup on Firefox 16.
-        var buf = this.buf_;
-        var inbuf = this.inbuf_;
+        const buf = this.buf_;
+        let inbuf = this.inbuf_;
         // The outer while loop should execute at most twice.
         while (n < length) {
             // When we have no data in the block to top up, we can directly process the
@@ -1534,11 +1552,11 @@ var Sha1 = /** @class */ (function () {
         }
         this.inbuf_ = inbuf;
         this.total_ += length;
-    };
+    }
     /** @override */
-    Sha1.prototype.digest = function () {
-        var digest = [];
-        var totalBits = this.total_ * 8;
+    digest() {
+        const digest = [];
+        let totalBits = this.total_ * 8;
         // Add pad 0x80 0x00*.
         if (this.inbuf_ < 56) {
             this.update(this.pad_, 56 - this.inbuf_);
@@ -1547,22 +1565,21 @@ var Sha1 = /** @class */ (function () {
             this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));
         }
         // Add # bits.
-        for (var i = this.blockSize - 1; i >= 56; i--) {
+        for (let i = this.blockSize - 1; i >= 56; i--) {
             this.buf_[i] = totalBits & 255;
             totalBits /= 256; // Don't use bit-shifting here!
         }
         this.compress_(this.buf_);
-        var n = 0;
-        for (var i = 0; i < 5; i++) {
-            for (var j = 24; j >= 0; j -= 8) {
+        let n = 0;
+        for (let i = 0; i < 5; i++) {
+            for (let j = 24; j >= 0; j -= 8) {
                 digest[n] = (this.chain_[i] >> j) & 255;
                 ++n;
             }
         }
         return digest;
-    };
-    return Sha1;
-}());
+    }
+}
 
 /**
  * Helper to make a Subscribe function (just like Promise helps make a
@@ -1573,21 +1590,20 @@ var Sha1 = /** @class */ (function () {
  * @param onNoObservers Callback when count of Observers goes to zero.
  */
 function createSubscribe(executor, onNoObservers) {
-    var proxy = new ObserverProxy(executor, onNoObservers);
+    const proxy = new ObserverProxy(executor, onNoObservers);
     return proxy.subscribe.bind(proxy);
 }
 /**
  * Implement fan-out for any number of Observers attached via a subscribe
  * function.
  */
-var ObserverProxy = /** @class */ (function () {
+class ObserverProxy {
     /**
      * @param executor Function which can make calls to a single Observer
      *     as a proxy.
      * @param onNoObservers Callback when count of Observers goes to zero.
      */
-    function ObserverProxy(executor, onNoObservers) {
-        var _this = this;
+    constructor(executor, onNoObservers) {
         this.observers = [];
         this.unsubscribes = [];
         this.observerCount = 0;
@@ -1599,39 +1615,38 @@ var ObserverProxy = /** @class */ (function () {
         // synchronously after the creation of the subscribe function
         // can still receive the very first value generated in the executor.
         this.task
-            .then(function () {
-            executor(_this);
+            .then(() => {
+            executor(this);
         })
-            .catch(function (e) {
-            _this.error(e);
+            .catch(e => {
+            this.error(e);
         });
     }
-    ObserverProxy.prototype.next = function (value) {
-        this.forEachObserver(function (observer) {
+    next(value) {
+        this.forEachObserver((observer) => {
             observer.next(value);
         });
-    };
-    ObserverProxy.prototype.error = function (error) {
-        this.forEachObserver(function (observer) {
+    }
+    error(error) {
+        this.forEachObserver((observer) => {
             observer.error(error);
         });
         this.close(error);
-    };
-    ObserverProxy.prototype.complete = function () {
-        this.forEachObserver(function (observer) {
+    }
+    complete() {
+        this.forEachObserver((observer) => {
             observer.complete();
         });
         this.close();
-    };
+    }
     /**
      * Subscribe function that can be used to add an Observer to the fan-out list.
      *
      * - We require that no event is sent to a subscriber synchronously to their
      *   call to subscribe().
      */
-    ObserverProxy.prototype.subscribe = function (nextOrObserver, error, complete) {
-        var _this = this;
-        var observer;
+    subscribe(nextOrObserver, error, complete) {
+        let observer;
         if (nextOrObserver === undefined &&
             error === undefined &&
             complete === undefined) {
@@ -1648,8 +1663,8 @@ var ObserverProxy = /** @class */ (function () {
         else {
             observer = {
                 next: nextOrObserver,
-                error: error,
-                complete: complete
+                error,
+                complete
             };
         }
         if (observer.next === undefined) {
@@ -1661,16 +1676,16 @@ var ObserverProxy = /** @class */ (function () {
         if (observer.complete === undefined) {
             observer.complete = noop;
         }
-        var unsub = this.unsubscribeOne.bind(this, this.observers.length);
+        const unsub = this.unsubscribeOne.bind(this, this.observers.length);
         // Attempt to subscribe to a terminated Observable - we
         // just respond to the Observer with the final error or complete
         // event.
         if (this.finalized) {
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.task.then(function () {
+            this.task.then(() => {
                 try {
-                    if (_this.finalError) {
-                        observer.error(_this.finalError);
+                    if (this.finalError) {
+                        observer.error(this.finalError);
                     }
                     else {
                         observer.complete();
@@ -1684,10 +1699,10 @@ var ObserverProxy = /** @class */ (function () {
         }
         this.observers.push(observer);
         return unsub;
-    };
+    }
     // Unsubscribe is synchronous - we guarantee that no events are sent to
     // any unsubscribed Observer.
-    ObserverProxy.prototype.unsubscribeOne = function (i) {
+    unsubscribeOne(i) {
         if (this.observers === undefined || this.observers[i] === undefined) {
             return;
         }
@@ -1696,29 +1711,28 @@ var ObserverProxy = /** @class */ (function () {
         if (this.observerCount === 0 && this.onNoObservers !== undefined) {
             this.onNoObservers(this);
         }
-    };
-    ObserverProxy.prototype.forEachObserver = function (fn) {
+    }
+    forEachObserver(fn) {
         if (this.finalized) {
             // Already closed by previous event....just eat the additional values.
             return;
         }
         // Since sendOne calls asynchronously - there is no chance that
         // this.observers will become undefined.
-        for (var i = 0; i < this.observers.length; i++) {
+        for (let i = 0; i < this.observers.length; i++) {
             this.sendOne(i, fn);
         }
-    };
+    }
     // Call the Observer via one of it's callback function. We are careful to
     // confirm that the observe has not been unsubscribed since this asynchronous
     // function had been queued.
-    ObserverProxy.prototype.sendOne = function (i, fn) {
-        var _this = this;
+    sendOne(i, fn) {
         // Execute the callback asynchronously
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.task.then(function () {
-            if (_this.observers !== undefined && _this.observers[i] !== undefined) {
+        this.task.then(() => {
+            if (this.observers !== undefined && this.observers[i] !== undefined) {
                 try {
-                    fn(_this.observers[i]);
+                    fn(this.observers[i]);
                 }
                 catch (e) {
                     // Ignore exceptions raised in Observers or missing methods of an
@@ -1730,9 +1744,8 @@ var ObserverProxy = /** @class */ (function () {
                 }
             }
         });
-    };
-    ObserverProxy.prototype.close = function (err) {
-        var _this = this;
+    }
+    close(err) {
         if (this.finalized) {
             return;
         }
@@ -1742,26 +1755,21 @@ var ObserverProxy = /** @class */ (function () {
         }
         // Proxy is no longer needed - garbage collect references
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.task.then(function () {
-            _this.observers = undefined;
-            _this.onNoObservers = undefined;
+        this.task.then(() => {
+            this.observers = undefined;
+            this.onNoObservers = undefined;
         });
-    };
-    return ObserverProxy;
-}());
+    }
+}
 /** Turn synchronous function into one called asynchronously. */
 // eslint-disable-next-line @typescript-eslint/ban-types
 function async(fn, onError) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
+    return (...args) => {
         Promise.resolve(true)
-            .then(function () {
-            fn.apply(void 0, args);
+            .then(() => {
+            fn(...args);
         })
-            .catch(function (error) {
+            .catch((error) => {
             if (onError) {
                 onError(error);
             }
@@ -1775,8 +1783,7 @@ function implementsAnyMethods(obj, methods) {
     if (typeof obj !== 'object' || obj === null) {
         return false;
     }
-    for (var _i = 0, methods_1 = methods; _i < methods_1.length; _i++) {
-        var method = methods_1[_i];
+    for (const method of methods) {
         if (method in obj && typeof obj[method] === 'function') {
             return true;
         }
@@ -1812,8 +1819,8 @@ function noop() {
  * @param maxCount The maximum number of argument to allow for the function call
  * @param argCount The actual number of arguments provided.
  */
-var validateArgCount = function (fnName, minCount, maxCount, argCount) {
-    var argError;
+const validateArgCount = function (fnName, minCount, maxCount, argCount) {
+    let argError;
     if (argCount < minCount) {
         argError = 'at least ' + minCount;
     }
@@ -1821,7 +1828,7 @@ var validateArgCount = function (fnName, minCount, maxCount, argCount) {
         argError = maxCount === 0 ? 'none' : 'no more than ' + maxCount;
     }
     if (argError) {
-        var error = fnName +
+        const error = fnName +
             ' failed: Was called with ' +
             argCount +
             (argCount === 1 ? ' argument.' : ' arguments.') +
@@ -1839,7 +1846,7 @@ var validateArgCount = function (fnName, minCount, maxCount, argCount) {
  * @return The prefix to add to the error thrown for validation.
  */
 function errorPrefix(fnName, argName) {
-    return "".concat(fnName, " failed: ").concat(argName, " argument ");
+    return `${fnName} failed: ${argName} argument `;
 }
 /**
  * @param fnName
@@ -1904,17 +1911,17 @@ function validateContextObject(fnName, argumentName, context, optional) {
  * @param {string} str
  * @return {Array}
  */
-var stringToByteArray = function (str) {
-    var out = [];
-    var p = 0;
-    for (var i = 0; i < str.length; i++) {
-        var c = str.charCodeAt(i);
+const stringToByteArray = function (str) {
+    const out = [];
+    let p = 0;
+    for (let i = 0; i < str.length; i++) {
+        let c = str.charCodeAt(i);
         // Is this the lead surrogate in a surrogate pair?
         if (c >= 0xd800 && c <= 0xdbff) {
-            var high = c - 0xd800; // the high 10 bits.
+            const high = c - 0xd800; // the high 10 bits.
             i++;
             assert(i < str.length, 'Surrogate pair missing trail surrogate.');
-            var low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.
+            const low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.
             c = 0x10000 + (high << 10) + low;
         }
         if (c < 128) {
@@ -1943,10 +1950,10 @@ var stringToByteArray = function (str) {
  * @param {string} str
  * @return {number}
  */
-var stringLength = function (str) {
-    var p = 0;
-    for (var i = 0; i < str.length; i++) {
-        var c = str.charCodeAt(i);
+const stringLength = function (str) {
+    let p = 0;
+    for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
         if (c < 128) {
             p++;
         }
@@ -1986,9 +1993,9 @@ var stringLength = function (str) {
  * Generates a new uuid.
  * @public
  */
-var uuidv4 = function () {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        var r = (Math.random() * 16) | 0, v = c === 'x' ? r : (r & 0x3) | 0x8;
+const uuidv4 = function () {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (Math.random() * 16) | 0, v = c === 'x' ? r : (r & 0x3) | 0x8;
         return v.toString(16);
     });
 };
@@ -2012,18 +2019,18 @@ var uuidv4 = function () {
 /**
  * The amount of milliseconds to exponentially increase.
  */
-var DEFAULT_INTERVAL_MILLIS = 1000;
+const DEFAULT_INTERVAL_MILLIS = 1000;
 /**
  * The factor to backoff by.
  * Should be a number greater than 1.
  */
-var DEFAULT_BACKOFF_FACTOR = 2;
+const DEFAULT_BACKOFF_FACTOR = 2;
 /**
  * The maximum milliseconds to increase to.
  *
  * <p>Visible for testing
  */
-var MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.
+const MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.
 /**
  * The percentage of backoff time to randomize by.
  * See
@@ -2032,22 +2039,20 @@ var MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.
  *
  * <p>Visible for testing
  */
-var RANDOM_FACTOR = 0.5;
+const RANDOM_FACTOR = 0.5;
 /**
  * Based on the backoff method from
  * https://github.com/google/closure-library/blob/master/closure/goog/math/exponentialbackoff.js.
  * Extracted here so we don't need to pass metadata and a stateful ExponentialBackoff object around.
  */
-function calculateBackoffMillis(backoffCount, intervalMillis, backoffFactor) {
-    if (intervalMillis === void 0) { intervalMillis = DEFAULT_INTERVAL_MILLIS; }
-    if (backoffFactor === void 0) { backoffFactor = DEFAULT_BACKOFF_FACTOR; }
+function calculateBackoffMillis(backoffCount, intervalMillis = DEFAULT_INTERVAL_MILLIS, backoffFactor = DEFAULT_BACKOFF_FACTOR) {
     // Calculates an exponentially increasing value.
     // Deviation: calculates value from count and a constant interval, so we only need to save value
     // and count to restore state.
-    var currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);
+    const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);
     // A random "fuzz" to avoid waves of retries.
     // Deviation: randomFactor is required.
-    var randomWait = Math.round(
+    const randomWait = Math.round(
     // A fraction of the backoff value to add/subtract.
     // Deviation: changes multiplication order to improve readability.
     RANDOM_FACTOR *
@@ -2081,17 +2086,17 @@ function calculateBackoffMillis(backoffCount, intervalMillis, backoffFactor) {
  */
 function ordinal(i) {
     if (!Number.isFinite(i)) {
-        return "".concat(i);
+        return `${i}`;
     }
     return i + indicator(i);
 }
 function indicator(i) {
     i = Math.abs(i);
-    var cent = i % 100;
+    const cent = i % 100;
     if (cent >= 10 && cent <= 20) {
         return 'th';
     }
-    var dec = i % 10;
+    const dec = i % 10;
     if (dec === 1) {
         return 'st';
     }