@formio/js 5.0.0-rc.5

package/lib/cjs/providers/address/GoogleAddressProvider.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAddressProvider = void 0;
+/* globals google */
+const Formio_1 = require("../../Formio");
+const lodash_1 = __importDefault(require("lodash"));
+const AddressProvider_1 = require("./AddressProvider");
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+class GoogleAddressProvider extends AddressProvider_1.AddressProvider {
+    static get name() {
+        return 'google';
+    }
+    static get displayName() {
+        return 'Google Maps';
+    }
+    constructor(options = {}) {
+        var _a;
+        super(options);
+        this.setAutocompleteOptions();
+        let src = 'https://maps.googleapis.com/maps/api/js?v=quarterly&libraries=places&callback=googleMapsCallback';
+        if ((_a = options.params) === null || _a === void 0 ? void 0 : _a.key) {
+            src += `&key=${options.params.key}`;
+        }
+        Formio_1.Formio.requireLibrary(this.getLibraryName(), 'google.maps.places', src);
+    }
+    get displayValueProperty() {
+        return 'formattedPlace';
+    }
+    get alternativeDisplayValueProperty() {
+        return 'formatted_address';
+    }
+    set autocompleteOptions(options) {
+        this._autocompleteOptions = options;
+    }
+    get autocompleteOptions() {
+        return this._autocompleteOptions;
+    }
+    setAutocompleteOptions() {
+        let options = lodash_1.default.get(this.options, 'params.autocompleteOptions', {});
+        if (!lodash_1.default.isObject(options)) {
+            options = {};
+        }
+        this.addRequiredProviderOptions(options);
+        this.autocompleteOptions = options;
+    }
+    beforeMergeOptions(options) {
+        // providing support of old Google Provider option
+        this.convertRegionToAutocompleteOption(options);
+    }
+    getLibraryName() {
+        return 'googleMaps';
+    }
+    convertRegionToAutocompleteOption(options) {
+        const providerOptions = options;
+        let region = lodash_1.default.get(providerOptions, 'params.region', '');
+        if (region && !lodash_1.default.has(options, 'params.autocompleteOptions')) {
+            region = region.toUpperCase().trim();
+            // providing compatibility with ISO 3166-1 Alpha-2 county codes (for checking compatibility https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes)
+            const countryCodes = { 'UK': 'GB' };
+            if (countryCodes[region]) {
+                region = countryCodes[region];
+            }
+            lodash_1.default.set(providerOptions, 'params.autocompleteOptions.componentRestrictions.country', [region]);
+        }
+    }
+    getRequiredAddressProperties() {
+        return ['address_components', 'formatted_address', 'geometry', 'place_id', 'plus_code', 'types'];
+    }
+    addRequiredProviderOptions(options) {
+        const addressProperties = this.getRequiredAddressProperties();
+        if (lodash_1.default.isArray(options.fields) && options.fields.length > 0) {
+            options.fields.forEach(optionalField => {
+                if (!addressProperties.some(addressProp => optionalField === addressProp)) {
+                    addressProperties.push(optionalField);
+                }
+            });
+        }
+        options.fields = addressProperties;
+    }
+    filterPlace(place) {
+        place = place || {};
+        const filteredPlace = {};
+        if (this.autocompleteOptions) {
+            this.autocompleteOptions.fields.forEach(field => {
+                if (place[field]) {
+                    filteredPlace[field] = place[field];
+                }
+            });
+        }
+        return filteredPlace;
+    }
+    attachAutocomplete(elem, index, onSelectAddress) {
+        Formio_1.Formio.libraryReady(this.getLibraryName()).then(() => {
+            const autocomplete = new google.maps.places.Autocomplete(elem, this.autocompleteOptions);
+            autocomplete.addListener('place_changed', () => {
+                const place = this.filterPlace(autocomplete.getPlace());
+                place.formattedPlace = lodash_1.default.get(autocomplete, 'gm_accessors_.place.se.formattedPrediction', place[this.alternativeDisplayValueProperty]);
+                onSelectAddress(place, elem, index);
+            });
+        });
+    }
+    search() {
+        return native_promise_only_1.default.resolve();
+    }
+    makeRequest() {
+        return native_promise_only_1.default.resolve();
+    }
+    getDisplayValue(address) {
+        const displayedProperty = lodash_1.default.has(address, this.displayValueProperty)
+            ? this.displayValueProperty
+            : this.alternativeDisplayValueProperty;
+        return lodash_1.default.get(address, displayedProperty, '');
+    }
+}
+exports.GoogleAddressProvider = GoogleAddressProvider;

