function indexeddb() {
  return {
    title: 'indexedDB',
    name: 'indexeddb',
    uploadFile(file, fileName, dir, progressCallback, url, options) {
      if (!('indexedDB' in window)) {
        console.log('This browser doesn\'t support IndexedDB');
        return;
      }

      return new Promise((resolve) => {
        const request = indexedDB.open(options.indexeddb);
        request.onsuccess = function(event) {
          const db = event.target.result;
          resolve(db);
        };
        request.onupgradeneeded = function(e) {
          const db = e.target.result;
          db.createObjectStore(options.indexeddbTable);
        };
      }).then((db) => {
        const reader = new FileReader();

        return new Promise((resolve, reject) => {
          reader.onload = () => {
            const blobObject = new Blob([file], { type: file.type });

            const id = uuidv4(blobObject);

            const data = {
              id,
              data: blobObject,
              name: file.name,
              size: file.size,
              type: file.type,
              url,
            };

            const trans = db.transaction([options.indexeddbTable], 'readwrite');
            const addReq = trans.objectStore(options.indexeddbTable).put(data, id);

            addReq.onerror = function(e) {
              console.log('error storing data');
              console.error(e);
            };

            trans.oncomplete = function() {
              resolve({
                storage: 'indexeddb',
                name: file.name,
                size: file.size,
                type: file.type,
                url: url,
                id,
              });
            };
          };

          reader.onerror = () => {
            return reject(this);
          };

          reader.readAsDataURL(file);
        });
      });
    },
    downloadFile(file, options) {
      return new Promise((resolve) => {
        const request = indexedDB.open(options.indexeddb);

        request.onsuccess = function(event) {
          const db = event.target.result;
          resolve(db);
        };
      }).then((db) => {
        return new Promise((resolve, reject) => {
          const trans = db.transaction([options.indexeddbTable], 'readonly');
          const store = trans.objectStore(options.indexeddbTable).get(file.id);
          store.onsuccess = () => {
            trans.oncomplete = () => {
              const result = store.result;
              const dbFile = new File([store.result.data], file.name, {
                type: store.result.type,
              });

              const reader = new FileReader();

              reader.onload = (event) => {
                result.url = event.target.result;
                result.storage = file.storage;
                resolve(result);
              };

              reader.onerror = () => {
                return reject(this);
              };

              reader.readAsDataURL(dbFile);
            };
          };
          store.onerror = () => {
            return reject(this);
          };
        });
      });
    },
    deleteFile(file, options) {
      return new Promise((resolve) => {
        const request = indexedDB.open(options.indexeddb);

        request.onsuccess = function(event) {
          const db = event.target.result;
          resolve(db);
        };
      }).then((db) => {
        return new Promise((resolve, reject) => {
          const trans = db.transaction([options.indexeddbTable], 'readwrite');
          const store = trans.objectStore(options.indexeddbTable).delete(file.id);
          store.onsuccess = () => {
            trans.oncomplete = () => {
              const result = store.result;

              resolve(result);
            };
          };
          store.onerror = () => {
            return reject(this);
          };
        });
      });
    },
  };
}
indexedDb provider for file storage.
@returns {import('./typedefs').FileProvider} The FileProvider interface defined in index.js.