@123usmanhaider321/ui 0.1.6 → 1.0.0

package/dist/node_modules/@firebase/storage/dist/index.esm.js

@@ -1,2623 +0,0 @@
-import { _getProvider, getApp, _isFirebaseServerApp, _registerComponent, registerVersion, SDK_VERSION } from "../../app/dist/esm/index.esm.js";
-import { getModularInstance, getDefaultEmulatorHostnameAndPort, FirebaseError, isCloudWorkstation, pingServer, createMockUserToken } from "../../util/dist/index.esm.js";
-import { Component } from "../../component/dist/esm/index.esm.js";
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const DEFAULT_HOST = "firebasestorage.googleapis.com";
-const CONFIG_STORAGE_BUCKET_KEY = "storageBucket";
-const DEFAULT_MAX_OPERATION_RETRY_TIME = 2 * 60 * 1e3;
-const DEFAULT_MAX_UPLOAD_RETRY_TIME = 10 * 60 * 1e3;
-const DEFAULT_MIN_SLEEP_TIME_MILLIS = 1e3;
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class StorageError extends FirebaseError {
-  /**
-   * @param code - A `StorageErrorCode` string to be prefixed with 'storage/' and
-   *  added to the end of the message.
-   * @param message  - Error message.
-   * @param status_ - Corresponding HTTP Status Code
-   */
-  constructor(code, message, status_ = 0) {
-    super(prependCode(code), `Firebase Storage: ${message} (${prependCode(code)})`);
-    this.status_ = status_;
-    this.customData = { serverResponse: null };
-    this._baseMessage = this.message;
-    Object.setPrototypeOf(this, StorageError.prototype);
-  }
-  get status() {
-    return this.status_;
-  }
-  set status(status) {
-    this.status_ = status;
-  }
-  /**
-   * Compares a `StorageErrorCode` against this error's code, filtering out the prefix.
-   */
-  _codeEquals(code) {
-    return prependCode(code) === this.code;
-  }
-  /**
-   * Optional response message that was added by the server.
-   */
-  get serverResponse() {
-    return this.customData.serverResponse;
-  }
-  set serverResponse(serverResponse) {
-    this.customData.serverResponse = serverResponse;
-    if (this.customData.serverResponse) {
-      this.message = `${this._baseMessage}
-${this.customData.serverResponse}`;
-    } else {
-      this.message = this._baseMessage;
-    }
-  }
-}
-var StorageErrorCode;
-(function(StorageErrorCode2) {
-  StorageErrorCode2["UNKNOWN"] = "unknown";
-  StorageErrorCode2["OBJECT_NOT_FOUND"] = "object-not-found";
-  StorageErrorCode2["BUCKET_NOT_FOUND"] = "bucket-not-found";
-  StorageErrorCode2["PROJECT_NOT_FOUND"] = "project-not-found";
-  StorageErrorCode2["QUOTA_EXCEEDED"] = "quota-exceeded";
-  StorageErrorCode2["UNAUTHENTICATED"] = "unauthenticated";
-  StorageErrorCode2["UNAUTHORIZED"] = "unauthorized";
-  StorageErrorCode2["UNAUTHORIZED_APP"] = "unauthorized-app";
-  StorageErrorCode2["RETRY_LIMIT_EXCEEDED"] = "retry-limit-exceeded";
-  StorageErrorCode2["INVALID_CHECKSUM"] = "invalid-checksum";
-  StorageErrorCode2["CANCELED"] = "canceled";
-  StorageErrorCode2["INVALID_EVENT_NAME"] = "invalid-event-name";
-  StorageErrorCode2["INVALID_URL"] = "invalid-url";
-  StorageErrorCode2["INVALID_DEFAULT_BUCKET"] = "invalid-default-bucket";
-  StorageErrorCode2["NO_DEFAULT_BUCKET"] = "no-default-bucket";
-  StorageErrorCode2["CANNOT_SLICE_BLOB"] = "cannot-slice-blob";
-  StorageErrorCode2["SERVER_FILE_WRONG_SIZE"] = "server-file-wrong-size";
-  StorageErrorCode2["NO_DOWNLOAD_URL"] = "no-download-url";
-  StorageErrorCode2["INVALID_ARGUMENT"] = "invalid-argument";
-  StorageErrorCode2["INVALID_ARGUMENT_COUNT"] = "invalid-argument-count";
-  StorageErrorCode2["APP_DELETED"] = "app-deleted";
-  StorageErrorCode2["INVALID_ROOT_OPERATION"] = "invalid-root-operation";
-  StorageErrorCode2["INVALID_FORMAT"] = "invalid-format";
-  StorageErrorCode2["INTERNAL_ERROR"] = "internal-error";
-  StorageErrorCode2["UNSUPPORTED_ENVIRONMENT"] = "unsupported-environment";
-})(StorageErrorCode || (StorageErrorCode = {}));
-function prependCode(code) {
-  return "storage/" + code;
-}
-function unknown() {
-  const message = "An unknown error occurred, please check the error payload for server response.";
-  return new StorageError(StorageErrorCode.UNKNOWN, message);
-}
-function objectNotFound(path) {
-  return new StorageError(StorageErrorCode.OBJECT_NOT_FOUND, "Object '" + path + "' does not exist.");
-}
-function quotaExceeded(bucket) {
-  return new StorageError(StorageErrorCode.QUOTA_EXCEEDED, "Quota for bucket '" + bucket + "' exceeded, please view quota on https://firebase.google.com/pricing/.");
-}
-function unauthenticated() {
-  const message = "User is not authenticated, please authenticate using Firebase Authentication and try again.";
-  return new StorageError(StorageErrorCode.UNAUTHENTICATED, message);
-}
-function unauthorizedApp() {
-  return new StorageError(StorageErrorCode.UNAUTHORIZED_APP, "This app does not have permission to access Firebase Storage on this project.");
-}
-function unauthorized(path) {
-  return new StorageError(StorageErrorCode.UNAUTHORIZED, "User does not have permission to access '" + path + "'.");
-}
-function retryLimitExceeded() {
-  return new StorageError(StorageErrorCode.RETRY_LIMIT_EXCEEDED, "Max retry time for operation exceeded, please try again.");
-}
-function canceled() {
-  return new StorageError(StorageErrorCode.CANCELED, "User canceled the upload/download.");
-}
-function invalidUrl(url) {
-  return new StorageError(StorageErrorCode.INVALID_URL, "Invalid URL '" + url + "'.");
-}
-function invalidDefaultBucket(bucket) {
-  return new StorageError(StorageErrorCode.INVALID_DEFAULT_BUCKET, "Invalid default bucket '" + bucket + "'.");
-}
-function noDefaultBucket() {
-  return new StorageError(StorageErrorCode.NO_DEFAULT_BUCKET, "No default bucket found. Did you set the '" + CONFIG_STORAGE_BUCKET_KEY + "' property when initializing the app?");
-}
-function cannotSliceBlob() {
-  return new StorageError(StorageErrorCode.CANNOT_SLICE_BLOB, "Cannot slice blob for upload. Please retry the upload.");
-}
-function serverFileWrongSize() {
-  return new StorageError(StorageErrorCode.SERVER_FILE_WRONG_SIZE, "Server recorded incorrect upload file size, please retry the upload.");
-}
-function noDownloadURL() {
-  return new StorageError(StorageErrorCode.NO_DOWNLOAD_URL, "The given file does not have any download URLs.");
-}
-function missingPolyFill(polyFill) {
-  return new StorageError(StorageErrorCode.UNSUPPORTED_ENVIRONMENT, `${polyFill} is missing. Make sure to install the required polyfills. See https://firebase.google.com/docs/web/environments-js-sdk#polyfills for more information.`);
-}
-function invalidArgument(message) {
-  return new StorageError(StorageErrorCode.INVALID_ARGUMENT, message);
-}
-function appDeleted() {
-  return new StorageError(StorageErrorCode.APP_DELETED, "The Firebase app was deleted.");
-}
-function invalidRootOperation(name2) {
-  return new StorageError(StorageErrorCode.INVALID_ROOT_OPERATION, "The operation '" + name2 + "' cannot be performed on a root reference, create a non-root reference using child, such as .child('file.png').");
-}
-function invalidFormat(format, message) {
-  return new StorageError(StorageErrorCode.INVALID_FORMAT, "String does not match format '" + format + "': " + message);
-}
-function internalError(message) {
-  throw new StorageError(StorageErrorCode.INTERNAL_ERROR, "Internal error: " + message);
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class Location {
-  constructor(bucket, path) {
-    this.bucket = bucket;
-    this.path_ = path;
-  }
-  get path() {
-    return this.path_;
-  }
-  get isRoot() {
-    return this.path.length === 0;
-  }
-  fullServerUrl() {
-    const encode = encodeURIComponent;
-    return "/b/" + encode(this.bucket) + "/o/" + encode(this.path);
-  }
-  bucketOnlyServerUrl() {
-    const encode = encodeURIComponent;
-    return "/b/" + encode(this.bucket) + "/o";
-  }
-  static makeFromBucketSpec(bucketString, host) {
-    let bucketLocation;
-    try {
-      bucketLocation = Location.makeFromUrl(bucketString, host);
-    } catch (e) {
-      return new Location(bucketString, "");
-    }
-    if (bucketLocation.path === "") {
-      return bucketLocation;
-    } else {
-      throw invalidDefaultBucket(bucketString);
-    }
-  }
-  static makeFromUrl(url, host) {
-    let location = null;
-    const bucketDomain = "([A-Za-z0-9.\\-_]+)";
-    function gsModify(loc) {
-      if (loc.path.charAt(loc.path.length - 1) === "/") {
-        loc.path_ = loc.path_.slice(0, -1);
-      }
-    }
-    const gsPath = "(/(.*))?$";
-    const gsRegex = new RegExp("^gs://" + bucketDomain + gsPath, "i");
-    const gsIndices = { bucket: 1, path: 3 };
-    function httpModify(loc) {
-      loc.path_ = decodeURIComponent(loc.path);
-    }
-    const version2 = "v[A-Za-z0-9_]+";
-    const firebaseStorageHost = host.replace(/[.]/g, "\\.");
-    const firebaseStoragePath = "(/([^?#]*).*)?$";
-    const firebaseStorageRegExp = new RegExp(`^https?://${firebaseStorageHost}/${version2}/b/${bucketDomain}/o${firebaseStoragePath}`, "i");
-    const firebaseStorageIndices = { bucket: 1, path: 3 };
-    const cloudStorageHost = host === DEFAULT_HOST ? "(?:storage.googleapis.com|storage.cloud.google.com)" : host;
-    const cloudStoragePath = "([^?#]*)";
-    const cloudStorageRegExp = new RegExp(`^https?://${cloudStorageHost}/${bucketDomain}/${cloudStoragePath}`, "i");
-    const cloudStorageIndices = { bucket: 1, path: 2 };
-    const groups = [
-      { regex: gsRegex, indices: gsIndices, postModify: gsModify },
-      {
-        regex: firebaseStorageRegExp,
-        indices: firebaseStorageIndices,
-        postModify: httpModify
-      },
-      {
-        regex: cloudStorageRegExp,
-        indices: cloudStorageIndices,
-        postModify: httpModify
-      }
-    ];
-    for (let i = 0; i < groups.length; i++) {
-      const group = groups[i];
-      const captures = group.regex.exec(url);
-      if (captures) {
-        const bucketValue = captures[group.indices.bucket];
-        let pathValue = captures[group.indices.path];
-        if (!pathValue) {
-          pathValue = "";
-        }
-        location = new Location(bucketValue, pathValue);
-        group.postModify(location);
-        break;
-      }
-    }
-    if (location == null) {
-      throw invalidUrl(url);
-    }
-    return location;
-  }
-}
-class FailRequest {
-  constructor(error) {
-    this.promise_ = Promise.reject(error);
-  }
-  /** @inheritDoc */
-  getPromise() {
-    return this.promise_;
-  }
-  /** @inheritDoc */
-  cancel(_appDelete = false) {
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function start(doRequest, backoffCompleteCb, timeout) {
-  let waitSeconds = 1;
-  let retryTimeoutId = null;
-  let globalTimeoutId = null;
-  let hitTimeout = false;
-  let cancelState = 0;
-  function canceled2() {
-    return cancelState === 2;
-  }
-  let triggeredCallback = false;
-  function triggerCallback(...args) {
-    if (!triggeredCallback) {
-      triggeredCallback = true;
-      backoffCompleteCb.apply(null, args);
-    }
-  }
-  function callWithDelay(millis) {
-    retryTimeoutId = setTimeout(() => {
-      retryTimeoutId = null;
-      doRequest(responseHandler, canceled2());
-    }, millis);
-  }
-  function clearGlobalTimeout() {
-    if (globalTimeoutId) {
-      clearTimeout(globalTimeoutId);
-    }
-  }
-  function responseHandler(success, ...args) {
-    if (triggeredCallback) {
-      clearGlobalTimeout();
-      return;
-    }
-    if (success) {
-      clearGlobalTimeout();
-      triggerCallback.call(null, success, ...args);
-      return;
-    }
-    const mustStop = canceled2() || hitTimeout;
-    if (mustStop) {
-      clearGlobalTimeout();
-      triggerCallback.call(null, success, ...args);
-      return;
-    }
-    if (waitSeconds < 64) {
-      waitSeconds *= 2;
-    }
-    let waitMillis;
-    if (cancelState === 1) {
-      cancelState = 2;
-      waitMillis = 0;
-    } else {
-      waitMillis = (waitSeconds + Math.random()) * 1e3;
-    }
-    callWithDelay(waitMillis);
-  }
-  let stopped = false;
-  function stop2(wasTimeout) {
-    if (stopped) {
-      return;
-    }
-    stopped = true;
-    clearGlobalTimeout();
-    if (triggeredCallback) {
-      return;
-    }
-    if (retryTimeoutId !== null) {
-      if (!wasTimeout) {
-        cancelState = 2;
-      }
-      clearTimeout(retryTimeoutId);
-      callWithDelay(0);
-    } else {
-      if (!wasTimeout) {
-        cancelState = 1;
-      }
-    }
-  }
-  callWithDelay(0);
-  globalTimeoutId = setTimeout(() => {
-    hitTimeout = true;
-    stop2(true);
-  }, timeout);
-  return stop2;
-}
-function stop(id) {
-  id(false);
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function isJustDef(p) {
-  return p !== void 0;
-}
-function isFunction(p) {
-  return typeof p === "function";
-}
-function isNonArrayObject(p) {
-  return typeof p === "object" && !Array.isArray(p);
-}
-function isString(p) {
-  return typeof p === "string" || p instanceof String;
-}
-function isNativeBlob(p) {
-  return isNativeBlobDefined() && p instanceof Blob;
-}
-function isNativeBlobDefined() {
-  return typeof Blob !== "undefined";
-}
-function validateNumber(argument, minValue, maxValue, value) {
-  if (value < minValue) {
-    throw invalidArgument(`Invalid value for '${argument}'. Expected ${minValue} or greater.`);
-  }
-  if (value > maxValue) {
-    throw invalidArgument(`Invalid value for '${argument}'. Expected ${maxValue} or less.`);
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function makeUrl(urlPart, host, protocol) {
-  let origin = host;
-  if (protocol == null) {
-    origin = `https://${host}`;
-  }
-  return `${protocol}://${origin}/v0${urlPart}`;
-}
-function makeQueryString(params) {
-  const encode = encodeURIComponent;
-  let queryPart = "?";
-  for (const key in params) {
-    if (params.hasOwnProperty(key)) {
-      const nextPart = encode(key) + "=" + encode(params[key]);
-      queryPart = queryPart + nextPart + "&";
-    }
-  }
-  queryPart = queryPart.slice(0, -1);
-  return queryPart;
-}
-var ErrorCode;
-(function(ErrorCode2) {
-  ErrorCode2[ErrorCode2["NO_ERROR"] = 0] = "NO_ERROR";
-  ErrorCode2[ErrorCode2["NETWORK_ERROR"] = 1] = "NETWORK_ERROR";
-  ErrorCode2[ErrorCode2["ABORT"] = 2] = "ABORT";
-})(ErrorCode || (ErrorCode = {}));
-/**
- * @license
- * Copyright 2022 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function isRetryStatusCode(status, additionalRetryCodes) {
-  const isFiveHundredCode = status >= 500 && status < 600;
-  const extraRetryCodes = [
-    // Request Timeout: web server didn't receive full request in time.
-    408,
-    // Too Many Requests: you're getting rate-limited, basically.
-    429
-  ];
-  const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;
-  const isAdditionalRetryCode = additionalRetryCodes.indexOf(status) !== -1;
-  return isFiveHundredCode || isExtraRetryCode || isAdditionalRetryCode;
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class NetworkRequest {
-  constructor(url_, method_, headers_, body_, successCodes_, additionalRetryCodes_, callback_, errorCallback_, timeout_, progressCallback_, connectionFactory_, retry = true, isUsingEmulator = false) {
-    this.url_ = url_;
-    this.method_ = method_;
-    this.headers_ = headers_;
-    this.body_ = body_;
-    this.successCodes_ = successCodes_;
-    this.additionalRetryCodes_ = additionalRetryCodes_;
-    this.callback_ = callback_;
-    this.errorCallback_ = errorCallback_;
-    this.timeout_ = timeout_;
-    this.progressCallback_ = progressCallback_;
-    this.connectionFactory_ = connectionFactory_;
-    this.retry = retry;
-    this.isUsingEmulator = isUsingEmulator;
-    this.pendingConnection_ = null;
-    this.backoffId_ = null;
-    this.canceled_ = false;
-    this.appDelete_ = false;
-    this.promise_ = new Promise((resolve, reject) => {
-      this.resolve_ = resolve;
-      this.reject_ = reject;
-      this.start_();
-    });
-  }
-  /**
-   * Actually starts the retry loop.
-   */
-  start_() {
-    const doTheRequest = (backoffCallback, canceled2) => {
-      if (canceled2) {
-        backoffCallback(false, new RequestEndStatus(false, null, true));
-        return;
-      }
-      const connection = this.connectionFactory_();
-      this.pendingConnection_ = connection;
-      const progressListener = (progressEvent) => {
-        const loaded = progressEvent.loaded;
-        const total = progressEvent.lengthComputable ? progressEvent.total : -1;
-        if (this.progressCallback_ !== null) {
-          this.progressCallback_(loaded, total);
-        }
-      };
-      if (this.progressCallback_ !== null) {
-        connection.addUploadProgressListener(progressListener);
-      }
-      connection.send(this.url_, this.method_, this.isUsingEmulator, this.body_, this.headers_).then(() => {
-        if (this.progressCallback_ !== null) {
-          connection.removeUploadProgressListener(progressListener);
-        }
-        this.pendingConnection_ = null;
-        const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
-        const status = connection.getStatus();
-        if (!hitServer || isRetryStatusCode(status, this.additionalRetryCodes_) && this.retry) {
-          const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
-          backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));
-          return;
-        }
-        const successCode = this.successCodes_.indexOf(status) !== -1;
-        backoffCallback(true, new RequestEndStatus(successCode, connection));
-      });
-    };
-    const backoffDone = (requestWentThrough, status) => {
-      const resolve = this.resolve_;
-      const reject = this.reject_;
-      const connection = status.connection;
-      if (status.wasSuccessCode) {
-        try {
-          const result = this.callback_(connection, connection.getResponse());
-          if (isJustDef(result)) {
-            resolve(result);
-          } else {
-            resolve();
-          }
-        } catch (e) {
-          reject(e);
-        }
-      } else {
-        if (connection !== null) {
-          const err = unknown();
-          err.serverResponse = connection.getErrorText();
-          if (this.errorCallback_) {
-            reject(this.errorCallback_(connection, err));
-          } else {
-            reject(err);
-          }
-        } else {
-          if (status.canceled) {
-            const err = this.appDelete_ ? appDeleted() : canceled();
-            reject(err);
-          } else {
-            const err = retryLimitExceeded();
-            reject(err);
-          }
-        }
-      }
-    };
-    if (this.canceled_) {
-      backoffDone(false, new RequestEndStatus(false, null, true));
-    } else {
-      this.backoffId_ = start(doTheRequest, backoffDone, this.timeout_);
-    }
-  }
-  /** @inheritDoc */
-  getPromise() {
-    return this.promise_;
-  }
-  /** @inheritDoc */
-  cancel(appDelete) {
-    this.canceled_ = true;
-    this.appDelete_ = appDelete || false;
-    if (this.backoffId_ !== null) {
-      stop(this.backoffId_);
-    }
-    if (this.pendingConnection_ !== null) {
-      this.pendingConnection_.abort();
-    }
-  }
-}
-class RequestEndStatus {
-  constructor(wasSuccessCode, connection, canceled2) {
-    this.wasSuccessCode = wasSuccessCode;
-    this.connection = connection;
-    this.canceled = !!canceled2;
-  }
-}
-function addAuthHeader_(headers, authToken) {
-  if (authToken !== null && authToken.length > 0) {
-    headers["Authorization"] = "Firebase " + authToken;
-  }
-}
-function addVersionHeader_(headers, firebaseVersion) {
-  headers["X-Firebase-Storage-Version"] = "webjs/" + (firebaseVersion ?? "AppManager");
-}
-function addGmpidHeader_(headers, appId) {
-  if (appId) {
-    headers["X-Firebase-GMPID"] = appId;
-  }
-}
-function addAppCheckHeader_(headers, appCheckToken) {
-  if (appCheckToken !== null) {
-    headers["X-Firebase-AppCheck"] = appCheckToken;
-  }
-}
-function makeRequest(requestInfo, appId, authToken, appCheckToken, requestFactory, firebaseVersion, retry = true, isUsingEmulator = false) {
-  const queryPart = makeQueryString(requestInfo.urlParams);
-  const url = requestInfo.url + queryPart;
-  const headers = Object.assign({}, requestInfo.headers);
-  addGmpidHeader_(headers, appId);
-  addAuthHeader_(headers, authToken);
-  addVersionHeader_(headers, firebaseVersion);
-  addAppCheckHeader_(headers, appCheckToken);
-  return new NetworkRequest(url, requestInfo.method, headers, requestInfo.body, requestInfo.successCodes, requestInfo.additionalRetryCodes, requestInfo.handler, requestInfo.errorHandler, requestInfo.timeout, requestInfo.progressCallback, requestFactory, retry, isUsingEmulator);
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function getBlobBuilder() {
-  if (typeof BlobBuilder !== "undefined") {
-    return BlobBuilder;
-  } else if (typeof WebKitBlobBuilder !== "undefined") {
-    return WebKitBlobBuilder;
-  } else {
-    return void 0;
-  }
-}
-function getBlob$1(...args) {
-  const BlobBuilder2 = getBlobBuilder();
-  if (BlobBuilder2 !== void 0) {
-    const bb = new BlobBuilder2();
-    for (let i = 0; i < args.length; i++) {
-      bb.append(args[i]);
-    }
-    return bb.getBlob();
-  } else {
-    if (isNativeBlobDefined()) {
-      return new Blob(args);
-    } else {
-      throw new StorageError(StorageErrorCode.UNSUPPORTED_ENVIRONMENT, "This browser doesn't seem to support creating Blobs");
-    }
-  }
-}
-function sliceBlob(blob, start2, end) {
-  if (blob.webkitSlice) {
-    return blob.webkitSlice(start2, end);
-  } else if (blob.mozSlice) {
-    return blob.mozSlice(start2, end);
-  } else if (blob.slice) {
-    return blob.slice(start2, end);
-  }
-  return null;
-}
-/**
- * @license
- * Copyright 2021 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function decodeBase64(encoded) {
-  if (typeof atob === "undefined") {
-    throw missingPolyFill("base-64");
-  }
-  return atob(encoded);
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const StringFormat = {
-  /**
-   * Indicates the string should be interpreted "raw", that is, as normal text.
-   * The string will be interpreted as UTF-16, then uploaded as a UTF-8 byte
-   * sequence.
-   * Example: The string 'Hello! \\ud83d\\ude0a' becomes the byte sequence
-   * 48 65 6c 6c 6f 21 20 f0 9f 98 8a
-   */
-  RAW: "raw",
-  /**
-   * Indicates the string should be interpreted as base64-encoded data.
-   * Padding characters (trailing '='s) are optional.
-   * Example: The string 'rWmO++E6t7/rlw==' becomes the byte sequence
-   * ad 69 8e fb e1 3a b7 bf eb 97
-   */
-  BASE64: "base64",
-  /**
-   * Indicates the string should be interpreted as base64url-encoded data.
-   * Padding characters (trailing '='s) are optional.
-   * Example: The string 'rWmO--E6t7_rlw==' becomes the byte sequence
-   * ad 69 8e fb e1 3a b7 bf eb 97
-   */
-  BASE64URL: "base64url",
-  /**
-   * Indicates the string is a data URL, such as one obtained from
-   * canvas.toDataURL().
-   * Example: the string 'data:application/octet-stream;base64,aaaa'
-   * becomes the byte sequence
-   * 69 a6 9a
-   * (the content-type "application/octet-stream" is also applied, but can
-   * be overridden in the metadata object).
-   */
-  DATA_URL: "data_url"
-};
-class StringData {
-  constructor(data, contentType) {
-    this.data = data;
-    this.contentType = contentType || null;
-  }
-}
-function dataFromString(format, stringData) {
-  switch (format) {
-    case StringFormat.RAW:
-      return new StringData(utf8Bytes_(stringData));
-    case StringFormat.BASE64:
-    case StringFormat.BASE64URL:
-      return new StringData(base64Bytes_(format, stringData));
-    case StringFormat.DATA_URL:
-      return new StringData(dataURLBytes_(stringData), dataURLContentType_(stringData));
-  }
-  throw unknown();
-}
-function utf8Bytes_(value) {
-  const b = [];
-  for (let i = 0; i < value.length; i++) {
-    let c = value.charCodeAt(i);
-    if (c <= 127) {
-      b.push(c);
-    } else {
-      if (c <= 2047) {
-        b.push(192 | c >> 6, 128 | c & 63);
-      } else {
-        if ((c & 64512) === 55296) {
-          const valid = i < value.length - 1 && (value.charCodeAt(i + 1) & 64512) === 56320;
-          if (!valid) {
-            b.push(239, 191, 189);
-          } else {
-            const hi = c;
-            const lo = value.charCodeAt(++i);
-            c = 65536 | (hi & 1023) << 10 | lo & 1023;
-            b.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
-          }
-        } else {
-          if ((c & 64512) === 56320) {
-            b.push(239, 191, 189);
-          } else {
-            b.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
-          }
-        }
-      }
-    }
-  }
-  return new Uint8Array(b);
-}
-function percentEncodedBytes_(value) {
-  let decoded;
-  try {
-    decoded = decodeURIComponent(value);
-  } catch (e) {
-    throw invalidFormat(StringFormat.DATA_URL, "Malformed data URL.");
-  }
-  return utf8Bytes_(decoded);
-}
-function base64Bytes_(format, value) {
-  switch (format) {
-    case StringFormat.BASE64: {
-      const hasMinus = value.indexOf("-") !== -1;
-      const hasUnder = value.indexOf("_") !== -1;
-      if (hasMinus || hasUnder) {
-        const invalidChar = hasMinus ? "-" : "_";
-        throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64url encoded?");
-      }
-      break;
-    }
-    case StringFormat.BASE64URL: {
-      const hasPlus = value.indexOf("+") !== -1;
-      const hasSlash = value.indexOf("/") !== -1;
-      if (hasPlus || hasSlash) {
-        const invalidChar = hasPlus ? "+" : "/";
-        throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64 encoded?");
-      }
-      value = value.replace(/-/g, "+").replace(/_/g, "/");
-      break;
-    }
-  }
-  let bytes;
-  try {
-    bytes = decodeBase64(value);
-  } catch (e) {
-    if (e.message.includes("polyfill")) {
-      throw e;
-    }
-    throw invalidFormat(format, "Invalid character found");
-  }
-  const array = new Uint8Array(bytes.length);
-  for (let i = 0; i < bytes.length; i++) {
-    array[i] = bytes.charCodeAt(i);
-  }
-  return array;
-}
-class DataURLParts {
-  constructor(dataURL) {
-    this.base64 = false;
-    this.contentType = null;
-    const matches = dataURL.match(/^data:([^,]+)?,/);
-    if (matches === null) {
-      throw invalidFormat(StringFormat.DATA_URL, "Must be formatted 'data:[<mediatype>][;base64],<data>");
-    }
-    const middle = matches[1] || null;
-    if (middle != null) {
-      this.base64 = endsWith(middle, ";base64");
-      this.contentType = this.base64 ? middle.substring(0, middle.length - ";base64".length) : middle;
-    }
-    this.rest = dataURL.substring(dataURL.indexOf(",") + 1);
-  }
-}
-function dataURLBytes_(dataUrl) {
-  const parts = new DataURLParts(dataUrl);
-  if (parts.base64) {
-    return base64Bytes_(StringFormat.BASE64, parts.rest);
-  } else {
-    return percentEncodedBytes_(parts.rest);
-  }
-}
-function dataURLContentType_(dataUrl) {
-  const parts = new DataURLParts(dataUrl);
-  return parts.contentType;
-}
-function endsWith(s, end) {
-  const longEnough = s.length >= end.length;
-  if (!longEnough) {
-    return false;
-  }
-  return s.substring(s.length - end.length) === end;
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class FbsBlob {
-  constructor(data, elideCopy) {
-    let size = 0;
-    let blobType = "";
-    if (isNativeBlob(data)) {
-      this.data_ = data;
-      size = data.size;
-      blobType = data.type;
-    } else if (data instanceof ArrayBuffer) {
-      if (elideCopy) {
-        this.data_ = new Uint8Array(data);
-      } else {
-        this.data_ = new Uint8Array(data.byteLength);
-        this.data_.set(new Uint8Array(data));
-      }
-      size = this.data_.length;
-    } else if (data instanceof Uint8Array) {
-      if (elideCopy) {
-        this.data_ = data;
-      } else {
-        this.data_ = new Uint8Array(data.length);
-        this.data_.set(data);
-      }
-      size = data.length;
-    }
-    this.size_ = size;
-    this.type_ = blobType;
-  }
-  size() {
-    return this.size_;
-  }
-  type() {
-    return this.type_;
-  }
-  slice(startByte, endByte) {
-    if (isNativeBlob(this.data_)) {
-      const realBlob = this.data_;
-      const sliced = sliceBlob(realBlob, startByte, endByte);
-      if (sliced === null) {
-        return null;
-      }
-      return new FbsBlob(sliced);
-    } else {
-      const slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte);
-      return new FbsBlob(slice, true);
-    }
-  }
-  static getBlob(...args) {
-    if (isNativeBlobDefined()) {
-      const blobby = args.map((val) => {
-        if (val instanceof FbsBlob) {
-          return val.data_;
-        } else {
-          return val;
-        }
-      });
-      return new FbsBlob(getBlob$1.apply(null, blobby));
-    } else {
-      const uint8Arrays = args.map((val) => {
-        if (isString(val)) {
-          return dataFromString(StringFormat.RAW, val).data;
-        } else {
-          return val.data_;
-        }
-      });
-      let finalLength = 0;
-      uint8Arrays.forEach((array) => {
-        finalLength += array.byteLength;
-      });
-      const merged = new Uint8Array(finalLength);
-      let index = 0;
-      uint8Arrays.forEach((array) => {
-        for (let i = 0; i < array.length; i++) {
-          merged[index++] = array[i];
-        }
-      });
-      return new FbsBlob(merged, true);
-    }
-  }
-  uploadData() {
-    return this.data_;
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function jsonObjectOrNull(s) {
-  let obj;
-  try {
-    obj = JSON.parse(s);
-  } catch (e) {
-    return null;
-  }
-  if (isNonArrayObject(obj)) {
-    return obj;
-  } else {
-    return null;
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function parent(path) {
-  if (path.length === 0) {
-    return null;
-  }
-  const index = path.lastIndexOf("/");
-  if (index === -1) {
-    return "";
-  }
-  const newPath = path.slice(0, index);
-  return newPath;
-}
-function child(path, childPath) {
-  const canonicalChildPath = childPath.split("/").filter((component) => component.length > 0).join("/");
-  if (path.length === 0) {
-    return canonicalChildPath;
-  } else {
-    return path + "/" + canonicalChildPath;
-  }
-}
-function lastComponent(path) {
-  const index = path.lastIndexOf("/", path.length - 2);
-  if (index === -1) {
-    return path;
-  } else {
-    return path.slice(index + 1);
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function noXform_(metadata, value) {
-  return value;
-}
-class Mapping {
-  constructor(server, local, writable, xform) {
-    this.server = server;
-    this.local = local || server;
-    this.writable = !!writable;
-    this.xform = xform || noXform_;
-  }
-}
-let mappings_ = null;
-function xformPath(fullPath) {
-  if (!isString(fullPath) || fullPath.length < 2) {
-    return fullPath;
-  } else {
-    return lastComponent(fullPath);
-  }
-}
-function getMappings() {
-  if (mappings_) {
-    return mappings_;
-  }
-  const mappings = [];
-  mappings.push(new Mapping("bucket"));
-  mappings.push(new Mapping("generation"));
-  mappings.push(new Mapping("metageneration"));
-  mappings.push(new Mapping("name", "fullPath", true));
-  function mappingsXformPath(_metadata, fullPath) {
-    return xformPath(fullPath);
-  }
-  const nameMapping = new Mapping("name");
-  nameMapping.xform = mappingsXformPath;
-  mappings.push(nameMapping);
-  function xformSize(_metadata, size) {
-    if (size !== void 0) {
-      return Number(size);
-    } else {
-      return size;
-    }
-  }
-  const sizeMapping = new Mapping("size");
-  sizeMapping.xform = xformSize;
-  mappings.push(sizeMapping);
-  mappings.push(new Mapping("timeCreated"));
-  mappings.push(new Mapping("updated"));
-  mappings.push(new Mapping("md5Hash", null, true));
-  mappings.push(new Mapping("cacheControl", null, true));
-  mappings.push(new Mapping("contentDisposition", null, true));
-  mappings.push(new Mapping("contentEncoding", null, true));
-  mappings.push(new Mapping("contentLanguage", null, true));
-  mappings.push(new Mapping("contentType", null, true));
-  mappings.push(new Mapping("metadata", "customMetadata", true));
-  mappings_ = mappings;
-  return mappings_;
-}
-function addRef(metadata, service) {
-  function generateRef() {
-    const bucket = metadata["bucket"];
-    const path = metadata["fullPath"];
-    const loc = new Location(bucket, path);
-    return service._makeStorageReference(loc);
-  }
-  Object.defineProperty(metadata, "ref", { get: generateRef });
-}
-function fromResource(service, resource, mappings) {
-  const metadata = {};
-  metadata["type"] = "file";
-  const len = mappings.length;
-  for (let i = 0; i < len; i++) {
-    const mapping = mappings[i];
-    metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]);
-  }
-  addRef(metadata, service);
-  return metadata;
-}
-function fromResourceString(service, resourceString, mappings) {
-  const obj = jsonObjectOrNull(resourceString);
-  if (obj === null) {
-    return null;
-  }
-  const resource = obj;
-  return fromResource(service, resource, mappings);
-}
-function downloadUrlFromResourceString(metadata, resourceString, host, protocol) {
-  const obj = jsonObjectOrNull(resourceString);
-  if (obj === null) {
-    return null;
-  }
-  if (!isString(obj["downloadTokens"])) {
-    return null;
-  }
-  const tokens = obj["downloadTokens"];
-  if (tokens.length === 0) {
-    return null;
-  }
-  const encode = encodeURIComponent;
-  const tokensList = tokens.split(",");
-  const urls = tokensList.map((token) => {
-    const bucket = metadata["bucket"];
-    const path = metadata["fullPath"];
-    const urlPart = "/b/" + encode(bucket) + "/o/" + encode(path);
-    const base = makeUrl(urlPart, host, protocol);
-    const queryString = makeQueryString({
-      alt: "media",
-      token
-    });
-    return base + queryString;
-  });
-  return urls[0];
-}
-function toResourceString(metadata, mappings) {
-  const resource = {};
-  const len = mappings.length;
-  for (let i = 0; i < len; i++) {
-    const mapping = mappings[i];
-    if (mapping.writable) {
-      resource[mapping.server] = metadata[mapping.local];
-    }
-  }
-  return JSON.stringify(resource);
-}
-class RequestInfo {
-  constructor(url, method, handler, timeout) {
-    this.url = url;
-    this.method = method;
-    this.handler = handler;
-    this.timeout = timeout;
-    this.urlParams = {};
-    this.headers = {};
-    this.body = null;
-    this.errorHandler = null;
-    this.progressCallback = null;
-    this.successCodes = [200];
-    this.additionalRetryCodes = [];
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function handlerCheck(cndn) {
-  if (!cndn) {
-    throw unknown();
-  }
-}
-function metadataHandler(service, mappings) {
-  function handler(xhr, text) {
-    const metadata = fromResourceString(service, text, mappings);
-    handlerCheck(metadata !== null);
-    return metadata;
-  }
-  return handler;
-}
-function downloadUrlHandler(service, mappings) {
-  function handler(xhr, text) {
-    const metadata = fromResourceString(service, text, mappings);
-    handlerCheck(metadata !== null);
-    return downloadUrlFromResourceString(metadata, text, service.host, service._protocol);
-  }
-  return handler;
-}
-function sharedErrorHandler(location) {
-  function errorHandler(xhr, err) {
-    let newErr;
-    if (xhr.getStatus() === 401) {
-      if (
-        // This exact message string is the only consistent part of the
-        // server's error response that identifies it as an App Check error.
-        xhr.getErrorText().includes("Firebase App Check token is invalid")
-      ) {
-        newErr = unauthorizedApp();
-      } else {
-        newErr = unauthenticated();
-      }
-    } else {
-      if (xhr.getStatus() === 402) {
-        newErr = quotaExceeded(location.bucket);
-      } else {
-        if (xhr.getStatus() === 403) {
-          newErr = unauthorized(location.path);
-        } else {
-          newErr = err;
-        }
-      }
-    }
-    newErr.status = xhr.getStatus();
-    newErr.serverResponse = err.serverResponse;
-    return newErr;
-  }
-  return errorHandler;
-}
-function objectErrorHandler(location) {
-  const shared = sharedErrorHandler(location);
-  function errorHandler(xhr, err) {
-    let newErr = shared(xhr, err);
-    if (xhr.getStatus() === 404) {
-      newErr = objectNotFound(location.path);
-    }
-    newErr.serverResponse = err.serverResponse;
-    return newErr;
-  }
-  return errorHandler;
-}
-function getMetadata$2(service, location, mappings) {
-  const urlPart = location.fullServerUrl();
-  const url = makeUrl(urlPart, service.host, service._protocol);
-  const method = "GET";
-  const timeout = service.maxOperationRetryTime;
-  const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout);
-  requestInfo.errorHandler = objectErrorHandler(location);
-  return requestInfo;
-}
-function getDownloadUrl(service, location, mappings) {
-  const urlPart = location.fullServerUrl();
-  const url = makeUrl(urlPart, service.host, service._protocol);
-  const method = "GET";
-  const timeout = service.maxOperationRetryTime;
-  const requestInfo = new RequestInfo(url, method, downloadUrlHandler(service, mappings), timeout);
-  requestInfo.errorHandler = objectErrorHandler(location);
-  return requestInfo;
-}
-function deleteObject$2(service, location) {
-  const urlPart = location.fullServerUrl();
-  const url = makeUrl(urlPart, service.host, service._protocol);
-  const method = "DELETE";
-  const timeout = service.maxOperationRetryTime;
-  function handler(_xhr, _text) {
-  }
-  const requestInfo = new RequestInfo(url, method, handler, timeout);
-  requestInfo.successCodes = [200, 204];
-  requestInfo.errorHandler = objectErrorHandler(location);
-  return requestInfo;
-}
-function determineContentType_(metadata, blob) {
-  return metadata && metadata["contentType"] || blob && blob.type() || "application/octet-stream";
-}
-function metadataForUpload_(location, blob, metadata) {
-  const metadataClone = Object.assign({}, metadata);
-  metadataClone["fullPath"] = location.path;
-  metadataClone["size"] = blob.size();
-  if (!metadataClone["contentType"]) {
-    metadataClone["contentType"] = determineContentType_(null, blob);
-  }
-  return metadataClone;
-}
-function multipartUpload(service, location, mappings, blob, metadata) {
-  const urlPart = location.bucketOnlyServerUrl();
-  const headers = {
-    "X-Goog-Upload-Protocol": "multipart"
-  };
-  function genBoundary() {
-    let str = "";
-    for (let i = 0; i < 2; i++) {
-      str = str + Math.random().toString().slice(2);
-    }
-    return str;
-  }
-  const boundary = genBoundary();
-  headers["Content-Type"] = "multipart/related; boundary=" + boundary;
-  const metadata_ = metadataForUpload_(location, blob, metadata);
-  const metadataString = toResourceString(metadata_, mappings);
-  const preBlobPart = "--" + boundary + "\r\nContent-Type: application/json; charset=utf-8\r\n\r\n" + metadataString + "\r\n--" + boundary + "\r\nContent-Type: " + metadata_["contentType"] + "\r\n\r\n";
-  const postBlobPart = "\r\n--" + boundary + "--";
-  const body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart);
-  if (body === null) {
-    throw cannotSliceBlob();
-  }
-  const urlParams = { name: metadata_["fullPath"] };
-  const url = makeUrl(urlPart, service.host, service._protocol);
-  const method = "POST";
-  const timeout = service.maxUploadRetryTime;
-  const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout);
-  requestInfo.urlParams = urlParams;
-  requestInfo.headers = headers;
-  requestInfo.body = body.uploadData();
-  requestInfo.errorHandler = sharedErrorHandler(location);
-  return requestInfo;
-}
-class ResumableUploadStatus {
-  constructor(current, total, finalized, metadata) {
-    this.current = current;
-    this.total = total;
-    this.finalized = !!finalized;
-    this.metadata = metadata || null;
-  }
-}
-function checkResumeHeader_(xhr, allowed) {
-  let status = null;
-  try {
-    status = xhr.getResponseHeader("X-Goog-Upload-Status");
-  } catch (e) {
-    handlerCheck(false);
-  }
-  const allowedStatus = allowed || ["active"];
-  handlerCheck(!!status && allowedStatus.indexOf(status) !== -1);
-  return status;
-}
-function createResumableUpload(service, location, mappings, blob, metadata) {
-  const urlPart = location.bucketOnlyServerUrl();
-  const metadataForUpload = metadataForUpload_(location, blob, metadata);
-  const urlParams = { name: metadataForUpload["fullPath"] };
-  const url = makeUrl(urlPart, service.host, service._protocol);
-  const method = "POST";
-  const headers = {
-    "X-Goog-Upload-Protocol": "resumable",
-    "X-Goog-Upload-Command": "start",
-    "X-Goog-Upload-Header-Content-Length": `${blob.size()}`,
-    "X-Goog-Upload-Header-Content-Type": metadataForUpload["contentType"],
-    "Content-Type": "application/json; charset=utf-8"
-  };
-  const body = toResourceString(metadataForUpload, mappings);
-  const timeout = service.maxUploadRetryTime;
-  function handler(xhr) {
-    checkResumeHeader_(xhr);
-    let url2;
-    try {
-      url2 = xhr.getResponseHeader("X-Goog-Upload-URL");
-    } catch (e) {
-      handlerCheck(false);
-    }
-    handlerCheck(isString(url2));
-    return url2;
-  }
-  const requestInfo = new RequestInfo(url, method, handler, timeout);
-  requestInfo.urlParams = urlParams;
-  requestInfo.headers = headers;
-  requestInfo.body = body;
-  requestInfo.errorHandler = sharedErrorHandler(location);
-  return requestInfo;
-}
-function getResumableUploadStatus(service, location, url, blob) {
-  const headers = { "X-Goog-Upload-Command": "query" };
-  function handler(xhr) {
-    const status = checkResumeHeader_(xhr, ["active", "final"]);
-    let sizeString = null;
-    try {
-      sizeString = xhr.getResponseHeader("X-Goog-Upload-Size-Received");
-    } catch (e) {
-      handlerCheck(false);
-    }
-    if (!sizeString) {
-      handlerCheck(false);
-    }
-    const size = Number(sizeString);
-    handlerCheck(!isNaN(size));
-    return new ResumableUploadStatus(size, blob.size(), status === "final");
-  }
-  const method = "POST";
-  const timeout = service.maxUploadRetryTime;
-  const requestInfo = new RequestInfo(url, method, handler, timeout);
-  requestInfo.headers = headers;
-  requestInfo.errorHandler = sharedErrorHandler(location);
-  return requestInfo;
-}
-const RESUMABLE_UPLOAD_CHUNK_SIZE = 256 * 1024;
-function continueResumableUpload(location, service, url, blob, chunkSize, mappings, status, progressCallback) {
-  const status_ = new ResumableUploadStatus(0, 0);
-  if (status) {
-    status_.current = status.current;
-    status_.total = status.total;
-  } else {
-    status_.current = 0;
-    status_.total = blob.size();
-  }
-  if (blob.size() !== status_.total) {
-    throw serverFileWrongSize();
-  }
-  const bytesLeft = status_.total - status_.current;
-  let bytesToUpload = bytesLeft;
-  if (chunkSize > 0) {
-    bytesToUpload = Math.min(bytesToUpload, chunkSize);
-  }
-  const startByte = status_.current;
-  const endByte = startByte + bytesToUpload;
-  let uploadCommand = "";
-  if (bytesToUpload === 0) {
-    uploadCommand = "finalize";
-  } else if (bytesLeft === bytesToUpload) {
-    uploadCommand = "upload, finalize";
-  } else {
-    uploadCommand = "upload";
-  }
-  const headers = {
-    "X-Goog-Upload-Command": uploadCommand,
-    "X-Goog-Upload-Offset": `${status_.current}`
-  };
-  const body = blob.slice(startByte, endByte);
-  if (body === null) {
-    throw cannotSliceBlob();
-  }
-  function handler(xhr, text) {
-    const uploadStatus = checkResumeHeader_(xhr, ["active", "final"]);
-    const newCurrent = status_.current + bytesToUpload;
-    const size = blob.size();
-    let metadata;
-    if (uploadStatus === "final") {
-      metadata = metadataHandler(service, mappings)(xhr, text);
-    } else {
-      metadata = null;
-    }
-    return new ResumableUploadStatus(newCurrent, size, uploadStatus === "final", metadata);
-  }
-  const method = "POST";
-  const timeout = service.maxUploadRetryTime;
-  const requestInfo = new RequestInfo(url, method, handler, timeout);
-  requestInfo.headers = headers;
-  requestInfo.body = body.uploadData();
-  requestInfo.progressCallback = progressCallback || null;
-  requestInfo.errorHandler = sharedErrorHandler(location);
-  return requestInfo;
-}
-const TaskState = {
-  /** The task is currently transferring data. */
-  RUNNING: "running",
-  /** The task was paused by the user. */
-  PAUSED: "paused",
-  /** The task completed successfully. */
-  SUCCESS: "success",
-  /** The task was canceled. */
-  CANCELED: "canceled",
-  /** The task failed with an error. */
-  ERROR: "error"
-};
-function taskStateFromInternalTaskState(state) {
-  switch (state) {
-    case "running":
-    case "pausing":
-    case "canceling":
-      return TaskState.RUNNING;
-    case "paused":
-      return TaskState.PAUSED;
-    case "success":
-      return TaskState.SUCCESS;
-    case "canceled":
-      return TaskState.CANCELED;
-    case "error":
-      return TaskState.ERROR;
-    default:
-      return TaskState.ERROR;
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class Observer {
-  constructor(nextOrObserver, error, complete) {
-    const asFunctions = isFunction(nextOrObserver) || error != null || complete != null;
-    if (asFunctions) {
-      this.next = nextOrObserver;
-      this.error = error ?? void 0;
-      this.complete = complete ?? void 0;
-    } else {
-      const observer = nextOrObserver;
-      this.next = observer.next;
-      this.error = observer.error;
-      this.complete = observer.complete;
-    }
-  }
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function async(f) {
-  return (...argsToForward) => {
-    Promise.resolve().then(() => f(...argsToForward));
-  };
-}
-class XhrConnection {
-  constructor() {
-    this.sent_ = false;
-    this.xhr_ = new XMLHttpRequest();
-    this.initXhr();
-    this.errorCode_ = ErrorCode.NO_ERROR;
-    this.sendPromise_ = new Promise((resolve) => {
-      this.xhr_.addEventListener("abort", () => {
-        this.errorCode_ = ErrorCode.ABORT;
-        resolve();
-      });
-      this.xhr_.addEventListener("error", () => {
-        this.errorCode_ = ErrorCode.NETWORK_ERROR;
-        resolve();
-      });
-      this.xhr_.addEventListener("load", () => {
-        resolve();
-      });
-    });
-  }
-  send(url, method, isUsingEmulator, body, headers) {
-    if (this.sent_) {
-      throw internalError("cannot .send() more than once");
-    }
-    if (isCloudWorkstation(url) && isUsingEmulator) {
-      this.xhr_.withCredentials = true;
-    }
-    this.sent_ = true;
-    this.xhr_.open(method, url, true);
-    if (headers !== void 0) {
-      for (const key in headers) {
-        if (headers.hasOwnProperty(key)) {
-          this.xhr_.setRequestHeader(key, headers[key].toString());
-        }
-      }
-    }
-    if (body !== void 0) {
-      this.xhr_.send(body);
-    } else {
-      this.xhr_.send();
-    }
-    return this.sendPromise_;
-  }
-  getErrorCode() {
-    if (!this.sent_) {
-      throw internalError("cannot .getErrorCode() before sending");
-    }
-    return this.errorCode_;
-  }
-  getStatus() {
-    if (!this.sent_) {
-      throw internalError("cannot .getStatus() before sending");
-    }
-    try {
-      return this.xhr_.status;
-    } catch (e) {
-      return -1;
-    }
-  }
-  getResponse() {
-    if (!this.sent_) {
-      throw internalError("cannot .getResponse() before sending");
-    }
-    return this.xhr_.response;
-  }
-  getErrorText() {
-    if (!this.sent_) {
-      throw internalError("cannot .getErrorText() before sending");
-    }
-    return this.xhr_.statusText;
-  }
-  /** Aborts the request. */
-  abort() {
-    this.xhr_.abort();
-  }
-  getResponseHeader(header) {
-    return this.xhr_.getResponseHeader(header);
-  }
-  addUploadProgressListener(listener) {
-    if (this.xhr_.upload != null) {
-      this.xhr_.upload.addEventListener("progress", listener);
-    }
-  }
-  removeUploadProgressListener(listener) {
-    if (this.xhr_.upload != null) {
-      this.xhr_.upload.removeEventListener("progress", listener);
-    }
-  }
-}
-class XhrTextConnection extends XhrConnection {
-  initXhr() {
-    this.xhr_.responseType = "text";
-  }
-}
-function newTextConnection() {
-  return new XhrTextConnection();
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class UploadTask {
-  isExponentialBackoffExpired() {
-    return this.sleepTime > this.maxSleepTime;
-  }
-  /**
-   * @param ref - The firebaseStorage.Reference object this task came
-   *     from, untyped to avoid cyclic dependencies.
-   * @param blob - The blob to upload.
-   */
-  constructor(ref2, blob, metadata = null) {
-    this._transferred = 0;
-    this._needToFetchStatus = false;
-    this._needToFetchMetadata = false;
-    this._observers = [];
-    this._error = void 0;
-    this._uploadUrl = void 0;
-    this._request = void 0;
-    this._chunkMultiplier = 1;
-    this._resolve = void 0;
-    this._reject = void 0;
-    this._ref = ref2;
-    this._blob = blob;
-    this._metadata = metadata;
-    this._mappings = getMappings();
-    this._resumable = this._shouldDoResumable(this._blob);
-    this._state = "running";
-    this._errorHandler = (error) => {
-      this._request = void 0;
-      this._chunkMultiplier = 1;
-      if (error._codeEquals(StorageErrorCode.CANCELED)) {
-        this._needToFetchStatus = true;
-        this.completeTransitions_();
-      } else {
-        const backoffExpired = this.isExponentialBackoffExpired();
-        if (isRetryStatusCode(error.status, [])) {
-          if (backoffExpired) {
-            error = retryLimitExceeded();
-          } else {
-            this.sleepTime = Math.max(this.sleepTime * 2, DEFAULT_MIN_SLEEP_TIME_MILLIS);
-            this._needToFetchStatus = true;
-            this.completeTransitions_();
-            return;
-          }
-        }
-        this._error = error;
-        this._transition(
-          "error"
-          /* InternalTaskState.ERROR */
-        );
-      }
-    };
-    this._metadataErrorHandler = (error) => {
-      this._request = void 0;
-      if (error._codeEquals(StorageErrorCode.CANCELED)) {
-        this.completeTransitions_();
-      } else {
-        this._error = error;
-        this._transition(
-          "error"
-          /* InternalTaskState.ERROR */
-        );
-      }
-    };
-    this.sleepTime = 0;
-    this.maxSleepTime = this._ref.storage.maxUploadRetryTime;
-    this._promise = new Promise((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
-      this._start();
-    });
-    this._promise.then(null, () => {
-    });
-  }
-  _makeProgressCallback() {
-    const sizeBefore = this._transferred;
-    return (loaded) => this._updateProgress(sizeBefore + loaded);
-  }
-  _shouldDoResumable(blob) {
-    return blob.size() > 256 * 1024;
-  }
-  _start() {
-    if (this._state !== "running") {
-      return;
-    }
-    if (this._request !== void 0) {
-      return;
-    }
-    if (this._resumable) {
-      if (this._uploadUrl === void 0) {
-        this._createResumable();
-      } else {
-        if (this._needToFetchStatus) {
-          this._fetchStatus();
-        } else {
-          if (this._needToFetchMetadata) {
-            this._fetchMetadata();
-          } else {
-            this.pendingTimeout = setTimeout(() => {
-              this.pendingTimeout = void 0;
-              this._continueUpload();
-            }, this.sleepTime);
-          }
-        }
-      }
-    } else {
-      this._oneShotUpload();
-    }
-  }
-  _resolveToken(callback) {
-    Promise.all([
-      this._ref.storage._getAuthToken(),
-      this._ref.storage._getAppCheckToken()
-    ]).then(([authToken, appCheckToken]) => {
-      switch (this._state) {
-        case "running":
-          callback(authToken, appCheckToken);
-          break;
-        case "canceling":
-          this._transition(
-            "canceled"
-            /* InternalTaskState.CANCELED */
-          );
-          break;
-        case "pausing":
-          this._transition(
-            "paused"
-            /* InternalTaskState.PAUSED */
-          );
-          break;
-      }
-    });
-  }
-  // TODO(andysoto): assert false
-  _createResumable() {
-    this._resolveToken((authToken, appCheckToken) => {
-      const requestInfo = createResumableUpload(this._ref.storage, this._ref._location, this._mappings, this._blob, this._metadata);
-      const createRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
-      this._request = createRequest;
-      createRequest.getPromise().then((url) => {
-        this._request = void 0;
-        this._uploadUrl = url;
-        this._needToFetchStatus = false;
-        this.completeTransitions_();
-      }, this._errorHandler);
-    });
-  }
-  _fetchStatus() {
-    const url = this._uploadUrl;
-    this._resolveToken((authToken, appCheckToken) => {
-      const requestInfo = getResumableUploadStatus(this._ref.storage, this._ref._location, url, this._blob);
-      const statusRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
-      this._request = statusRequest;
-      statusRequest.getPromise().then((status) => {
-        status = status;
-        this._request = void 0;
-        this._updateProgress(status.current);
-        this._needToFetchStatus = false;
-        if (status.finalized) {
-          this._needToFetchMetadata = true;
-        }
-        this.completeTransitions_();
-      }, this._errorHandler);
-    });
-  }
-  _continueUpload() {
-    const chunkSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier;
-    const status = new ResumableUploadStatus(this._transferred, this._blob.size());
-    const url = this._uploadUrl;
-    this._resolveToken((authToken, appCheckToken) => {
-      let requestInfo;
-      try {
-        requestInfo = continueResumableUpload(this._ref._location, this._ref.storage, url, this._blob, chunkSize, this._mappings, status, this._makeProgressCallback());
-      } catch (e) {
-        this._error = e;
-        this._transition(
-          "error"
-          /* InternalTaskState.ERROR */
-        );
-        return;
-      }
-      const uploadRequest = this._ref.storage._makeRequest(
-        requestInfo,
-        newTextConnection,
-        authToken,
-        appCheckToken,
-        /*retry=*/
-        false
-        // Upload requests should not be retried as each retry should be preceded by another query request. Which is handled in this file.
-      );
-      this._request = uploadRequest;
-      uploadRequest.getPromise().then((newStatus) => {
-        this._increaseMultiplier();
-        this._request = void 0;
-        this._updateProgress(newStatus.current);
-        if (newStatus.finalized) {
-          this._metadata = newStatus.metadata;
-          this._transition(
-            "success"
-            /* InternalTaskState.SUCCESS */
-          );
-        } else {
-          this.completeTransitions_();
-        }
-      }, this._errorHandler);
-    });
-  }
-  _increaseMultiplier() {
-    const currentSize = RESUMABLE_UPLOAD_CHUNK_SIZE * this._chunkMultiplier;
-    if (currentSize * 2 < 32 * 1024 * 1024) {
-      this._chunkMultiplier *= 2;
-    }
-  }
-  _fetchMetadata() {
-    this._resolveToken((authToken, appCheckToken) => {
-      const requestInfo = getMetadata$2(this._ref.storage, this._ref._location, this._mappings);
-      const metadataRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
-      this._request = metadataRequest;
-      metadataRequest.getPromise().then((metadata) => {
-        this._request = void 0;
-        this._metadata = metadata;
-        this._transition(
-          "success"
-          /* InternalTaskState.SUCCESS */
-        );
-      }, this._metadataErrorHandler);
-    });
-  }
-  _oneShotUpload() {
-    this._resolveToken((authToken, appCheckToken) => {
-      const requestInfo = multipartUpload(this._ref.storage, this._ref._location, this._mappings, this._blob, this._metadata);
-      const multipartRequest = this._ref.storage._makeRequest(requestInfo, newTextConnection, authToken, appCheckToken);
-      this._request = multipartRequest;
-      multipartRequest.getPromise().then((metadata) => {
-        this._request = void 0;
-        this._metadata = metadata;
-        this._updateProgress(this._blob.size());
-        this._transition(
-          "success"
-          /* InternalTaskState.SUCCESS */
-        );
-      }, this._errorHandler);
-    });
-  }
-  _updateProgress(transferred) {
-    const old = this._transferred;
-    this._transferred = transferred;
-    if (this._transferred !== old) {
-      this._notifyObservers();
-    }
-  }
-  _transition(state) {
-    if (this._state === state) {
-      return;
-    }
-    switch (state) {
-      case "canceling":
-      case "pausing":
-        this._state = state;
-        if (this._request !== void 0) {
-          this._request.cancel();
-        } else if (this.pendingTimeout) {
-          clearTimeout(this.pendingTimeout);
-          this.pendingTimeout = void 0;
-          this.completeTransitions_();
-        }
-        break;
-      case "running":
-        const wasPaused = this._state === "paused";
-        this._state = state;
-        if (wasPaused) {
-          this._notifyObservers();
-          this._start();
-        }
-        break;
-      case "paused":
-        this._state = state;
-        this._notifyObservers();
-        break;
-      case "canceled":
-        this._error = canceled();
-        this._state = state;
-        this._notifyObservers();
-        break;
-      case "error":
-        this._state = state;
-        this._notifyObservers();
-        break;
-      case "success":
-        this._state = state;
-        this._notifyObservers();
-        break;
-    }
-  }
-  completeTransitions_() {
-    switch (this._state) {
-      case "pausing":
-        this._transition(
-          "paused"
-          /* InternalTaskState.PAUSED */
-        );
-        break;
-      case "canceling":
-        this._transition(
-          "canceled"
-          /* InternalTaskState.CANCELED */
-        );
-        break;
-      case "running":
-        this._start();
-        break;
-    }
-  }
-  /**
-   * A snapshot of the current task state.
-   */
-  get snapshot() {
-    const externalState = taskStateFromInternalTaskState(this._state);
-    return {
-      bytesTransferred: this._transferred,
-      totalBytes: this._blob.size(),
-      state: externalState,
-      metadata: this._metadata,
-      task: this,
-      ref: this._ref
-    };
-  }
-  /**
-   * Adds a callback for an event.
-   * @param type - The type of event to listen for.
-   * @param nextOrObserver -
-   *     The `next` function, which gets called for each item in
-   *     the event stream, or an observer object with some or all of these three
-   *     properties (`next`, `error`, `complete`).
-   * @param error - A function that gets called with a `StorageError`
-   *     if the event stream ends due to an error.
-   * @param completed - A function that gets called if the
-   *     event stream ends normally.
-   * @returns
-   *     If only the event argument is passed, returns a function you can use to
-   *     add callbacks (see the examples above). If more than just the event
-   *     argument is passed, returns a function you can call to unregister the
-   *     callbacks.
-   */
-  on(type, nextOrObserver, error, completed) {
-    const observer = new Observer(nextOrObserver || void 0, error || void 0, completed || void 0);
-    this._addObserver(observer);
-    return () => {
-      this._removeObserver(observer);
-    };
-  }
-  /**
-   * This object behaves like a Promise, and resolves with its snapshot data
-   * when the upload completes.
-   * @param onFulfilled - The fulfillment callback. Promise chaining works as normal.
-   * @param onRejected - The rejection callback.
-   */
-  then(onFulfilled, onRejected) {
-    return this._promise.then(onFulfilled, onRejected);
-  }
-  /**
-   * Equivalent to calling `then(null, onRejected)`.
-   */
-  catch(onRejected) {
-    return this.then(null, onRejected);
-  }
-  /**
-   * Adds the given observer.
-   */
-  _addObserver(observer) {
-    this._observers.push(observer);
-    this._notifyObserver(observer);
-  }
-  /**
-   * Removes the given observer.
-   */
-  _removeObserver(observer) {
-    const i = this._observers.indexOf(observer);
-    if (i !== -1) {
-      this._observers.splice(i, 1);
-    }
-  }
-  _notifyObservers() {
-    this._finishPromise();
-    const observers = this._observers.slice();
-    observers.forEach((observer) => {
-      this._notifyObserver(observer);
-    });
-  }
-  _finishPromise() {
-    if (this._resolve !== void 0) {
-      let triggered = true;
-      switch (taskStateFromInternalTaskState(this._state)) {
-        case TaskState.SUCCESS:
-          async(this._resolve.bind(null, this.snapshot))();
-          break;
-        case TaskState.CANCELED:
-        case TaskState.ERROR:
-          const toCall = this._reject;
-          async(toCall.bind(null, this._error))();
-          break;
-        default:
-          triggered = false;
-          break;
-      }
-      if (triggered) {
-        this._resolve = void 0;
-        this._reject = void 0;
-      }
-    }
-  }
-  _notifyObserver(observer) {
-    const externalState = taskStateFromInternalTaskState(this._state);
-    switch (externalState) {
-      case TaskState.RUNNING:
-      case TaskState.PAUSED:
-        if (observer.next) {
-          async(observer.next.bind(observer, this.snapshot))();
-        }
-        break;
-      case TaskState.SUCCESS:
-        if (observer.complete) {
-          async(observer.complete.bind(observer))();
-        }
-        break;
-      case TaskState.CANCELED:
-      case TaskState.ERROR:
-        if (observer.error) {
-          async(observer.error.bind(observer, this._error))();
-        }
-        break;
-      default:
-        if (observer.error) {
-          async(observer.error.bind(observer, this._error))();
-        }
-    }
-  }
-  /**
-   * Resumes a paused task. Has no effect on a currently running or failed task.
-   * @returns True if the operation took effect, false if ignored.
-   */
-  resume() {
-    const valid = this._state === "paused" || this._state === "pausing";
-    if (valid) {
-      this._transition(
-        "running"
-        /* InternalTaskState.RUNNING */
-      );
-    }
-    return valid;
-  }
-  /**
-   * Pauses a currently running task. Has no effect on a paused or failed task.
-   * @returns True if the operation took effect, false if ignored.
-   */
-  pause() {
-    const valid = this._state === "running";
-    if (valid) {
-      this._transition(
-        "pausing"
-        /* InternalTaskState.PAUSING */
-      );
-    }
-    return valid;
-  }
-  /**
-   * Cancels a currently running or paused task. Has no effect on a complete or
-   * failed task.
-   * @returns True if the operation took effect, false if ignored.
-   */
-  cancel() {
-    const valid = this._state === "running" || this._state === "pausing";
-    if (valid) {
-      this._transition(
-        "canceling"
-        /* InternalTaskState.CANCELING */
-      );
-    }
-    return valid;
-  }
-}
-/**
- * @license
- * Copyright 2019 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class Reference {
-  constructor(_service, location) {
-    this._service = _service;
-    if (location instanceof Location) {
-      this._location = location;
-    } else {
-      this._location = Location.makeFromUrl(location, _service.host);
-    }
-  }
-  /**
-   * Returns the URL for the bucket and path this object references,
-   *     in the form gs://<bucket>/<object-path>
-   * @override
-   */
-  toString() {
-    return "gs://" + this._location.bucket + "/" + this._location.path;
-  }
-  _newRef(service, location) {
-    return new Reference(service, location);
-  }
-  /**
-   * A reference to the root of this object's bucket.
-   */
-  get root() {
-    const location = new Location(this._location.bucket, "");
-    return this._newRef(this._service, location);
-  }
-  /**
-   * The name of the bucket containing this reference's object.
-   */
-  get bucket() {
-    return this._location.bucket;
-  }
-  /**
-   * The full path of this object.
-   */
-  get fullPath() {
-    return this._location.path;
-  }
-  /**
-   * The short name of this object, which is the last component of the full path.
-   * For example, if fullPath is 'full/path/image.png', name is 'image.png'.
-   */
-  get name() {
-    return lastComponent(this._location.path);
-  }
-  /**
-   * The `StorageService` instance this `StorageReference` is associated with.
-   */
-  get storage() {
-    return this._service;
-  }
-  /**
-   * A `StorageReference` pointing to the parent location of this `StorageReference`, or null if
-   * this reference is the root.
-   */
-  get parent() {
-    const newPath = parent(this._location.path);
-    if (newPath === null) {
-      return null;
-    }
-    const location = new Location(this._location.bucket, newPath);
-    return new Reference(this._service, location);
-  }
-  /**
-   * Utility function to throw an error in methods that do not accept a root reference.
-   */
-  _throwIfRoot(name2) {
-    if (this._location.path === "") {
-      throw invalidRootOperation(name2);
-    }
-  }
-}
-function uploadBytesResumable$1(ref2, data, metadata) {
-  ref2._throwIfRoot("uploadBytesResumable");
-  return new UploadTask(ref2, new FbsBlob(data), metadata);
-}
-function getDownloadURL$1(ref2) {
-  ref2._throwIfRoot("getDownloadURL");
-  const requestInfo = getDownloadUrl(ref2.storage, ref2._location, getMappings());
-  return ref2.storage.makeRequestWithTokens(requestInfo, newTextConnection).then((url) => {
-    if (url === null) {
-      throw noDownloadURL();
-    }
-    return url;
-  });
-}
-function deleteObject$1(ref2) {
-  ref2._throwIfRoot("deleteObject");
-  const requestInfo = deleteObject$2(ref2.storage, ref2._location);
-  return ref2.storage.makeRequestWithTokens(requestInfo, newTextConnection);
-}
-function _getChild$1(ref2, childPath) {
-  const newPath = child(ref2._location.path, childPath);
-  const location = new Location(ref2._location.bucket, newPath);
-  return new Reference(ref2.storage, location);
-}
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function isUrl(path) {
-  return /^[A-Za-z]+:\/\//.test(path);
-}
-function refFromURL(service, url) {
-  return new Reference(service, url);
-}
-function refFromPath(ref2, path) {
-  if (ref2 instanceof FirebaseStorageImpl) {
-    const service = ref2;
-    if (service._bucket == null) {
-      throw noDefaultBucket();
-    }
-    const reference = new Reference(service, service._bucket);
-    if (path != null) {
-      return refFromPath(reference, path);
-    } else {
-      return reference;
-    }
-  } else {
-    if (path !== void 0) {
-      return _getChild$1(ref2, path);
-    } else {
-      return ref2;
-    }
-  }
-}
-function ref$1(serviceOrRef, pathOrUrl) {
-  if (pathOrUrl && isUrl(pathOrUrl)) {
-    if (serviceOrRef instanceof FirebaseStorageImpl) {
-      return refFromURL(serviceOrRef, pathOrUrl);
-    } else {
-      throw invalidArgument("To use ref(service, url), the first argument must be a Storage instance.");
-    }
-  } else {
-    return refFromPath(serviceOrRef, pathOrUrl);
-  }
-}
-function extractBucket(host, config) {
-  const bucketString = config == null ? void 0 : config[CONFIG_STORAGE_BUCKET_KEY];
-  if (bucketString == null) {
-    return null;
-  }
-  return Location.makeFromBucketSpec(bucketString, host);
-}
-function connectStorageEmulator$1(storage, host, port, options = {}) {
-  storage.host = `${host}:${port}`;
-  const useSsl = isCloudWorkstation(host);
-  if (useSsl) {
-    void pingServer(`https://${storage.host}/b`);
-  }
-  storage._isUsingEmulator = true;
-  storage._protocol = useSsl ? "https" : "http";
-  const { mockUserToken } = options;
-  if (mockUserToken) {
-    storage._overrideAuthToken = typeof mockUserToken === "string" ? mockUserToken : createMockUserToken(mockUserToken, storage.app.options.projectId);
-  }
-}
-class FirebaseStorageImpl {
-  constructor(app, _authProvider, _appCheckProvider, _url, _firebaseVersion, _isUsingEmulator = false) {
-    this.app = app;
-    this._authProvider = _authProvider;
-    this._appCheckProvider = _appCheckProvider;
-    this._url = _url;
-    this._firebaseVersion = _firebaseVersion;
-    this._isUsingEmulator = _isUsingEmulator;
-    this._bucket = null;
-    this._host = DEFAULT_HOST;
-    this._protocol = "https";
-    this._appId = null;
-    this._deleted = false;
-    this._maxOperationRetryTime = DEFAULT_MAX_OPERATION_RETRY_TIME;
-    this._maxUploadRetryTime = DEFAULT_MAX_UPLOAD_RETRY_TIME;
-    this._requests = /* @__PURE__ */ new Set();
-    if (_url != null) {
-      this._bucket = Location.makeFromBucketSpec(_url, this._host);
-    } else {
-      this._bucket = extractBucket(this._host, this.app.options);
-    }
-  }
-  /**
-   * The host string for this service, in the form of `host` or
-   * `host:port`.
-   */
-  get host() {
-    return this._host;
-  }
-  set host(host) {
-    this._host = host;
-    if (this._url != null) {
-      this._bucket = Location.makeFromBucketSpec(this._url, host);
-    } else {
-      this._bucket = extractBucket(host, this.app.options);
-    }
-  }
-  /**
-   * The maximum time to retry uploads in milliseconds.
-   */
-  get maxUploadRetryTime() {
-    return this._maxUploadRetryTime;
-  }
-  set maxUploadRetryTime(time) {
-    validateNumber(
-      "time",
-      /* minValue=*/
-      0,
-      /* maxValue= */
-      Number.POSITIVE_INFINITY,
-      time
-    );
-    this._maxUploadRetryTime = time;
-  }
-  /**
-   * The maximum time to retry operations other than uploads or downloads in
-   * milliseconds.
-   */
-  get maxOperationRetryTime() {
-    return this._maxOperationRetryTime;
-  }
-  set maxOperationRetryTime(time) {
-    validateNumber(
-      "time",
-      /* minValue=*/
-      0,
-      /* maxValue= */
-      Number.POSITIVE_INFINITY,
-      time
-    );
-    this._maxOperationRetryTime = time;
-  }
-  async _getAuthToken() {
-    if (this._overrideAuthToken) {
-      return this._overrideAuthToken;
-    }
-    const auth = this._authProvider.getImmediate({ optional: true });
-    if (auth) {
-      const tokenData = await auth.getToken();
-      if (tokenData !== null) {
-        return tokenData.accessToken;
-      }
-    }
-    return null;
-  }
-  async _getAppCheckToken() {
-    if (_isFirebaseServerApp(this.app) && this.app.settings.appCheckToken) {
-      return this.app.settings.appCheckToken;
-    }
-    const appCheck = this._appCheckProvider.getImmediate({ optional: true });
-    if (appCheck) {
-      const result = await appCheck.getToken();
-      return result.token;
-    }
-    return null;
-  }
-  /**
-   * Stop running requests and prevent more from being created.
-   */
-  _delete() {
-    if (!this._deleted) {
-      this._deleted = true;
-      this._requests.forEach((request) => request.cancel());
-      this._requests.clear();
-    }
-    return Promise.resolve();
-  }
-  /**
-   * Returns a new firebaseStorage.Reference object referencing this StorageService
-   * at the given Location.
-   */
-  _makeStorageReference(loc) {
-    return new Reference(this, loc);
-  }
-  /**
-   * @param requestInfo - HTTP RequestInfo object
-   * @param authToken - Firebase auth token
-   */
-  _makeRequest(requestInfo, requestFactory, authToken, appCheckToken, retry = true) {
-    if (!this._deleted) {
-      const request = makeRequest(requestInfo, this._appId, authToken, appCheckToken, requestFactory, this._firebaseVersion, retry, this._isUsingEmulator);
-      this._requests.add(request);
-      request.getPromise().then(() => this._requests.delete(request), () => this._requests.delete(request));
-      return request;
-    } else {
-      return new FailRequest(appDeleted());
-    }
-  }
-  async makeRequestWithTokens(requestInfo, requestFactory) {
-    const [authToken, appCheckToken] = await Promise.all([
-      this._getAuthToken(),
-      this._getAppCheckToken()
-    ]);
-    return this._makeRequest(requestInfo, requestFactory, authToken, appCheckToken).getPromise();
-  }
-}
-const name = "@firebase/storage";
-const version = "0.14.2";
-/**
- * @license
- * Copyright 2020 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const STORAGE_TYPE = "storage";
-function uploadBytesResumable(ref2, data, metadata) {
-  ref2 = getModularInstance(ref2);
-  return uploadBytesResumable$1(ref2, data, metadata);
-}
-function getDownloadURL(ref2) {
-  ref2 = getModularInstance(ref2);
-  return getDownloadURL$1(ref2);
-}
-function deleteObject(ref2) {
-  ref2 = getModularInstance(ref2);
-  return deleteObject$1(ref2);
-}
-function ref(serviceOrRef, pathOrUrl) {
-  serviceOrRef = getModularInstance(serviceOrRef);
-  return ref$1(serviceOrRef, pathOrUrl);
-}
-function getStorage(app = getApp(), bucketUrl) {
-  app = getModularInstance(app);
-  const storageProvider = _getProvider(app, STORAGE_TYPE);
-  const storageInstance = storageProvider.getImmediate({
-    identifier: bucketUrl
-  });
-  const emulator = getDefaultEmulatorHostnameAndPort("storage");
-  if (emulator) {
-    connectStorageEmulator(storageInstance, ...emulator);
-  }
-  return storageInstance;
-}
-function connectStorageEmulator(storage, host, port, options = {}) {
-  connectStorageEmulator$1(storage, host, port, options);
-}
-function factory(container, { instanceIdentifier: url }) {
-  const app = container.getProvider("app").getImmediate();
-  const authProvider = container.getProvider("auth-internal");
-  const appCheckProvider = container.getProvider("app-check-internal");
-  return new FirebaseStorageImpl(app, authProvider, appCheckProvider, url, SDK_VERSION);
-}
-function registerStorage() {
-  _registerComponent(new Component(
-    STORAGE_TYPE,
-    factory,
-    "PUBLIC"
-    /* ComponentType.PUBLIC */
-  ).setMultipleInstances(true));
-  registerVersion(name, version, "");
-  registerVersion(name, version, "esm2020");
-}
-registerStorage();
-export {
-  StorageError,
-  StorageErrorCode,
-  StringFormat,
-  FbsBlob as _FbsBlob,
-  Location as _Location,
-  TaskState as _TaskState,
-  UploadTask as _UploadTask,
-  dataFromString as _dataFromString,
-  invalidArgument as _invalidArgument,
-  invalidRootOperation as _invalidRootOperation,
-  connectStorageEmulator,
-  deleteObject,
-  getDownloadURL,
-  getStorage,
-  ref,
-  uploadBytesResumable
-};
-//# sourceMappingURL=index.esm.js.map