Fix actions/tour

node_modules/localforage/build/es5src/drivers/localstorage.js

@@ -0,0 +1,357 @@
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define('localStorageWrapper', ['module', 'exports', '../utils/isLocalStorageValid', '../utils/serializer', '../utils/promise', '../utils/executeCallback', '../utils/normalizeKey', '../utils/getCallback'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(module, exports, require('../utils/isLocalStorageValid'), require('../utils/serializer'), require('../utils/promise'), require('../utils/executeCallback'), require('../utils/normalizeKey'), require('../utils/getCallback'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod, mod.exports, global.isLocalStorageValid, global.serializer, global.promise, global.executeCallback, global.normalizeKey, global.getCallback);
+        global.localStorageWrapper = mod.exports;
+    }
+})(this, function (module, exports, _isLocalStorageValid, _serializer, _promise, _executeCallback, _normalizeKey, _getCallback) {
+    'use strict';
+
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+
+    var _isLocalStorageValid2 = _interopRequireDefault(_isLocalStorageValid);
+
+    var _serializer2 = _interopRequireDefault(_serializer);
+
+    var _promise2 = _interopRequireDefault(_promise);
+
+    var _executeCallback2 = _interopRequireDefault(_executeCallback);
+
+    var _normalizeKey2 = _interopRequireDefault(_normalizeKey);
+
+    var _getCallback2 = _interopRequireDefault(_getCallback);
+
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+
+    // If IndexedDB isn't available, we'll fall back to localStorage.
+    // Note that this will have considerable performance and storage
+    // side-effects (all data will be serialized on save and only data that
+    // can be converted to a string via `JSON.stringify()` will be saved).
+
+    function _getKeyPrefix(options, defaultConfig) {
+        var keyPrefix = options.name + '/';
+
+        if (options.storeName !== defaultConfig.storeName) {
+            keyPrefix += options.storeName + '/';
+        }
+        return keyPrefix;
+    }
+
+    // Check if localStorage throws when saving an item
+    function checkIfLocalStorageThrows() {
+        var localStorageTestKey = '_localforage_support_test';
+
+        try {
+            localStorage.setItem(localStorageTestKey, true);
+            localStorage.removeItem(localStorageTestKey);
+
+            return false;
+        } catch (e) {
+            return true;
+        }
+    }
+
+    // Check if localStorage is usable and allows to save an item
+    // This method checks if localStorage is usable in Safari Private Browsing
+    // mode, or in any other case where the available quota for localStorage
+    // is 0 and there wasn't any saved items yet.
+    function _isLocalStorageUsable() {
+        return !checkIfLocalStorageThrows() || localStorage.length > 0;
+    }
+
+    // Config the localStorage backend, using options set in the config.
+    function _initStorage(options) {
+        var self = this;
+        var dbInfo = {};
+        if (options) {
+            for (var i in options) {
+                dbInfo[i] = options[i];
+            }
+        }
+
+        dbInfo.keyPrefix = _getKeyPrefix(options, self._defaultConfig);
+
+        if (!_isLocalStorageUsable()) {
+            return _promise2.default.reject();
+        }
+
+        self._dbInfo = dbInfo;
+        dbInfo.serializer = _serializer2.default;
+
+        return _promise2.default.resolve();
+    }
+
+    // Remove all keys from the datastore, effectively destroying all data in
+    // the app's key/value store!
+    function clear(callback) {
+        var self = this;
+        var promise = self.ready().then(function () {
+            var keyPrefix = self._dbInfo.keyPrefix;
+
+            for (var i = localStorage.length - 1; i >= 0; i--) {
+                var key = localStorage.key(i);
+
+                if (key.indexOf(keyPrefix) === 0) {
+                    localStorage.removeItem(key);
+                }
+            }
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Retrieve an item from the store. Unlike the original async_storage
+    // library in Gaia, we don't modify return values at all. If a key's value
+    // is `undefined`, we pass that value to the callback function.
+    function getItem(key, callback) {
+        var self = this;
+
+        key = (0, _normalizeKey2.default)(key);
+
+        var promise = self.ready().then(function () {
+            var dbInfo = self._dbInfo;
+            var result = localStorage.getItem(dbInfo.keyPrefix + key);
+
+            // If a result was found, parse it from the serialized
+            // string into a JS object. If result isn't truthy, the key
+            // is likely undefined and we'll pass it straight to the
+            // callback.
+            if (result) {
+                result = dbInfo.serializer.deserialize(result);
+            }
+
+            return result;
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Iterate over all items in the store.
+    function iterate(iterator, callback) {
+        var self = this;
+
+        var promise = self.ready().then(function () {
+            var dbInfo = self._dbInfo;
+            var keyPrefix = dbInfo.keyPrefix;
+            var keyPrefixLength = keyPrefix.length;
+            var length = localStorage.length;
+
+            // We use a dedicated iterator instead of the `i` variable below
+            // so other keys we fetch in localStorage aren't counted in
+            // the `iterationNumber` argument passed to the `iterate()`
+            // callback.
+            //
+            // See: github.com/mozilla/localForage/pull/435#discussion_r38061530
+            var iterationNumber = 1;
+
+            for (var i = 0; i < length; i++) {
+                var key = localStorage.key(i);
+                if (key.indexOf(keyPrefix) !== 0) {
+                    continue;
+                }
+                var value = localStorage.getItem(key);
+
+                // If a result was found, parse it from the serialized
+                // string into a JS object. If result isn't truthy, the
+                // key is likely undefined and we'll pass it straight
+                // to the iterator.
+                if (value) {
+                    value = dbInfo.serializer.deserialize(value);
+                }
+
+                value = iterator(value, key.substring(keyPrefixLength), iterationNumber++);
+
+                if (value !== void 0) {
+                    return value;
+                }
+            }
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Same as localStorage's key() method, except takes a callback.
+    function key(n, callback) {
+        var self = this;
+        var promise = self.ready().then(function () {
+            var dbInfo = self._dbInfo;
+            var result;
+            try {
+                result = localStorage.key(n);
+            } catch (error) {
+                result = null;
+            }
+
+            // Remove the prefix from the key, if a key is found.
+            if (result) {
+                result = result.substring(dbInfo.keyPrefix.length);
+            }
+
+            return result;
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    function keys(callback) {
+        var self = this;
+        var promise = self.ready().then(function () {
+            var dbInfo = self._dbInfo;
+            var length = localStorage.length;
+            var keys = [];
+
+            for (var i = 0; i < length; i++) {
+                var itemKey = localStorage.key(i);
+                if (itemKey.indexOf(dbInfo.keyPrefix) === 0) {
+                    keys.push(itemKey.substring(dbInfo.keyPrefix.length));
+                }
+            }
+
+            return keys;
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Supply the number of keys in the datastore to the callback function.
+    function length(callback) {
+        var self = this;
+        var promise = self.keys().then(function (keys) {
+            return keys.length;
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Remove an item from the store, nice and simple.
+    function removeItem(key, callback) {
+        var self = this;
+
+        key = (0, _normalizeKey2.default)(key);
+
+        var promise = self.ready().then(function () {
+            var dbInfo = self._dbInfo;
+            localStorage.removeItem(dbInfo.keyPrefix + key);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Set a key's value and run an optional callback once the value is set.
+    // Unlike Gaia's implementation, the callback function is passed the value,
+    // in case you want to operate on that value only after you're sure it
+    // saved, or something like that.
+    function setItem(key, value, callback) {
+        var self = this;
+
+        key = (0, _normalizeKey2.default)(key);
+
+        var promise = self.ready().then(function () {
+            // Convert undefined values to null.
+            // https://github.com/mozilla/localForage/pull/42
+            if (value === undefined) {
+                value = null;
+            }
+
+            // Save the original value to pass to the callback.
+            var originalValue = value;
+
+            return new _promise2.default(function (resolve, reject) {
+                var dbInfo = self._dbInfo;
+                dbInfo.serializer.serialize(value, function (value, error) {
+                    if (error) {
+                        reject(error);
+                    } else {
+                        try {
+                            localStorage.setItem(dbInfo.keyPrefix + key, value);
+                            resolve(originalValue);
+                        } catch (e) {
+                            // localStorage capacity exceeded.
+                            // TODO: Make this a specific error/event.
+                            if (e.name === 'QuotaExceededError' || e.name === 'NS_ERROR_DOM_QUOTA_REACHED') {
+                                reject(e);
+                            }
+                            reject(e);
+                        }
+                    }
+                });
+            });
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    function dropInstance(options, callback) {
+        callback = _getCallback2.default.apply(this, arguments);
+
+        options = typeof options !== 'function' && options || {};
+        if (!options.name) {
+            var currentConfig = this.config();
+            options.name = options.name || currentConfig.name;
+            options.storeName = options.storeName || currentConfig.storeName;
+        }
+
+        var self = this;
+        var promise;
+        if (!options.name) {
+            promise = _promise2.default.reject('Invalid arguments');
+        } else {
+            promise = new _promise2.default(function (resolve) {
+                if (!options.storeName) {
+                    resolve(options.name + '/');
+                } else {
+                    resolve(_getKeyPrefix(options, self._defaultConfig));
+                }
+            }).then(function (keyPrefix) {
+                for (var i = localStorage.length - 1; i >= 0; i--) {
+                    var key = localStorage.key(i);
+
+                    if (key.indexOf(keyPrefix) === 0) {
+                        localStorage.removeItem(key);
+                    }
+                }
+            });
+        }
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    var localStorageWrapper = {
+        _driver: 'localStorageWrapper',
+        _initStorage: _initStorage,
+        _support: (0, _isLocalStorageValid2.default)(),
+        iterate: iterate,
+        getItem: getItem,
+        setItem: setItem,
+        removeItem: removeItem,
+        clear: clear,
+        length: length,
+        key: key,
+        keys: keys,
+        dropInstance: dropInstance
+    };
+
+    exports.default = localStorageWrapper;
+    module.exports = exports['default'];
+});

node_modules/localforage/build/es5src/drivers/websql.js

@@ -0,0 +1,474 @@
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define('webSQLStorage', ['module', 'exports', '../utils/isWebSQLValid', '../utils/serializer', '../utils/promise', '../utils/executeCallback', '../utils/normalizeKey', '../utils/getCallback'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(module, exports, require('../utils/isWebSQLValid'), require('../utils/serializer'), require('../utils/promise'), require('../utils/executeCallback'), require('../utils/normalizeKey'), require('../utils/getCallback'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod, mod.exports, global.isWebSQLValid, global.serializer, global.promise, global.executeCallback, global.normalizeKey, global.getCallback);
+        global.webSQLStorage = mod.exports;
+    }
+})(this, function (module, exports, _isWebSQLValid, _serializer, _promise, _executeCallback, _normalizeKey, _getCallback) {
+    'use strict';
+
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+
+    var _isWebSQLValid2 = _interopRequireDefault(_isWebSQLValid);
+
+    var _serializer2 = _interopRequireDefault(_serializer);
+
+    var _promise2 = _interopRequireDefault(_promise);
+
+    var _executeCallback2 = _interopRequireDefault(_executeCallback);
+
+    var _normalizeKey2 = _interopRequireDefault(_normalizeKey);
+
+    var _getCallback2 = _interopRequireDefault(_getCallback);
+
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+
+    /*
+     * Includes code from:
+     *
+     * base64-arraybuffer
+     * https://github.com/niklasvh/base64-arraybuffer
+     *
+     * Copyright (c) 2012 Niklas von Hertzen
+     * Licensed under the MIT license.
+     */
+
+    function createDbTable(t, dbInfo, callback, errorCallback) {
+        t.executeSql('CREATE TABLE IF NOT EXISTS ' + dbInfo.storeName + ' ' + '(id INTEGER PRIMARY KEY, key unique, value)', [], callback, errorCallback);
+    }
+
+    // Open the WebSQL database (automatically creates one if one didn't
+    // previously exist), using any options set in the config.
+    function _initStorage(options) {
+        var self = this;
+        var dbInfo = {
+            db: null
+        };
+
+        if (options) {
+            for (var i in options) {
+                dbInfo[i] = typeof options[i] !== 'string' ? options[i].toString() : options[i];
+            }
+        }
+
+        var dbInfoPromise = new _promise2.default(function (resolve, reject) {
+            // Open the database; the openDatabase API will automatically
+            // create it for us if it doesn't exist.
+            try {
+                dbInfo.db = openDatabase(dbInfo.name, String(dbInfo.version), dbInfo.description, dbInfo.size);
+            } catch (e) {
+                return reject(e);
+            }
+
+            // Create our key/value table if it doesn't exist.
+            dbInfo.db.transaction(function (t) {
+                createDbTable(t, dbInfo, function () {
+                    self._dbInfo = dbInfo;
+                    resolve();
+                }, function (t, error) {
+                    reject(error);
+                });
+            }, reject);
+        });
+
+        dbInfo.serializer = _serializer2.default;
+        return dbInfoPromise;
+    }
+
+    function tryExecuteSql(t, dbInfo, sqlStatement, args, callback, errorCallback) {
+        t.executeSql(sqlStatement, args, callback, function (t, error) {
+            if (error.code === error.SYNTAX_ERR) {
+                t.executeSql('SELECT name FROM sqlite_master ' + "WHERE type='table' AND name = ?", [dbInfo.storeName], function (t, results) {
+                    if (!results.rows.length) {
+                        // if the table is missing (was deleted)
+                        // re-create it table and retry
+                        createDbTable(t, dbInfo, function () {
+                            t.executeSql(sqlStatement, args, callback, errorCallback);
+                        }, errorCallback);
+                    } else {
+                        errorCallback(t, error);
+                    }
+                }, errorCallback);
+            } else {
+                errorCallback(t, error);
+            }
+        }, errorCallback);
+    }
+
+    function getItem(key, callback) {
+        var self = this;
+
+        key = (0, _normalizeKey2.default)(key);
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                var dbInfo = self._dbInfo;
+                dbInfo.db.transaction(function (t) {
+                    tryExecuteSql(t, dbInfo, 'SELECT * FROM ' + dbInfo.storeName + ' WHERE key = ? LIMIT 1', [key], function (t, results) {
+                        var result = results.rows.length ? results.rows.item(0).value : null;
+
+                        // Check to see if this is serialized content we need to
+                        // unpack.
+                        if (result) {
+                            result = dbInfo.serializer.deserialize(result);
+                        }
+
+                        resolve(result);
+                    }, function (t, error) {
+                        reject(error);
+                    });
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    function iterate(iterator, callback) {
+        var self = this;
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                var dbInfo = self._dbInfo;
+
+                dbInfo.db.transaction(function (t) {
+                    tryExecuteSql(t, dbInfo, 'SELECT * FROM ' + dbInfo.storeName, [], function (t, results) {
+                        var rows = results.rows;
+                        var length = rows.length;
+
+                        for (var i = 0; i < length; i++) {
+                            var item = rows.item(i);
+                            var result = item.value;
+
+                            // Check to see if this is serialized content
+                            // we need to unpack.
+                            if (result) {
+                                result = dbInfo.serializer.deserialize(result);
+                            }
+
+                            result = iterator(result, item.key, i + 1);
+
+                            // void(0) prevents problems with redefinition
+                            // of `undefined`.
+                            if (result !== void 0) {
+                                resolve(result);
+                                return;
+                            }
+                        }
+
+                        resolve();
+                    }, function (t, error) {
+                        reject(error);
+                    });
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    function _setItem(key, value, callback, retriesLeft) {
+        var self = this;
+
+        key = (0, _normalizeKey2.default)(key);
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                // The localStorage API doesn't return undefined values in an
+                // "expected" way, so undefined is always cast to null in all
+                // drivers. See: https://github.com/mozilla/localForage/pull/42
+                if (value === undefined) {
+                    value = null;
+                }
+
+                // Save the original value to pass to the callback.
+                var originalValue = value;
+
+                var dbInfo = self._dbInfo;
+                dbInfo.serializer.serialize(value, function (value, error) {
+                    if (error) {
+                        reject(error);
+                    } else {
+                        dbInfo.db.transaction(function (t) {
+                            tryExecuteSql(t, dbInfo, 'INSERT OR REPLACE INTO ' + dbInfo.storeName + ' ' + '(key, value) VALUES (?, ?)', [key, value], function () {
+                                resolve(originalValue);
+                            }, function (t, error) {
+                                reject(error);
+                            });
+                        }, function (sqlError) {
+                            // The transaction failed; check
+                            // to see if it's a quota error.
+                            if (sqlError.code === sqlError.QUOTA_ERR) {
+                                // We reject the callback outright for now, but
+                                // it's worth trying to re-run the transaction.
+                                // Even if the user accepts the prompt to use
+                                // more storage on Safari, this error will
+                                // be called.
+                                //
+                                // Try to re-run the transaction.
+                                if (retriesLeft > 0) {
+                                    resolve(_setItem.apply(self, [key, originalValue, callback, retriesLeft - 1]));
+                                    return;
+                                }
+                                reject(sqlError);
+                            }
+                        });
+                    }
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    function setItem(key, value, callback) {
+        return _setItem.apply(this, [key, value, callback, 1]);
+    }
+
+    function removeItem(key, callback) {
+        var self = this;
+
+        key = (0, _normalizeKey2.default)(key);
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                var dbInfo = self._dbInfo;
+                dbInfo.db.transaction(function (t) {
+                    tryExecuteSql(t, dbInfo, 'DELETE FROM ' + dbInfo.storeName + ' WHERE key = ?', [key], function () {
+                        resolve();
+                    }, function (t, error) {
+                        reject(error);
+                    });
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Deletes every item in the table.
+    // TODO: Find out if this resets the AUTO_INCREMENT number.
+    function clear(callback) {
+        var self = this;
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                var dbInfo = self._dbInfo;
+                dbInfo.db.transaction(function (t) {
+                    tryExecuteSql(t, dbInfo, 'DELETE FROM ' + dbInfo.storeName, [], function () {
+                        resolve();
+                    }, function (t, error) {
+                        reject(error);
+                    });
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Does a simple `COUNT(key)` to get the number of items stored in
+    // localForage.
+    function length(callback) {
+        var self = this;
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                var dbInfo = self._dbInfo;
+                dbInfo.db.transaction(function (t) {
+                    // Ahhh, SQL makes this one soooooo easy.
+                    tryExecuteSql(t, dbInfo, 'SELECT COUNT(key) as c FROM ' + dbInfo.storeName, [], function (t, results) {
+                        var result = results.rows.item(0).c;
+                        resolve(result);
+                    }, function (t, error) {
+                        reject(error);
+                    });
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // Return the key located at key index X; essentially gets the key from a
+    // `WHERE id = ?`. This is the most efficient way I can think to implement
+    // this rarely-used (in my experience) part of the API, but it can seem
+    // inconsistent, because we do `INSERT OR REPLACE INTO` on `setItem()`, so
+    // the ID of each key will change every time it's updated. Perhaps a stored
+    // procedure for the `setItem()` SQL would solve this problem?
+    // TODO: Don't change ID on `setItem()`.
+    function key(n, callback) {
+        var self = this;
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                var dbInfo = self._dbInfo;
+                dbInfo.db.transaction(function (t) {
+                    tryExecuteSql(t, dbInfo, 'SELECT key FROM ' + dbInfo.storeName + ' WHERE id = ? LIMIT 1', [n + 1], function (t, results) {
+                        var result = results.rows.length ? results.rows.item(0).key : null;
+                        resolve(result);
+                    }, function (t, error) {
+                        reject(error);
+                    });
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    function keys(callback) {
+        var self = this;
+
+        var promise = new _promise2.default(function (resolve, reject) {
+            self.ready().then(function () {
+                var dbInfo = self._dbInfo;
+                dbInfo.db.transaction(function (t) {
+                    tryExecuteSql(t, dbInfo, 'SELECT key FROM ' + dbInfo.storeName, [], function (t, results) {
+                        var keys = [];
+
+                        for (var i = 0; i < results.rows.length; i++) {
+                            keys.push(results.rows.item(i).key);
+                        }
+
+                        resolve(keys);
+                    }, function (t, error) {
+                        reject(error);
+                    });
+                });
+            }).catch(reject);
+        });
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    // https://www.w3.org/TR/webdatabase/#databases
+    // > There is no way to enumerate or delete the databases available for an origin from this API.
+    function getAllStoreNames(db) {
+        return new _promise2.default(function (resolve, reject) {
+            db.transaction(function (t) {
+                t.executeSql('SELECT name FROM sqlite_master ' + "WHERE type='table' AND name <> '__WebKitDatabaseInfoTable__'", [], function (t, results) {
+                    var storeNames = [];
+
+                    for (var i = 0; i < results.rows.length; i++) {
+                        storeNames.push(results.rows.item(i).name);
+                    }
+
+                    resolve({
+                        db: db,
+                        storeNames: storeNames
+                    });
+                }, function (t, error) {
+                    reject(error);
+                });
+            }, function (sqlError) {
+                reject(sqlError);
+            });
+        });
+    }
+
+    function dropInstance(options, callback) {
+        callback = _getCallback2.default.apply(this, arguments);
+
+        var currentConfig = this.config();
+        options = typeof options !== 'function' && options || {};
+        if (!options.name) {
+            options.name = options.name || currentConfig.name;
+            options.storeName = options.storeName || currentConfig.storeName;
+        }
+
+        var self = this;
+        var promise;
+        if (!options.name) {
+            promise = _promise2.default.reject('Invalid arguments');
+        } else {
+            promise = new _promise2.default(function (resolve) {
+                var db;
+                if (options.name === currentConfig.name) {
+                    // use the db reference of the current instance
+                    db = self._dbInfo.db;
+                } else {
+                    db = openDatabase(options.name, '', '', 0);
+                }
+
+                if (!options.storeName) {
+                    // drop all database tables
+                    resolve(getAllStoreNames(db));
+                } else {
+                    resolve({
+                        db: db,
+                        storeNames: [options.storeName]
+                    });
+                }
+            }).then(function (operationInfo) {
+                return new _promise2.default(function (resolve, reject) {
+                    operationInfo.db.transaction(function (t) {
+                        function dropTable(storeName) {
+                            return new _promise2.default(function (resolve, reject) {
+                                t.executeSql('DROP TABLE IF EXISTS ' + storeName, [], function () {
+                                    resolve();
+                                }, function (t, error) {
+                                    reject(error);
+                                });
+                            });
+                        }
+
+                        var operations = [];
+                        for (var i = 0, len = operationInfo.storeNames.length; i < len; i++) {
+                            operations.push(dropTable(operationInfo.storeNames[i]));
+                        }
+
+                        _promise2.default.all(operations).then(function () {
+                            resolve();
+                        }).catch(function (e) {
+                            reject(e);
+                        });
+                    }, function (sqlError) {
+                        reject(sqlError);
+                    });
+                });
+            });
+        }
+
+        (0, _executeCallback2.default)(promise, callback);
+        return promise;
+    }
+
+    var webSQLStorage = {
+        _driver: 'webSQLStorage',
+        _initStorage: _initStorage,
+        _support: (0, _isWebSQLValid2.default)(),
+        iterate: iterate,
+        getItem: getItem,
+        setItem: setItem,
+        removeItem: removeItem,
+        clear: clear,
+        length: length,
+        key: key,
+        keys: keys,
+        dropInstance: dropInstance
+    };
+
+    exports.default = webSQLStorage;
+    module.exports = exports['default'];
+});

node_modules/localforage/build/es5src/localforage.js

@@ -0,0 +1,408 @@
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define('localforage', ['module', 'exports', './drivers/indexeddb', './drivers/websql', './drivers/localstorage', './utils/serializer', './utils/promise', './utils/executeCallback', './utils/executeTwoCallbacks', './utils/includes', './utils/isArray'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(module, exports, require('./drivers/indexeddb'), require('./drivers/websql'), require('./drivers/localstorage'), require('./utils/serializer'), require('./utils/promise'), require('./utils/executeCallback'), require('./utils/executeTwoCallbacks'), require('./utils/includes'), require('./utils/isArray'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod, mod.exports, global.indexeddb, global.websql, global.localstorage, global.serializer, global.promise, global.executeCallback, global.executeTwoCallbacks, global.includes, global.isArray);
+        global.localforage = mod.exports;
+    }
+})(this, function (module, exports, _indexeddb, _websql, _localstorage, _serializer, _promise, _executeCallback, _executeTwoCallbacks, _includes, _isArray) {
+    'use strict';
+
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+
+    var _indexeddb2 = _interopRequireDefault(_indexeddb);
+
+    var _websql2 = _interopRequireDefault(_websql);
+
+    var _localstorage2 = _interopRequireDefault(_localstorage);
+
+    var _serializer2 = _interopRequireDefault(_serializer);
+
+    var _promise2 = _interopRequireDefault(_promise);
+
+    var _executeCallback2 = _interopRequireDefault(_executeCallback);
+
+    var _executeTwoCallbacks2 = _interopRequireDefault(_executeTwoCallbacks);
+
+    var _includes2 = _interopRequireDefault(_includes);
+
+    var _isArray2 = _interopRequireDefault(_isArray);
+
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+
+    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+        return typeof obj;
+    } : function (obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+        }
+    }
+
+    // Drivers are stored here when `defineDriver()` is called.
+    // They are shared across all instances of localForage.
+    var DefinedDrivers = {};
+
+    var DriverSupport = {};
+
+    var DefaultDrivers = {
+        INDEXEDDB: _indexeddb2.default,
+        WEBSQL: _websql2.default,
+        LOCALSTORAGE: _localstorage2.default
+    };
+
+    var DefaultDriverOrder = [DefaultDrivers.INDEXEDDB._driver, DefaultDrivers.WEBSQL._driver, DefaultDrivers.LOCALSTORAGE._driver];
+
+    var OptionalDriverMethods = ['dropInstance'];
+
+    var LibraryMethods = ['clear', 'getItem', 'iterate', 'key', 'keys', 'length', 'removeItem', 'setItem'].concat(OptionalDriverMethods);
+
+    var DefaultConfig = {
+        description: '',
+        driver: DefaultDriverOrder.slice(),
+        name: 'localforage',
+        // Default DB size is _JUST UNDER_ 5MB, as it's the highest size
+        // we can use without a prompt.
+        size: 4980736,
+        storeName: 'keyvaluepairs',
+        version: 1.0
+    };
+
+    function callWhenReady(localForageInstance, libraryMethod) {
+        localForageInstance[libraryMethod] = function () {
+            var _args = arguments;
+            return localForageInstance.ready().then(function () {
+                return localForageInstance[libraryMethod].apply(localForageInstance, _args);
+            });
+        };
+    }
+
+    function extend() {
+        for (var i = 1; i < arguments.length; i++) {
+            var arg = arguments[i];
+
+            if (arg) {
+                for (var key in arg) {
+                    if (arg.hasOwnProperty(key)) {
+                        if ((0, _isArray2.default)(arg[key])) {
+                            arguments[0][key] = arg[key].slice();
+                        } else {
+                            arguments[0][key] = arg[key];
+                        }
+                    }
+                }
+            }
+        }
+
+        return arguments[0];
+    }
+
+    var LocalForage = function () {
+        function LocalForage(options) {
+            _classCallCheck(this, LocalForage);
+
+            for (var driverTypeKey in DefaultDrivers) {
+                if (DefaultDrivers.hasOwnProperty(driverTypeKey)) {
+                    var driver = DefaultDrivers[driverTypeKey];
+                    var driverName = driver._driver;
+                    this[driverTypeKey] = driverName;
+
+                    if (!DefinedDrivers[driverName]) {
+                        // we don't need to wait for the promise,
+                        // since the default drivers can be defined
+                        // in a blocking manner
+                        this.defineDriver(driver);
+                    }
+                }
+            }
+
+            this._defaultConfig = extend({}, DefaultConfig);
+            this._config = extend({}, this._defaultConfig, options);
+            this._driverSet = null;
+            this._initDriver = null;
+            this._ready = false;
+            this._dbInfo = null;
+
+            this._wrapLibraryMethodsWithReady();
+            this.setDriver(this._config.driver).catch(function () {});
+        }
+
+        // Set any config values for localForage; can be called anytime before
+        // the first API call (e.g. `getItem`, `setItem`).
+        // We loop through options so we don't overwrite existing config
+        // values.
+
+
+        LocalForage.prototype.config = function config(options) {
+            // If the options argument is an object, we use it to set values.
+            // Otherwise, we return either a specified config value or all
+            // config values.
+            if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) === 'object') {
+                // If localforage is ready and fully initialized, we can't set
+                // any new configuration values. Instead, we return an error.
+                if (this._ready) {
+                    return new Error("Can't call config() after localforage " + 'has been used.');
+                }
+
+                for (var i in options) {
+                    if (i === 'storeName') {
+                        options[i] = options[i].replace(/\W/g, '_');
+                    }
+
+                    if (i === 'version' && typeof options[i] !== 'number') {
+                        return new Error('Database version must be a number.');
+                    }
+
+                    this._config[i] = options[i];
+                }
+
+                // after all config options are set and
+                // the driver option is used, try setting it
+                if ('driver' in options && options.driver) {
+                    return this.setDriver(this._config.driver);
+                }
+
+                return true;
+            } else if (typeof options === 'string') {
+                return this._config[options];
+            } else {
+                return this._config;
+            }
+        };
+
+        LocalForage.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) {
+            var promise = new _promise2.default(function (resolve, reject) {
+                try {
+                    var driverName = driverObject._driver;
+                    var complianceError = new Error('Custom driver not compliant; see ' + 'https://mozilla.github.io/localForage/#definedriver');
+
+                    // A driver name should be defined and not overlap with the
+                    // library-defined, default drivers.
+                    if (!driverObject._driver) {
+                        reject(complianceError);
+                        return;
+                    }
+
+                    var driverMethods = LibraryMethods.concat('_initStorage');
+                    for (var i = 0, len = driverMethods.length; i < len; i++) {
+                        var driverMethodName = driverMethods[i];
+
+                        // when the property is there,
+                        // it should be a method even when optional
+                        var isRequired = !(0, _includes2.default)(OptionalDriverMethods, driverMethodName);
+                        if ((isRequired || driverObject[driverMethodName]) && typeof driverObject[driverMethodName] !== 'function') {
+                            reject(complianceError);
+                            return;
+                        }
+                    }
+
+                    var configureMissingMethods = function configureMissingMethods() {
+                        var methodNotImplementedFactory = function methodNotImplementedFactory(methodName) {
+                            return function () {
+                                var error = new Error('Method ' + methodName + ' is not implemented by the current driver');
+                                var promise = _promise2.default.reject(error);
+                                (0, _executeCallback2.default)(promise, arguments[arguments.length - 1]);
+                                return promise;
+                            };
+                        };
+
+                        for (var _i = 0, _len = OptionalDriverMethods.length; _i < _len; _i++) {
+                            var optionalDriverMethod = OptionalDriverMethods[_i];
+                            if (!driverObject[optionalDriverMethod]) {
+                                driverObject[optionalDriverMethod] = methodNotImplementedFactory(optionalDriverMethod);
+                            }
+                        }
+                    };
+
+                    configureMissingMethods();
+
+                    var setDriverSupport = function setDriverSupport(support) {
+                        if (DefinedDrivers[driverName]) {
+                            console.info('Redefining LocalForage driver: ' + driverName);
+                        }
+                        DefinedDrivers[driverName] = driverObject;
+                        DriverSupport[driverName] = support;
+                        // don't use a then, so that we can define
+                        // drivers that have simple _support methods
+                        // in a blocking manner
+                        resolve();
+                    };
+
+                    if ('_support' in driverObject) {
+                        if (driverObject._support && typeof driverObject._support === 'function') {
+                            driverObject._support().then(setDriverSupport, reject);
+                        } else {
+                            setDriverSupport(!!driverObject._support);
+                        }
+                    } else {
+                        setDriverSupport(true);
+                    }
+                } catch (e) {
+                    reject(e);
+                }
+            });
+
+            (0, _executeTwoCallbacks2.default)(promise, callback, errorCallback);
+            return promise;
+        };
+
+        LocalForage.prototype.driver = function driver() {
+            return this._driver || null;
+        };
+
+        LocalForage.prototype.getDriver = function getDriver(driverName, callback, errorCallback) {
+            var getDriverPromise = DefinedDrivers[driverName] ? _promise2.default.resolve(DefinedDrivers[driverName]) : _promise2.default.reject(new Error('Driver not found.'));
+
+            (0, _executeTwoCallbacks2.default)(getDriverPromise, callback, errorCallback);
+            return getDriverPromise;
+        };
+
+        LocalForage.prototype.getSerializer = function getSerializer(callback) {
+            var serializerPromise = _promise2.default.resolve(_serializer2.default);
+            (0, _executeTwoCallbacks2.default)(serializerPromise, callback);
+            return serializerPromise;
+        };
+
+        LocalForage.prototype.ready = function ready(callback) {
+            var self = this;
+
+            var promise = self._driverSet.then(function () {
+                if (self._ready === null) {
+                    self._ready = self._initDriver();
+                }
+
+                return self._ready;
+            });
+
+            (0, _executeTwoCallbacks2.default)(promise, callback, callback);
+            return promise;
+        };
+
+        LocalForage.prototype.setDriver = function setDriver(drivers, callback, errorCallback) {
+            var self = this;
+
+            if (!(0, _isArray2.default)(drivers)) {
+                drivers = [drivers];
+            }
+
+            var supportedDrivers = this._getSupportedDrivers(drivers);
+
+            function setDriverToConfig() {
+                self._config.driver = self.driver();
+            }
+
+            function extendSelfWithDriver(driver) {
+                self._extend(driver);
+                setDriverToConfig();
+
+                self._ready = self._initStorage(self._config);
+                return self._ready;
+            }
+
+            function initDriver(supportedDrivers) {
+                return function () {
+                    var currentDriverIndex = 0;
+
+                    function driverPromiseLoop() {
+                        while (currentDriverIndex < supportedDrivers.length) {
+                            var driverName = supportedDrivers[currentDriverIndex];
+                            currentDriverIndex++;
+
+                            self._dbInfo = null;
+                            self._ready = null;
+
+                            return self.getDriver(driverName).then(extendSelfWithDriver).catch(driverPromiseLoop);
+                        }
+
+                        setDriverToConfig();
+                        var error = new Error('No available storage method found.');
+                        self._driverSet = _promise2.default.reject(error);
+                        return self._driverSet;
+                    }
+
+                    return driverPromiseLoop();
+                };
+            }
+
+            // There might be a driver initialization in progress
+            // so wait for it to finish in order to avoid a possible
+            // race condition to set _dbInfo
+            var oldDriverSetDone = this._driverSet !== null ? this._driverSet.catch(function () {
+                return _promise2.default.resolve();
+            }) : _promise2.default.resolve();
+
+            this._driverSet = oldDriverSetDone.then(function () {
+                var driverName = supportedDrivers[0];
+                self._dbInfo = null;
+                self._ready = null;
+
+                return self.getDriver(driverName).then(function (driver) {
+                    self._driver = driver._driver;
+                    setDriverToConfig();
+                    self._wrapLibraryMethodsWithReady();
+                    self._initDriver = initDriver(supportedDrivers);
+                });
+            }).catch(function () {
+                setDriverToConfig();
+                var error = new Error('No available storage method found.');
+                self._driverSet = _promise2.default.reject(error);
+                return self._driverSet;
+            });
+
+            (0, _executeTwoCallbacks2.default)(this._driverSet, callback, errorCallback);
+            return this._driverSet;
+        };
+
+        LocalForage.prototype.supports = function supports(driverName) {
+            return !!DriverSupport[driverName];
+        };
+
+        LocalForage.prototype._extend = function _extend(libraryMethodsAndProperties) {
+            extend(this, libraryMethodsAndProperties);
+        };
+
+        LocalForage.prototype._getSupportedDrivers = function _getSupportedDrivers(drivers) {
+            var supportedDrivers = [];
+            for (var i = 0, len = drivers.length; i < len; i++) {
+                var driverName = drivers[i];
+                if (this.supports(driverName)) {
+                    supportedDrivers.push(driverName);
+                }
+            }
+            return supportedDrivers;
+        };
+
+        LocalForage.prototype._wrapLibraryMethodsWithReady = function _wrapLibraryMethodsWithReady() {
+            // Add a stub for each driver API method that delays the call to the
+            // corresponding driver method until localForage is ready. These stubs
+            // will be replaced by the driver methods as soon as the driver is
+            // loaded, so there is no performance impact.
+            for (var i = 0, len = LibraryMethods.length; i < len; i++) {
+                callWhenReady(this, LibraryMethods[i]);
+            }
+        };
+
+        LocalForage.prototype.createInstance = function createInstance(options) {
+            return new LocalForage(options);
+        };
+
+        return LocalForage;
+    }();
+
+    exports.default = new LocalForage();
+    module.exports = exports['default'];
+});

node_modules/localforage/build/es5src/utils/serializer.js

@@ -0,0 +1,256 @@
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define('localforageSerializer', ['module', 'exports', './createBlob'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(module, exports, require('./createBlob'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod, mod.exports, global.createBlob);
+        global.localforageSerializer = mod.exports;
+    }
+})(this, function (module, exports, _createBlob) {
+    'use strict';
+
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+
+    var _createBlob2 = _interopRequireDefault(_createBlob);
+
+    function _interopRequireDefault(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+
+    // Sadly, the best way to save binary data in WebSQL/localStorage is serializing
+    // it to Base64, so this is how we store it to prevent very strange errors with less
+    // verbose ways of binary <-> string data storage.
+    var BASE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; /* eslint-disable no-bitwise */
+
+
+    var BLOB_TYPE_PREFIX = '~~local_forage_type~';
+    var BLOB_TYPE_PREFIX_REGEX = /^~~local_forage_type~([^~]+)~/;
+
+    var SERIALIZED_MARKER = '__lfsc__:';
+    var SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER.length;
+
+    // OMG the serializations!
+    var TYPE_ARRAYBUFFER = 'arbf';
+    var TYPE_BLOB = 'blob';
+    var TYPE_INT8ARRAY = 'si08';
+    var TYPE_UINT8ARRAY = 'ui08';
+    var TYPE_UINT8CLAMPEDARRAY = 'uic8';
+    var TYPE_INT16ARRAY = 'si16';
+    var TYPE_INT32ARRAY = 'si32';
+    var TYPE_UINT16ARRAY = 'ur16';
+    var TYPE_UINT32ARRAY = 'ui32';
+    var TYPE_FLOAT32ARRAY = 'fl32';
+    var TYPE_FLOAT64ARRAY = 'fl64';
+    var TYPE_SERIALIZED_MARKER_LENGTH = SERIALIZED_MARKER_LENGTH + TYPE_ARRAYBUFFER.length;
+
+    var toString = Object.prototype.toString;
+
+    function stringToBuffer(serializedString) {
+        // Fill the string into a ArrayBuffer.
+        var bufferLength = serializedString.length * 0.75;
+        var len = serializedString.length;
+        var i;
+        var p = 0;
+        var encoded1, encoded2, encoded3, encoded4;
+
+        if (serializedString[serializedString.length - 1] === '=') {
+            bufferLength--;
+            if (serializedString[serializedString.length - 2] === '=') {
+                bufferLength--;
+            }
+        }
+
+        var buffer = new ArrayBuffer(bufferLength);
+        var bytes = new Uint8Array(buffer);
+
+        for (i = 0; i < len; i += 4) {
+            encoded1 = BASE_CHARS.indexOf(serializedString[i]);
+            encoded2 = BASE_CHARS.indexOf(serializedString[i + 1]);
+            encoded3 = BASE_CHARS.indexOf(serializedString[i + 2]);
+            encoded4 = BASE_CHARS.indexOf(serializedString[i + 3]);
+
+            /*jslint bitwise: true */
+            bytes[p++] = encoded1 << 2 | encoded2 >> 4;
+            bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
+            bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
+        }
+        return buffer;
+    }
+
+    // Converts a buffer to a string to store, serialized, in the backend
+    // storage library.
+    function bufferToString(buffer) {
+        // base64-arraybuffer
+        var bytes = new Uint8Array(buffer);
+        var base64String = '';
+        var i;
+
+        for (i = 0; i < bytes.length; i += 3) {
+            /*jslint bitwise: true */
+            base64String += BASE_CHARS[bytes[i] >> 2];
+            base64String += BASE_CHARS[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
+            base64String += BASE_CHARS[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
+            base64String += BASE_CHARS[bytes[i + 2] & 63];
+        }
+
+        if (bytes.length % 3 === 2) {
+            base64String = base64String.substring(0, base64String.length - 1) + '=';
+        } else if (bytes.length % 3 === 1) {
+            base64String = base64String.substring(0, base64String.length - 2) + '==';
+        }
+
+        return base64String;
+    }
+
+    // Serialize a value, afterwards executing a callback (which usually
+    // instructs the `setItem()` callback/promise to be executed). This is how
+    // we store binary data with localStorage.
+    function serialize(value, callback) {
+        var valueType = '';
+        if (value) {
+            valueType = toString.call(value);
+        }
+
+        // Cannot use `value instanceof ArrayBuffer` or such here, as these
+        // checks fail when running the tests using casper.js...
+        //
+        // TODO: See why those tests fail and use a better solution.
+        if (value && (valueType === '[object ArrayBuffer]' || value.buffer && toString.call(value.buffer) === '[object ArrayBuffer]')) {
+            // Convert binary arrays to a string and prefix the string with
+            // a special marker.
+            var buffer;
+            var marker = SERIALIZED_MARKER;
+
+            if (value instanceof ArrayBuffer) {
+                buffer = value;
+                marker += TYPE_ARRAYBUFFER;
+            } else {
+                buffer = value.buffer;
+
+                if (valueType === '[object Int8Array]') {
+                    marker += TYPE_INT8ARRAY;
+                } else if (valueType === '[object Uint8Array]') {
+                    marker += TYPE_UINT8ARRAY;
+                } else if (valueType === '[object Uint8ClampedArray]') {
+                    marker += TYPE_UINT8CLAMPEDARRAY;
+                } else if (valueType === '[object Int16Array]') {
+                    marker += TYPE_INT16ARRAY;
+                } else if (valueType === '[object Uint16Array]') {
+                    marker += TYPE_UINT16ARRAY;
+                } else if (valueType === '[object Int32Array]') {
+                    marker += TYPE_INT32ARRAY;
+                } else if (valueType === '[object Uint32Array]') {
+                    marker += TYPE_UINT32ARRAY;
+                } else if (valueType === '[object Float32Array]') {
+                    marker += TYPE_FLOAT32ARRAY;
+                } else if (valueType === '[object Float64Array]') {
+                    marker += TYPE_FLOAT64ARRAY;
+                } else {
+                    callback(new Error('Failed to get type for BinaryArray'));
+                }
+            }
+
+            callback(marker + bufferToString(buffer));
+        } else if (valueType === '[object Blob]') {
+            // Conver the blob to a binaryArray and then to a string.
+            var fileReader = new FileReader();
+
+            fileReader.onload = function () {
+                // Backwards-compatible prefix for the blob type.
+                var str = BLOB_TYPE_PREFIX + value.type + '~' + bufferToString(this.result);
+
+                callback(SERIALIZED_MARKER + TYPE_BLOB + str);
+            };
+
+            fileReader.readAsArrayBuffer(value);
+        } else {
+            try {
+                callback(JSON.stringify(value));
+            } catch (e) {
+                console.error("Couldn't convert value into a JSON string: ", value);
+
+                callback(null, e);
+            }
+        }
+    }
+
+    // Deserialize data we've inserted into a value column/field. We place
+    // special markers into our strings to mark them as encoded; this isn't
+    // as nice as a meta field, but it's the only sane thing we can do whilst
+    // keeping localStorage support intact.
+    //
+    // Oftentimes this will just deserialize JSON content, but if we have a
+    // special marker (SERIALIZED_MARKER, defined above), we will extract
+    // some kind of arraybuffer/binary data/typed array out of the string.
+    function deserialize(value) {
+        // If we haven't marked this string as being specially serialized (i.e.
+        // something other than serialized JSON), we can just return it and be
+        // done with it.
+        if (value.substring(0, SERIALIZED_MARKER_LENGTH) !== SERIALIZED_MARKER) {
+            return JSON.parse(value);
+        }
+
+        // The following code deals with deserializing some kind of Blob or
+        // TypedArray. First we separate out the type of data we're dealing
+        // with from the data itself.
+        var serializedString = value.substring(TYPE_SERIALIZED_MARKER_LENGTH);
+        var type = value.substring(SERIALIZED_MARKER_LENGTH, TYPE_SERIALIZED_MARKER_LENGTH);
+
+        var blobType;
+        // Backwards-compatible blob type serialization strategy.
+        // DBs created with older versions of localForage will simply not have the blob type.
+        if (type === TYPE_BLOB && BLOB_TYPE_PREFIX_REGEX.test(serializedString)) {
+            var matcher = serializedString.match(BLOB_TYPE_PREFIX_REGEX);
+            blobType = matcher[1];
+            serializedString = serializedString.substring(matcher[0].length);
+        }
+        var buffer = stringToBuffer(serializedString);
+
+        // Return the right type based on the code/type set during
+        // serialization.
+        switch (type) {
+            case TYPE_ARRAYBUFFER:
+                return buffer;
+            case TYPE_BLOB:
+                return (0, _createBlob2.default)([buffer], { type: blobType });
+            case TYPE_INT8ARRAY:
+                return new Int8Array(buffer);
+            case TYPE_UINT8ARRAY:
+                return new Uint8Array(buffer);
+            case TYPE_UINT8CLAMPEDARRAY:
+                return new Uint8ClampedArray(buffer);
+            case TYPE_INT16ARRAY:
+                return new Int16Array(buffer);
+            case TYPE_UINT16ARRAY:
+                return new Uint16Array(buffer);
+            case TYPE_INT32ARRAY:
+                return new Int32Array(buffer);
+            case TYPE_UINT32ARRAY:
+                return new Uint32Array(buffer);
+            case TYPE_FLOAT32ARRAY:
+                return new Float32Array(buffer);
+            case TYPE_FLOAT64ARRAY:
+                return new Float64Array(buffer);
+            default:
+                throw new Error('Unkown type: ' + type);
+        }
+    }
+
+    var localforageSerializer = {
+        serialize: serialize,
+        deserialize: deserialize,
+        stringToBuffer: stringToBuffer,
+        bufferToString: bufferToString
+    };
+
+    exports.default = localforageSerializer;
+    module.exports = exports['default'];
+});