package/lib/cjs/providers/address/NominatimAddressProvider.d.ts

@@ -0,0 +1,11 @@
+export class NominatimAddressProvider extends AddressProvider {
+    get defaultOptions(): {
+        params: {
+            addressdetails: string;
+            format: string;
+        };
+    };
+    get displayValueProperty(): string;
+    getRequestUrl(options?: {}): string;
+}
+import { AddressProvider } from './AddressProvider';

package/lib/cjs/providers/address/NominatimAddressProvider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NominatimAddressProvider = void 0;
+const AddressProvider_1 = require("./AddressProvider");
+class NominatimAddressProvider extends AddressProvider_1.AddressProvider {
+    static get name() {
+        return 'nominatim';
+    }
+    static get displayName() {
+        return 'OpenStreetMap Nominatim';
+    }
+    get defaultOptions() {
+        return {
+            params: {
+                addressdetails: '1',
+                format: 'json',
+            },
+        };
+    }
+    get queryProperty() {
+        return 'q';
+    }
+    get displayValueProperty() {
+        return 'display_name';
+    }
+    getRequestUrl(options = {}) {
+        const { params } = options;
+        return `https://nominatim.openstreetmap.org/search?${this.serialize(params)}`;
+    }
+}
+exports.NominatimAddressProvider = NominatimAddressProvider;

package/lib/cjs/providers/address/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    [x: string]: typeof CustomAddressProvider | typeof GoogleAddressProvider;
+};
+export default _default;
+import { CustomAddressProvider } from './CustomAddressProvider';
+import { GoogleAddressProvider } from './GoogleAddressProvider';

package/lib/cjs/providers/address/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AzureAddressProvider_1 = require("./AzureAddressProvider");
+const CustomAddressProvider_1 = require("./CustomAddressProvider");
+const GoogleAddressProvider_1 = require("./GoogleAddressProvider");
+const NominatimAddressProvider_1 = require("./NominatimAddressProvider");
+exports.default = {
+    [AzureAddressProvider_1.AzureAddressProvider.name]: AzureAddressProvider_1.AzureAddressProvider,
+    [CustomAddressProvider_1.CustomAddressProvider.name]: CustomAddressProvider_1.CustomAddressProvider,
+    [GoogleAddressProvider_1.GoogleAddressProvider.name]: GoogleAddressProvider_1.GoogleAddressProvider,
+    [NominatimAddressProvider_1.NominatimAddressProvider.name]: NominatimAddressProvider_1.NominatimAddressProvider,
+};

package/lib/cjs/providers/auth/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/lib/cjs/providers/auth/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {};

package/lib/cjs/providers/index.d.ts

@@ -0,0 +1,2 @@
+export default Providers;
+import Providers from './Providers';

package/lib/cjs/providers/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Providers_1 = __importDefault(require("./Providers"));
+exports.default = Providers_1.default;

package/lib/cjs/providers/processor/fileProcessor.d.ts

@@ -0,0 +1,2 @@
+export default fileProcessor;
+declare function fileProcessor(formio: any, config: any): (file: any, options: any) => any;

package/lib/cjs/providers/processor/fileProcessor.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const fileProcessor = (formio, config) => (file, options) => new native_promise_only_1.default((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    // Fire on network error.
+    xhr.onerror = (err) => {
+        err.networkError = true;
+        reject(err);
+    };
+    // Fire on network abort.
+    xhr.onabort = (err) => {
+        err.networkError = true;
+        reject(err);
+    };
+    // Fired when the response has made it back from the server.
+    xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+            const mimetype = xhr.getResponseHeader('Content-Type') || file.type;
+            resolve(new File([xhr.response], file.name, { type: mimetype }));
+        }
+        else {
+            reject(xhr.response || 'Unable to process file');
+        }
+    };
+    // Set the onabort error callback.
+    xhr.onabort = reject;
+    xhr.open('POST', config.url);
+    const token = formio.getToken();
+    if (token) {
+        xhr.setRequestHeader('x-jwt-token', token);
+    }
+    xhr.responseType = 'arraybuffer';
+    const data = new FormData();
+    data.append('file', file);
+    data.append('processorOptions', JSON.stringify(config.options || {}));
+    data.append('options', JSON.stringify(options || {}));
+    // Get the request and send it to the server.
+    xhr.send(data);
+});
+exports.default = fileProcessor;

package/lib/cjs/providers/storage/azure.d.ts

