@progressive-development/pd-spa-helper 0.3.102 → 0.3.103

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

@@ -0,0 +1,2042 @@
+import { _registerComponent, registerVersion, SDK_VERSION, _getProvider, getApp } from "../../app/dist/esm/index.esm2017.js";
+import { getModularInstance, FirebaseError, getDefaultEmulatorHostnameAndPort, createMockUserToken } from "../../util/dist/index.esm2017.js";
+import { Component } from "../../component/dist/esm/index.esm2017.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;
+/**
+ * @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 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 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) {
+    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.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.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 !== null && firebaseVersion !== void 0 ? 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) {
+  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);
+}
+/**
+ * @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);
+}
+/**
+ * @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.
+ */
+const PREFIXES_KEY = "prefixes";
+const ITEMS_KEY = "items";
+function fromBackendResponse(service, bucket, resource) {
+  const listResult = {
+    prefixes: [],
+    items: [],
+    nextPageToken: resource["nextPageToken"]
+  };
+  if (resource[PREFIXES_KEY]) {
+    for (const path of resource[PREFIXES_KEY]) {
+      const pathWithoutTrailingSlash = path.replace(/\/$/, "");
+      const reference = service._makeStorageReference(new Location(bucket, pathWithoutTrailingSlash));
+      listResult.prefixes.push(reference);
+    }
+  }
+  if (resource[ITEMS_KEY]) {
+    for (const item of resource[ITEMS_KEY]) {
+      const reference = service._makeStorageReference(new Location(bucket, item["name"]));
+      listResult.items.push(reference);
+    }
+  }
+  return listResult;
+}
+function fromResponseString(service, bucket, resourceString) {
+  const obj = jsonObjectOrNull(resourceString);
+  if (obj === null) {
+    return null;
+  }
+  const resource = obj;
+  return fromBackendResponse(service, bucket, 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 listHandler(service, bucket) {
+  function handler(xhr, text) {
+    const listResult = fromResponseString(service, bucket, text);
+    handlerCheck(listResult !== null);
+    return listResult;
+  }
+  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 list$2(service, location, delimiter, pageToken, maxResults) {
+  const urlParams = {};
+  if (location.isRoot) {
+    urlParams["prefix"] = "";
+  } else {
+    urlParams["prefix"] = location.path + "/";
+  }
+  if (delimiter.length > 0) {
+    urlParams["delimiter"] = delimiter;
+  }
+  if (pageToken) {
+    urlParams["pageToken"] = pageToken;
+  }
+  if (maxResults) {
+    urlParams["maxResults"] = maxResults;
+  }
+  const urlPart = location.bucketOnlyServerUrl();
+  const url = makeUrl(urlPart, service.host, service._protocol);
+  const method = "GET";
+  const timeout = service.maxOperationRetryTime;
+  const requestInfo = new RequestInfo(url, method, listHandler(service, location.bucket), timeout);
+  requestInfo.urlParams = urlParams;
+  requestInfo.errorHandler = sharedErrorHandler(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 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, body, headers) {
+    if (this.sent_) {
+      throw internalError("cannot .send() more than once");
+    }
+    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 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 uploadBytes$1(ref2, data, metadata) {
+  ref2._throwIfRoot("uploadBytes");
+  const requestInfo = multipartUpload(ref2.storage, ref2._location, getMappings(), new FbsBlob(data, true), metadata);
+  return ref2.storage.makeRequestWithTokens(requestInfo, newTextConnection).then((finalMetadata) => {
+    return {
+      metadata: finalMetadata,
+      ref: ref2
+    };
+  });
+}
+function uploadString$1(ref2, value, format = StringFormat.RAW, metadata) {
+  ref2._throwIfRoot("uploadString");
+  const data = dataFromString(format, value);
+  const metadataClone = Object.assign({}, metadata);
+  if (metadataClone["contentType"] == null && data.contentType != null) {
+    metadataClone["contentType"] = data.contentType;
+  }
+  return uploadBytes$1(ref2, data.data, metadataClone);
+}
+function listAll$1(ref2) {
+  const accumulator = {
+    prefixes: [],
+    items: []
+  };
+  return listAllHelper(ref2, accumulator).then(() => accumulator);
+}
+async function listAllHelper(ref2, accumulator, pageToken) {
+  const opt = {
+    // maxResults is 1000 by default.
+    pageToken
+  };
+  const nextPage = await list$1(ref2, opt);
+  accumulator.prefixes.push(...nextPage.prefixes);
+  accumulator.items.push(...nextPage.items);
+  if (nextPage.nextPageToken != null) {
+    await listAllHelper(ref2, accumulator, nextPage.nextPageToken);
+  }
+}
+function list$1(ref2, options) {
+  if (options != null) {
+    if (typeof options.maxResults === "number") {
+      validateNumber(
+        "options.maxResults",
+        /* minValue= */
+        1,
+        /* maxValue= */
+        1e3,
+        options.maxResults
+      );
+    }
+  }
+  const op = options;
+  const requestInfo = list$2(
+    ref2.storage,
+    ref2._location,
+    /*delimiter= */
+    "/",
+    op.pageToken,
+    op.maxResults
+  );
+  return ref2.storage.makeRequestWithTokens(requestInfo, newTextConnection);
+}
+function getMetadata$1(ref2) {
+  ref2._throwIfRoot("getMetadata");
+  const requestInfo = getMetadata$2(ref2.storage, ref2._location, getMappings());
+  return ref2.storage.makeRequestWithTokens(requestInfo, newTextConnection);
+}
+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 || config === void 0 ? 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}`;
+  storage._protocol = "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) {
+    this.app = app;
+    this._authProvider = _authProvider;
+    this._appCheckProvider = _appCheckProvider;
+    this._url = _url;
+    this._firebaseVersion = _firebaseVersion;
+    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() {
+    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._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.13.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 uploadString(ref2, value, format, metadata) {
+  ref2 = getModularInstance(ref2);
+  return uploadString$1(ref2, value, format, metadata);
+}
+function getMetadata(ref2) {
+  ref2 = getModularInstance(ref2);
+  return getMetadata$1(ref2);
+}
+function listAll(ref2) {
+  ref2 = getModularInstance(ref2);
+  return listAll$1(ref2);
+}
+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, "esm2017");
+}
+registerStorage();
+export {
+  StorageError,
+  StorageErrorCode,
+  StringFormat,
+  FbsBlob as _FbsBlob,
+  Location as _Location,
+  dataFromString as _dataFromString,
+  invalidArgument as _invalidArgument,
+  invalidRootOperation as _invalidRootOperation,
+  connectStorageEmulator,
+  deleteObject,
+  getDownloadURL,
+  getMetadata,
+  getStorage,
+  listAll,
+  ref,
+  uploadString
+};