@@ -0,0 +1,8 @@
+export default azure;
+declare function azure(formio: any): {
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any, fileKey: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace azure {
+    const title: string;
+}

package/lib/cjs/providers/storage/azure.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const xhr_1 = __importDefault(require("./xhr"));
+const azure = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return xhr_1.default.upload(formio, 'azure', (xhr, response) => {
+            xhr.openAndSetHeaders('PUT', response.url);
+            xhr.setRequestHeader('Content-Type', file.type);
+            xhr.setRequestHeader('x-ms-blob-type', 'BlockBlob');
+            return file;
+        }, file, fileName, dir, progressCallback, groupPermissions, groupId, abortCallback).then(() => {
+            return {
+                storage: 'azure',
+                name: xhr_1.default.path([dir, fileName]),
+                size: file.size,
+                type: file.type,
+                groupPermissions,
+                groupId
+            };
+        });
+    },
+    downloadFile(file) {
+        return formio.makeRequest('file', `${formio.formUrl}/storage/azure?name=${xhr_1.default.trim(file.name)}`, 'GET');
+    }
+});
+azure.title = 'Azure File Services';
+exports.default = azure;

package/lib/cjs/providers/storage/base64.d.ts

@@ -0,0 +1,10 @@
+export default base64;
+declare function base64(): {
+    title: string;
+    name: string;
+    uploadFile(file: any, fileName: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace base64 {
+    const title: string;
+}

package/lib/cjs/providers/storage/base64.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const base64 = () => ({
+    title: 'Base64',
+    name: 'base64',
+    uploadFile(file, fileName) {
+        const reader = new FileReader();
+        return new native_promise_only_1.default((resolve, reject) => {
+            reader.onload = (event) => {
+                const url = event.target.result;
+                resolve({
+                    storage: 'base64',
+                    name: fileName,
+                    url: url,
+                    size: file.size,
+                    type: file.type,
+                });
+            };
+            reader.onerror = () => {
+                return reject(this);
+            };
+            reader.readAsDataURL(file);
+        });
+    },
+    downloadFile(file) {
+        // Return the original as there is nothing to do.
+        return native_promise_only_1.default.resolve(file);
+    }
+});
+base64.title = 'Base64';
+exports.default = base64;

package/lib/cjs/providers/storage/dropbox.d.ts

@@ -0,0 +1,8 @@
+export default dropbox;
+declare function dropbox(formio: any): {
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any, fileKey: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace dropbox {
+    const title: string;
+}

package/lib/cjs/providers/storage/dropbox.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const xhr_1 = require("./xhr");
+const dropbox = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return new native_promise_only_1.default(((resolve, reject) => {
+            // Send the file with data.
+            const xhr = new XMLHttpRequest();
+            if (typeof progressCallback === 'function') {
+                xhr.upload.onprogress = progressCallback;
+            }
+            if (typeof abortCallback === 'function') {
+                abortCallback(() => xhr.abort());
+            }
+            const fd = new FormData();
+            fd.append('name', fileName);
+            fd.append('dir', dir);
+            fd.append('file', file);
+            // Fire on network error.
+            xhr.onerror = (err) => {
+                err.networkError = true;
+                reject(err);
+            };
+            xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    const response = JSON.parse(xhr.response);
+                    response.storage = 'dropbox';
+                    response.size = file.size;
+                    response.type = file.type;
+                    response.groupId = groupId;
+                    response.groupPermissions = groupPermissions;
+                    response.url = response.path_lower;
+                    resolve(response);
+                }
+                else {
+                    reject(xhr.response || 'Unable to upload file');
+                }
+            };
+            xhr.onabort = reject;
+            xhr.open('POST', `${formio.formUrl}/storage/dropbox`);
+            (0, xhr_1.setXhrHeaders)(formio, xhr);
+            const token = formio.getToken();
+            if (token) {
+                xhr.setRequestHeader('x-jwt-token', token);
+            }
+            xhr.send(fd);
+        }));
+    },
+    downloadFile(file) {
+        const token = formio.getToken();
+        file.url =
+            `${formio.formUrl}/storage/dropbox?path_lower=${file.path_lower}${token ? `&x-jwt-token=${token}` : ''}`;
+        return native_promise_only_1.default.resolve(file);
+    }
+});
+dropbox.title = 'Dropbox';
+exports.default = dropbox;

package/lib/cjs/providers/storage/googleDrive.d.ts

@@ -0,0 +1,8 @@
+export default googledrive;
+declare function googledrive(formio: any): {
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any, fileKey: any, groupPermissions: any, groupId: any, abortCallback: any): any;
+    downloadFile(file: any): any;
+};
+declare namespace googledrive {
+    const title: string;
+}

package/lib/cjs/providers/storage/googleDrive.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const xhr_1 = require("./xhr");
+const googledrive = (formio) => ({
+    uploadFile(file, fileName, dir, progressCallback, url, options, fileKey, groupPermissions, groupId, abortCallback) {
+        return new native_promise_only_1.default(((resolve, reject) => {
+            // Send the file with data.
+            const xhr = new XMLHttpRequest();
+            if (typeof progressCallback === 'function') {
+                xhr.upload.onprogress = progressCallback;
+            }
+            if (typeof abortCallback === 'function') {
+                abortCallback(() => xhr.abort());
+            }
+            const fd = new FormData();
+            fd.append('name', fileName);
+            fd.append('dir', dir);
+            fd.append('file', file);
+            // Fire on network error.
+            xhr.onerror = (err) => {
+                err.networkError = true;
+                reject(err);
+            };
+            xhr.onload = () => {
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    const response = JSON.parse(xhr.response);
+                    response.storage = 'googledrive';
+                    response.size = file.size;
+                    response.type = file.type;
+                    response.groupId = groupId;
+                    response.groupPermissions = groupPermissions;
+                    resolve(response);
+                }
+                else {
+                    reject(xhr.response || 'Unable to upload file');
+                }
+            };
+            xhr.onabort = reject;
+            xhr.open('POST', `${formio.formUrl}/storage/gdrive`);
+            (0, xhr_1.setXhrHeaders)(formio, xhr);
+            const token = formio.getToken();
+            if (token) {
+                xhr.setRequestHeader('x-jwt-token', token);
+            }
+            xhr.send(fd);
+        }));
+    },
+    downloadFile(file) {
+        const token = formio.getToken();
+        file.url =
+            `${formio.formUrl}/storage/gdrive?fileId=${file.id}&fileName=${file.originalName}${token ? `&x-jwt-token=${token}` : ''}`;
+        return native_promise_only_1.default.resolve(file);
+    }
+});
+googledrive.title = 'Google Drive';
+exports.default = googledrive;

package/lib/cjs/providers/storage/index.d.ts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { base64 };
+    export { s3 };
+    export { url };
+    export { azure };
+    export { indexeddb };
+    export { googledrive };
+}
+export default _default;
+import base64 from './base64';
+import s3 from './s3';
+import url from './url';
+import azure from './azure';
+import indexeddb from './indexeddb';
+import googledrive from './googleDrive';

package/lib/cjs/providers/storage/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base64_1 = __importDefault(require("./base64"));
+const s3_1 = __importDefault(require("./s3"));
+const azure_1 = __importDefault(require("./azure"));
+const url_1 = __importDefault(require("./url"));
+const indexeddb_1 = __importDefault(require("./indexeddb"));
+const googleDrive_1 = __importDefault(require("./googleDrive"));
+exports.default = {
+    base64: base64_1.default,
+    s3: s3_1.default,
+    url: url_1.default,
+    azure: azure_1.default,
+    indexeddb: indexeddb_1.default,
+    googledrive: googleDrive_1.default
+};

package/lib/cjs/providers/storage/indexeddb.d.ts

@@ -0,0 +1,11 @@
+export default indexeddb;
+declare function indexeddb(): {
+    title: string;
+    name: string;
+    uploadFile(file: any, fileName: any, dir: any, progressCallback: any, url: any, options: any): any;
+    downloadFile(file: any, options: any): any;
+    deleteFile(file: any, options: any): any;
+};
+declare namespace indexeddb {
+    const title: string;
+}

package/lib/cjs/providers/storage/indexeddb.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+const native_promise_only_1 = __importDefault(require("native-promise-only"));
+const indexeddb = () => ({
+    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 native_promise_only_1.default((resolve) => {
+            const request = indexedDB.open(options.indexeddb, 3);
+            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 native_promise_only_1.default((resolve, reject) => {
+                reader.onload = () => {
+                    const blobObject = new Blob([file], { type: file.type });
+                    const id = (0, uuid_1.v4)(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 native_promise_only_1.default((resolve) => {
+            const request = indexedDB.open(options.indexeddb, 3);
+            request.onsuccess = function (event) {
+                const db = event.target.result;
+                resolve(db);
+            };
+        }).then((db) => {
+            return new native_promise_only_1.default((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 native_promise_only_1.default((resolve) => {
+            const request = indexedDB.open(options.indexeddb, 3);
+            request.onsuccess = function (event) {
+                const db = event.target.result;
+                resolve(db);
+            };
+        }).then((db) => {
+            return new native_promise_only_1.default((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.title = 'IndexedDB';
+exports.default = indexeddb;