diff --git a/CHANGELOG.MD b/CHANGELOG.MD
index 40ff7176c..47f1a0bae 100644
--- a/CHANGELOG.MD
+++ b/CHANGELOG.MD
@@ -1,5 +1,14 @@
 # Change Log
 
+## Version 3.9.2 - Dec 7, 2020
+
+* Viewer: massive improvement of rendering performance.
+* Viewer: fixes layout request in filtered viewers.
+* Viewer-based dialogs: allows open an item with the Enter key.
+* Scene Editor: caches scene file thumbnails in local browser Indexed DB. 
+* Scene Editor: more accuracy on thumbnail generation of container-based prefabs.
+* Restore custom "alert" message dialog.
+
 ## Version 3.9.1 - Nov 30, 2020
 
 * Check if a new version is available at startup.
diff --git a/source/editor/plugins/colibri/src/core/io/FileContentCache.ts b/source/editor/plugins/colibri/src/core/io/FileContentCache.ts
index ff442fda4..45a87e517 100644
--- a/source/editor/plugins/colibri/src/core/io/FileContentCache.ts
+++ b/source/editor/plugins/colibri/src/core/io/FileContentCache.ts
@@ -1,14 +1,25 @@
 namespace colibri.core.io {
 
-    export declare type GetFileContent<T> = (file: FilePath) => Promise<T>;
+    export declare type GetFileContent<T> = (file: FilePath, force?:boolean) => Promise<T>;
 
     export declare type SetFileContent<T> = (file: FilePath, content: T) => Promise<void>;
 
+    export interface IContentCacheMap<T> {
+
+        has(key: string): boolean;
+
+        delete(key: string): void;
+
+        set(key: string, value: ContentEntry<T>): void;
+
+        get(key: string): ContentEntry<T>;
+    }
+
     export class FileContentCache<T> {
 
         private _backendGetContent: GetFileContent<T>;
         private _backendSetContent: SetFileContent<T>;
-        private _map: Map<string, ContentEntry<T>>;
+        private _map: IContentCacheMap<T>;
         private _preloadMap: Map<string, Promise<ui.controls.PreloadResult>>;
 
         constructor(getContent: GetFileContent<T>, setContent?: SetFileContent<T>) {
@@ -30,6 +41,7 @@ namespace colibri.core.io {
             const filename = file.getFullName();
 
             if (this._preloadMap.has(filename)) {
+
                 return this._preloadMap.get(filename);
             }
 
@@ -38,10 +50,11 @@ namespace colibri.core.io {
             if (entry) {
 
                 if (!force && entry.modTime === file.getModTime()) {
+
                     return ui.controls.Controls.resolveNothingLoaded();
                 }
 
-                const promise2 = this._backendGetContent(file)
+                const promise2 = this._backendGetContent(file, force)
 
                     .then((content) => {
 
@@ -58,7 +71,7 @@ namespace colibri.core.io {
                 return promise2;
             }
 
-            const promise = this._backendGetContent(file)
+            const promise = this._backendGetContent(file, force)
 
                 .then((content) => {
 
@@ -116,5 +129,4 @@ namespace colibri.core.io {
         ) {
         }
     }
-
 }
\ No newline at end of file
diff --git a/source/editor/plugins/colibri/src/ui/controls/Controls.ts b/source/editor/plugins/colibri/src/ui/controls/Controls.ts
index 98f65bde3..0f7333987 100644
--- a/source/editor/plugins/colibri/src/ui/controls/Controls.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/Controls.ts
@@ -54,11 +54,46 @@ namespace colibri.ui.controls {
             return ctx;
         }
 
+        private static _charWidthMap: Map<string, number> = new Map();
+        private static _textWidthMap: Map<string, number> = new Map();
+
         static measureTextWidth(context: CanvasRenderingContext2D, label: string) {
 
-            const measure = context.measureText(label);
+            const font = FONT_FAMILY + FONT_HEIGHT;
+
+            const textKey = font + "@" + label;
+
+            let width = 0;
+
+            if (this._textWidthMap.has(textKey)) {
+
+                width = this._textWidthMap.get(textKey);
+
+            } else {
+
+                for (const c of label) {
+
+                    const key = font + "@" + c;
+
+                    let charWidth = 0;
+
+                    if (this._charWidthMap.has(key)) {
+
+                        charWidth = this._charWidthMap.get(key);
+
+                    } else {
+
+                        charWidth = context.measureText(c).width;
+                        this._charWidthMap.set(key, charWidth);
+                    }
+
+                    width += charWidth;
+                }
+
+                this._textWidthMap.set(textKey, width);
+            }
 
-            return measure.width * DEVICE_PIXEL_RATIO;
+            return width * DEVICE_PIXEL_RATIO;
         }
 
         static setDragEventImage(e: DragEvent, render: (ctx: CanvasRenderingContext2D, w: number, h: number) => void) {
diff --git a/source/editor/plugins/colibri/src/ui/controls/ImageFrame.ts b/source/editor/plugins/colibri/src/ui/controls/ImageFrame.ts
index 95c709e63..27398445a 100644
--- a/source/editor/plugins/colibri/src/ui/controls/ImageFrame.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/ImageFrame.ts
@@ -72,9 +72,9 @@ namespace colibri.ui.controls {
 
         paintFrame(context: CanvasRenderingContext2D,
 
-                   srcX: number, srcY: number, scrW: number, srcH: number,
+            srcX: number, srcY: number, scrW: number, srcH: number,
 
-                   dstX: number, dstY: number, dstW: number, dstH: number): void {
+            dstX: number, dstY: number, dstW: number, dstH: number): void {
 
             // not implemented fow now
         }
@@ -82,6 +82,7 @@ namespace colibri.ui.controls {
         preload(): Promise<PreloadResult> {
 
             if (this._image === null) {
+
                 return controls.Controls.resolveNothingLoaded();
             }
 
diff --git a/source/editor/plugins/colibri/src/ui/controls/ImageWrapper.ts b/source/editor/plugins/colibri/src/ui/controls/ImageWrapper.ts
index 2dff46115..403be4161 100644
--- a/source/editor/plugins/colibri/src/ui/controls/ImageWrapper.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/ImageWrapper.ts
@@ -57,6 +57,11 @@ namespace colibri.ui.controls {
 
             return 0;
         }
+
+        getImageElement() {
+
+            return this._imageElement;
+        }
     }
 
 }
\ No newline at end of file
diff --git a/source/editor/plugins/colibri/src/ui/controls/ScrollPane.ts b/source/editor/plugins/colibri/src/ui/controls/ScrollPane.ts
index 3b72699ab..f788702d4 100644
--- a/source/editor/plugins/colibri/src/ui/controls/ScrollPane.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/ScrollPane.ts
@@ -43,32 +43,44 @@ namespace colibri.ui.controls {
         }
 
         getViewer() {
+
             if (this._clientControl instanceof viewers.ViewerContainer) {
+
                 return this._clientControl.getViewer();
             }
+
             return this._clientControl;
         }
 
         updateScroll(clientContentHeight: number) {
+
             const scrollY = this.getViewer().getScrollY();
+
             const b = this.getBounds();
+
             let newScrollY = scrollY;
             newScrollY = Math.max(-this._clientContentHeight + b.height, newScrollY);
             newScrollY = Math.min(0, newScrollY);
 
             if (newScrollY !== scrollY) {
+
                 this._clientContentHeight = clientContentHeight;
                 this.setClientScrollY(scrollY);
+
             } else if (clientContentHeight !== this._clientContentHeight) {
+
                 this._clientContentHeight = clientContentHeight;
                 this.layout();
             }
         }
 
         private onBarMouseDown(e: MouseEvent) {
+
             if (e.target !== this._scrollBar) {
+
                 return;
             }
+
             e.stopImmediatePropagation();
             const b = this.getBounds();
             this.setClientScrollY(- e.offsetY / b.height * (this._clientContentHeight - b.height));
@@ -77,6 +89,7 @@ namespace colibri.ui.controls {
         private onClientWheel(e: WheelEvent) {
 
             if (e.shiftKey || e.ctrlKey || e.metaKey || e.altKey) {
+
                 return;
             }
 
@@ -103,15 +116,20 @@ namespace colibri.ui.controls {
         private _startScrollY = 0;
 
         private onMouseDown(e: MouseEvent) {
+
             if (e.target === this._scrollHandler) {
+
                 e.stopImmediatePropagation();
+
                 this._startDragY = e.y;
                 this._startScrollY = this.getViewer().getScrollY();
             }
         }
 
         private onMouseMove(e: MouseEvent) {
+
             if (this._startDragY !== -1) {
+
                 let delta = e.y - this._startDragY;
                 const b = this.getBounds();
                 delta = delta / b.height * this._clientContentHeight;
@@ -120,21 +138,27 @@ namespace colibri.ui.controls {
         }
 
         private onMouseUp(e: MouseEvent) {
+
             if (this._startDragY !== -1) {
+
                 e.stopImmediatePropagation();
                 this._startDragY = -1;
             }
         }
 
         getBounds() {
+
             const b = this.getElement().getBoundingClientRect();
+
             return { x: 0, y: 0, width: b.width, height: b.height };
         }
 
         layout(): void {
+
             const b = this.getBounds();
 
             if (b.height < this._clientContentHeight) {
+
                 this._scrollHandler.style.display = "block";
                 const h = Math.max(10, b.height / this._clientContentHeight * b.height);
                 const y = -(b.height - h) * this.getViewer().getScrollY() / (this._clientContentHeight - b.height);
@@ -143,8 +167,11 @@ namespace colibri.ui.controls {
                     y: y,
                     height: h
                 });
+
                 this.removeClass("hideScrollBar");
+
             } else {
+
                 this.addClass("hideScrollBar");
             }
 
diff --git a/source/editor/plugins/colibri/src/ui/controls/dialogs/AbstractViewerDialog.ts b/source/editor/plugins/colibri/src/ui/controls/dialogs/AbstractViewerDialog.ts
index 1e47010b8..db2bc266c 100644
--- a/source/editor/plugins/colibri/src/ui/controls/dialogs/AbstractViewerDialog.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/dialogs/AbstractViewerDialog.ts
@@ -26,6 +26,7 @@ namespace colibri.ui.controls.dialogs {
         }
 
         getViewer() {
+
             return this._viewer;
         }
 
@@ -39,6 +40,7 @@ namespace colibri.ui.controls.dialogs {
             this.resize();
 
             if (this._viewer) {
+
                 this._viewer.repaint();
             }
         }
@@ -85,9 +87,9 @@ namespace colibri.ui.controls.dialogs {
 
             const inputElement = this.getFilteredViewer().getFilterControl().getElement();
 
-            inputElement.addEventListener("keyup", e => {
+            const listener = e => {
 
-                if (e.keyCode === 13) {
+                if (e.key === "Enter") {
 
                     e.preventDefault();
 
@@ -111,7 +113,10 @@ namespace colibri.ui.controls.dialogs {
                         btn.click();
                     }
                 }
-            });
+            };
+
+            inputElement.addEventListener("keyup", listener);
+            this.getViewer().getElement().addEventListener("keyup", listener);
 
             return btn;
         }
diff --git a/source/editor/plugins/colibri/src/ui/controls/dialogs/Dialog.ts b/source/editor/plugins/colibri/src/ui/controls/dialogs/Dialog.ts
index 26c426190..a39785168 100644
--- a/source/editor/plugins/colibri/src/ui/controls/dialogs/Dialog.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/dialogs/Dialog.ts
@@ -168,7 +168,7 @@ namespace colibri.ui.controls.dialogs {
 
             inputElement.addEventListener("keyup", e => {
 
-                if (e.keyCode === 13) {
+                if (e.key === "Enter") {
 
                     e.preventDefault();
 
diff --git a/source/editor/plugins/colibri/src/ui/controls/globals.ts b/source/editor/plugins/colibri/src/ui/controls/globals.ts
index c38760db0..311802eb0 100644
--- a/source/editor/plugins/colibri/src/ui/controls/globals.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/globals.ts
@@ -3,6 +3,7 @@ namespace colibri.ui.controls {
     export const CONTROL_PADDING = 3;
     export const ROW_HEIGHT = 20;
     export const FONT_HEIGHT = 14;
+    export const FONT_WITH = 12;
     export const FONT_OFFSET = 2;
     export const FONT_FAMILY = "Arial, Helvetica, sans-serif";
     export const ACTION_WIDTH = 20;
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/FilteredViewer.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/FilteredViewer.ts
index a1f083e92..0a8a8a7d8 100644
--- a/source/editor/plugins/colibri/src/ui/controls/viewers/FilteredViewer.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/FilteredViewer.ts
@@ -36,7 +36,8 @@ namespace colibri.ui.controls.viewers {
                 this.addZoomControl();
             }
 
-            setTimeout(() => this.layout(), 1);
+            //setTimeout(() => this.layout(), 1);
+            requestAnimationFrame(() => this.layout());
         }
 
         private addZoomControl() {
@@ -204,6 +205,7 @@ namespace colibri.ui.controls.viewers {
         }
 
         layout() {
+
             this._viewerContainer.layout();
             this._scrollPane.layout();
         }
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/GridTreeViewerRenderer.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/GridTreeViewerRenderer.ts
index 0a2fd0785..a93d5eba9 100644
--- a/source/editor/plugins/colibri/src/ui/controls/viewers/GridTreeViewerRenderer.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/GridTreeViewerRenderer.ts
@@ -48,6 +48,7 @@ namespace colibri.ui.controls.viewers {
             parentPaintItem: PaintItem, x: number, y: number) {
 
             const viewer = this.getViewer();
+            const paintAreaHeight = viewer.getBounds().height;
 
             const labelProvider = viewer.getLabelProvider();
 
@@ -58,13 +59,16 @@ namespace colibri.ui.controls.viewers {
                 const limit = 64 * controls.DEVICE_PIXEL_RATIO;
 
                 if (cellSize < limit) {
+
                     cellSize = limit;
+
                     viewer.setCellSize(cellSize);
                 }
 
             } else {
 
                 if (cellSize <= 48) {
+
                     return super.paintItems(objects, treeIconList, paintItems, null, x, y);
                 }
             }
@@ -94,26 +98,32 @@ namespace colibri.ui.controls.viewers {
                     }
 
                     if (first) {
+
                         first = false;
+
                     } else {
+
                         y2 += sectionMargin;
                     }
 
-                    const label = labelProvider.getLabel(section);
+                    if (y2 >= -cellSize && y2 <= paintAreaHeight) {
 
-                    ctx.save();
+                        const label = labelProvider.getLabel(section);
 
-                    ctx.fillStyle = "rgba(0, 0, 0, 0.05)";
+                        ctx.save();
 
-                    ctx.fillRect(0, y2 - 18, b.width, 25);
+                        ctx.fillStyle = "rgba(0, 0, 0, 0.05)";
 
-                    ctx.fillStyle = controls.Controls.getTheme().viewerForeground + "aa";
+                        ctx.fillRect(0, y2 - 18, b.width, 25);
 
-                    const textWidth = controls.Controls.measureTextWidth(ctx, label);
+                        ctx.fillStyle = controls.Controls.getTheme().viewerForeground + "aa";
 
-                    ctx.fillText(label, b.width / 2 - textWidth / 2, y2);
+                        const textWidth = controls.Controls.measureTextWidth(ctx, label);
 
-                    ctx.restore();
+                        ctx.fillText(label, b.width / 2 - textWidth / 2, y2);
+
+                        ctx.restore();
+                    }
 
                     y2 += sectionMargin;
 
@@ -123,9 +133,9 @@ namespace colibri.ui.controls.viewers {
                     y2 = result.y + sectionMargin;
 
                     if (result.x > TREE_RENDERER_GRID_PADDING) {
+
                         y2 += cellSize;
                     }
-
                 }
 
                 return {
@@ -168,7 +178,7 @@ namespace colibri.ui.controls.viewers {
 
                     const args = new RenderCellArgs(context, x, y, cellSize, cellSize, obj, viewer, true);
 
-                    this.renderGridCell(args, renderer, depth, obj === lastObj);
+                    let isItemVisible = false;
 
                     if (y > -cellSize && y < b.height) {
 
@@ -201,9 +211,12 @@ namespace colibri.ui.controls.viewers {
                                 obj: obj
                             });
                         }
+
+                        isItemVisible = true;
+                        this.renderGridCell(args, renderer, depth, obj === lastObj);
                     }
 
-                    const item = new PaintItem(paintItems.length, obj, parentPaintItem);
+                    const item = new PaintItem(paintItems.length, obj, parentPaintItem, isItemVisible);
 
                     item.set(args.x, args.y, args.w, args.h);
 
@@ -244,31 +257,6 @@ namespace colibri.ui.controls.viewers {
 
             const ctx = args.canvasContext;
 
-            const label = args.viewer.getLabelProvider().getLabel(args.obj);
-
-            let line = "";
-
-            for (const c of label) {
-
-                const test = line + c;
-
-                const textWidth = controls.Controls.measureTextWidth(ctx, test);
-
-                if (textWidth > args.w) {
-
-                    if (line.length > 2) {
-
-                        line = line.substring(0, line.length - 2) + "..";
-                    }
-
-                    break;
-
-                } else {
-
-                    line += c;
-                }
-            }
-
             const selected = args.viewer.isSelected(args.obj);
 
             let labelHeight: number;
@@ -314,16 +302,51 @@ namespace colibri.ui.controls.viewers {
 
                 this.prepareContextForText(args);
 
-                const m = ctx.measureText(line);
 
-                const x2 = Math.max(x, x + args.w / 2 - m.width / 2);
+                const label = args.viewer.getLabelProvider().getLabel(args.obj);
+
+                const trim = this.trimLabel(ctx, label, args.w);
+
+                const x2 = Math.max(x, x + args.w / 2 - trim.textWidth / 2);
 
-                ctx.fillText(line, x2, args.y + args.h - 5);
+                ctx.fillText(trim.text, x2, args.y + args.h - 5);
 
                 ctx.restore();
             }
         }
 
+        private trimLabel(ctx: CanvasRenderingContext2D, label: string, maxWidth: number) {
+
+            let text = "";
+            let textWidth = 0;
+
+            for (const c of label) {
+
+                const test = text + c;
+
+                textWidth = controls.Controls.measureTextWidth(ctx, test);
+
+                if (textWidth > maxWidth) {
+
+                    if (text.length > 2) {
+
+                        text = text.substring(0, text.length - 2) + "..";
+                    }
+
+                    break;
+
+                } else {
+
+                    text += c;
+                }
+            }
+
+            return {
+                text,
+                textWidth
+            };
+        }
+
         protected renderCellBack(args: RenderCellArgs, selected: boolean, isLastChild: boolean) {
 
             if (selected) {
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/ImageCellRenderer.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/ImageCellRenderer.ts
index 3aebaca83..8c905258b 100644
--- a/source/editor/plugins/colibri/src/ui/controls/viewers/ImageCellRenderer.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/ImageCellRenderer.ts
@@ -34,6 +34,7 @@ namespace colibri.ui.controls.viewers {
         }
 
         cellHeight(args: RenderCellArgs): number {
+
             return args.viewer.getCellSize();
         }
 
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/OneCharCellRenderer.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/OneCharCellRenderer.ts
new file mode 100644
index 000000000..0830743c0
--- /dev/null
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/OneCharCellRenderer.ts
@@ -0,0 +1,39 @@
+namespace colibri.ui.controls.viewers {
+
+    export class OneCharCellRenderer implements ICellRenderer {
+
+        private _iconSize: boolean;
+
+        constructor(iconSize: boolean) {
+
+            this._iconSize = iconSize;
+        }
+
+        renderCell(args: RenderCellArgs): void {
+
+            const label = args.viewer.getLabelProvider().getLabel(args.obj);
+
+            const ctx = args.canvasContext;
+
+            let char = label.trim();
+
+            if (label.length > 0) {
+
+                char = label[0];
+
+                ctx.fillText(char, args.x + args.w / 2, args.y + args.h / 2, args.w);
+            }
+        }
+
+        cellHeight(args: RenderCellArgs): number {
+
+            return this._iconSize ? controls.ROW_HEIGHT : args.viewer.getCellSize();
+        }
+
+        preload(args: PreloadCellArgs): Promise<PreloadResult> {
+
+            return controls.Controls.resolveNothingLoaded();
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/PaintItem.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/PaintItem.ts
index 25100af0b..ed52cdb56 100644
--- a/source/editor/plugins/colibri/src/ui/controls/viewers/PaintItem.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/PaintItem.ts
@@ -4,7 +4,8 @@ namespace colibri.ui.controls.viewers {
         constructor(
             public index: number,
             public data: any,
-            public parent: PaintItem = null
+            public parent: PaintItem = null,
+            public visible: boolean
         ) {
             super();
         }
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewer.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewer.ts
index b98740d5f..5fa93274e 100644
--- a/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewer.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewer.ts
@@ -230,29 +230,6 @@ namespace colibri.ui.controls.viewers {
             }
         }
 
-        async preload(): Promise<PreloadResult> {
-
-            const list: Array<Promise<PreloadResult>> = [];
-
-            const viewer = this;
-
-            this.visitObjects(obj => {
-
-                const provider = this.getCellRendererProvider();
-
-                list.push(provider.preload(new PreloadCellArgs(obj, viewer)).then(r1 => {
-
-                    const renderer = provider.getCellRenderer(obj);
-
-                    return renderer.preload(new PreloadCellArgs(obj, viewer)).then(r2 => {
-                        return Math.max(r1, r2);
-                    });
-                }));
-            });
-
-            return Controls.resolveAll(list);
-        }
-
         protected paint(): void {
 
             const result = this._treeRenderer.paint();
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewerRenderer.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewerRenderer.ts
index d6300ca39..51377eaa1 100644
--- a/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewerRenderer.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/TreeViewerRenderer.ts
@@ -79,10 +79,13 @@ namespace colibri.ui.controls.viewers {
 
                     viewer.paintItemBackground(obj, 0, y, b.width, cellHeight);
 
+                    let isItemVisible = false;
+
                     if (y > -viewer.getCellSize() && y < b.height) {
 
                         // render tree icon
                         if (children.length > 0) {
+
                             const iconY = y + (cellHeight - TREE_ICON_SIZE) / 2;
 
                             const themeIcon = ColibriPlugin.getInstance()
@@ -103,10 +106,11 @@ namespace colibri.ui.controls.viewers {
                             });
                         }
 
+                        isItemVisible = true;
                         this.renderTreeCell(args, renderer);
                     }
 
-                    const item = new PaintItem(paintItems.length, obj, parentPaintItem);
+                    const item = new PaintItem(paintItems.length, obj, parentPaintItem, isItemVisible);
                     item.set(args.x, args.y, args.w, args.h);
                     paintItems.push(item);
 
diff --git a/source/editor/plugins/colibri/src/ui/controls/viewers/Viewer.ts b/source/editor/plugins/colibri/src/ui/controls/viewers/Viewer.ts
index c7c477b6f..78aa6083f 100644
--- a/source/editor/plugins/colibri/src/ui/controls/viewers/Viewer.ts
+++ b/source/editor/plugins/colibri/src/ui/controls/viewers/Viewer.ts
@@ -460,13 +460,17 @@ namespace colibri.ui.controls.viewers {
         }
 
         expandCollapseBranch(obj: any) {
+
             const parents = [];
 
             const item = this._paintItems.find(i => i.data === obj);
 
             if (item && item.parent) {
+
                 const parentObj = item.parent.data;
+
                 this.setExpanded(parentObj, !this.isExpanded(parentObj));
+
                 parents.push(parentObj);
             }
 
@@ -498,17 +502,18 @@ namespace colibri.ui.controls.viewers {
 
             this.repaint2();
 
-            const result = await this.preload();
+            this.preload(this._paintItems).then(result => {
 
-            if (result === PreloadResult.RESOURCES_LOADED) {
+                if (result === PreloadResult.RESOURCES_LOADED) {
 
-                this.repaint2();
-            }
+                    this.repaint2();
+                }
+            });
 
             this.updateScrollPane();
         }
 
-        updateScrollPane() {
+        private updateScrollPane() {
 
             const pane = this.getContainer().getContainer();
 
@@ -536,7 +541,27 @@ namespace colibri.ui.controls.viewers {
             }
         }
 
-        protected abstract preload(): Promise<PreloadResult>;
+        private async preload(paintItems: PaintItem[]): Promise<PreloadResult> {
+
+            const viewer = this;
+
+            const rendererProvider = this.getCellRendererProvider();
+
+            let result = PreloadResult.NOTHING_LOADED;
+
+            for (const paintItem of paintItems) {
+
+                const obj = paintItem.data;
+
+                const renderer = rendererProvider.getCellRenderer(obj);
+
+                const itemResult = await renderer.preload(new PreloadCellArgs(obj, viewer));
+
+                result = Math.max(itemResult, result);
+            }
+
+            return result;
+        }
 
         paintItemBackground(obj: any, x: number, y: number, w: number, h: number, radius: number = 0): void {
 
diff --git a/source/editor/plugins/phasereditor2d.blocks/src/ui/views/BlocksView.ts b/source/editor/plugins/phasereditor2d.blocks/src/ui/views/BlocksView.ts
index 1cfa27cda..9b7485a8e 100644
--- a/source/editor/plugins/phasereditor2d.blocks/src/ui/views/BlocksView.ts
+++ b/source/editor/plugins/phasereditor2d.blocks/src/ui/views/BlocksView.ts
@@ -11,11 +11,12 @@ namespace phasereditor2d.blocks.ui.views {
             super("BlocksView");
 
             this.setTitle("Blocks");
-            this.setIcon(BlocksPlugin.getInstance().getIcon(ICON_BLOCKS));
 
+            this.setIcon(BlocksPlugin.getInstance().getIcon(ICON_BLOCKS));
         }
 
         getViewerProvider(editor: ide.EditorPart) {
+
             return editor.getEditorViewerProvider(BlocksView.EDITOR_VIEWER_PROVIDER_KEY);
         }
     }
diff --git a/source/editor/plugins/phasereditor2d.ide/src/IDEPlugin.ts b/source/editor/plugins/phasereditor2d.ide/src/IDEPlugin.ts
index 4b96914f7..e00de8af0 100644
--- a/source/editor/plugins/phasereditor2d.ide/src/IDEPlugin.ts
+++ b/source/editor/plugins/phasereditor2d.ide/src/IDEPlugin.ts
@@ -335,7 +335,7 @@ namespace phasereditor2d.ide {
 
     /* program entry point */
 
-    export const VER = "3.9.1";
+    export const VER = "3.9.2";
 
     async function main() {
 
@@ -349,6 +349,7 @@ namespace phasereditor2d.ide {
             "background-color:silver",
         );
 
+        colibri.ui.controls.dialogs.AlertDialog.replaceConsoleAlert();
 
         await IDEPlugin.getInstance().requestServerMode();
 
diff --git a/source/editor/plugins/phasereditor2d.ide/src/core/IProjectSettings.ts b/source/editor/plugins/phasereditor2d.ide/src/core/IProjectSettings.ts
new file mode 100644
index 000000000..2eff5eac3
--- /dev/null
+++ b/source/editor/plugins/phasereditor2d.ide/src/core/IProjectSettings.ts
@@ -0,0 +1,7 @@
+namespace phasereditor2d.ide.core {
+
+    export interface IProjectSettings {
+
+        disableViewerCellRendererPreview?: boolean;
+    }
+}
\ No newline at end of file
diff --git a/source/editor/plugins/phasereditor2d.pack/src/core/ImageFrameContainerAssetPackItem.ts b/source/editor/plugins/phasereditor2d.pack/src/core/ImageFrameContainerAssetPackItem.ts
index d907af48f..0b2da044c 100644
--- a/source/editor/plugins/phasereditor2d.pack/src/core/ImageFrameContainerAssetPackItem.ts
+++ b/source/editor/plugins/phasereditor2d.pack/src/core/ImageFrameContainerAssetPackItem.ts
@@ -41,12 +41,7 @@ namespace phasereditor2d.pack.core {
 
             for (const frame of frames) {
 
-                const img = frame.getImage();
-
-                if (img) {
-
-                    result = Math.max(await img.preload(), result);
-                }
+                result = Math.max(await frame.preload(), result);
             }
 
             const result2 = await this.makeThumbnail();
diff --git a/source/editor/plugins/phasereditor2d.pack/src/ui/viewers/AtlasItemCellRenderer.ts b/source/editor/plugins/phasereditor2d.pack/src/ui/viewers/AtlasItemCellRenderer.ts
index 74b619912..53cedd3ca 100644
--- a/source/editor/plugins/phasereditor2d.pack/src/ui/viewers/AtlasItemCellRenderer.ts
+++ b/source/editor/plugins/phasereditor2d.pack/src/ui/viewers/AtlasItemCellRenderer.ts
@@ -13,11 +13,15 @@ namespace phasereditor2d.pack.ui.viewers {
 
             const container = args.obj as pack.core.ImageFrameContainerAssetPackItem;
 
-            const r1 = await container.preload();
+            await container.preload();
+
+            const r1 = container.getThumbnail() ? controls.PreloadResult.NOTHING_LOADED : controls.PreloadResult.RESOURCES_LOADED;
 
             const r2 = await container.preloadImages();
 
-            return Math.max(r1, r2);
+            const result = Math.max(r1, r2);
+
+            return result;
         }
     }
 }
\ No newline at end of file
diff --git a/source/editor/plugins/phasereditor2d.scene/libs/localforage.js b/source/editor/plugins/phasereditor2d.scene/libs/localforage.js
new file mode 100644
index 000000000..2c2a8336b
--- /dev/null
+++ b/source/editor/plugins/phasereditor2d.scene/libs/localforage.js
@@ -0,0 +1,2959 @@
+/*!
+    localForage -- Offline Storage, Improved
+    Version 1.9.0
+    https://localforage.github.io/localForage
+    (c) 2013-2017 Mozilla, Apache License 2.0
+*/
+(function (f) {
+    var g;
+    if (typeof window !== "undefined") {
+        g = window
+    } else if (typeof global !== "undefined") {
+        g = global
+    } else if (typeof self !== "undefined") {
+        g = self
+    } else {
+        g = this
+    }
+    g.localforage = f()
+}
+)(function () {
+    var define, module, exports;
+    return (function e(t, n, r) {
+        function s(o, u) {
+            if (!n[o]) {
+                if (!t[o]) {
+                    var a = typeof require == "function" && require;
+                    if (!u && a)
+                        return a(o, !0);
+                    if (i)
+                        return i(o, !0);
+                    var f = new Error("Cannot find module '" + o + "'");
+                    throw (f.code = "MODULE_NOT_FOUND",
+                        f)
+                }
+                var l = n[o] = {
+                    exports: {}
+                };
+                t[o][0].call(l.exports, function (e) {
+                    var n = t[o][1][e];
+                    return s(n ? n : e)
+                }, l, l.exports, e, t, n, r)
+            }
+            return n[o].exports
+        }
+        var i = typeof require == "function" && require;
+        for (var o = 0; o < r.length; o++)
+            s(r[o]);
+        return s
+    }
+    )({
+        1: [function (_dereq_, module, exports) {
+            (function (global) {
+                'use strict';
+                var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+
+                var scheduleDrain;
+
+                {
+                    if (Mutation) {
+                        var called = 0;
+                        var observer = new Mutation(nextTick);
+                        var element = global.document.createTextNode('');
+                        observer.observe(element, {
+                            characterData: true
+                        });
+                        scheduleDrain = function () {
+                            element.data = (called = ++called % 2);
+                        }
+                            ;
+                    } else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {
+                        var channel = new global.MessageChannel();
+                        channel.port1.onmessage = nextTick;
+                        scheduleDrain = function () {
+                            channel.port2.postMessage(0);
+                        }
+                            ;
+                    } else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {
+                        scheduleDrain = function () {
+
+                            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+                            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+                            var scriptEl = global.document.createElement('script');
+                            scriptEl.onreadystatechange = function () {
+                                nextTick();
+
+                                scriptEl.onreadystatechange = null;
+                                scriptEl.parentNode.removeChild(scriptEl);
+                                scriptEl = null;
+                            }
+                                ;
+                            global.document.documentElement.appendChild(scriptEl);
+                        }
+                            ;
+                    } else {
+                        scheduleDrain = function () {
+                            setTimeout(nextTick, 0);
+                        }
+                            ;
+                    }
+                }
+
+                var draining;
+                var queue = [];
+                //named nextTick for less confusing stack traces
+                function nextTick() {
+                    draining = true;
+                    var i, oldQueue;
+                    var len = queue.length;
+                    while (len) {
+                        oldQueue = queue;
+                        queue = [];
+                        i = -1;
+                        while (++i < len) {
+                            oldQueue[i]();
+                        }
+                        len = queue.length;
+                    }
+                    draining = false;
+                }
+
+                module.exports = immediate;
+                function immediate(task) {
+                    if (queue.push(task) === 1 && !draining) {
+                        scheduleDrain();
+                    }
+                }
+
+            }
+            ).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+        }
+            , {}],
+        2: [function (_dereq_, module, exports) {
+            'use strict';
+            var immediate = _dereq_(1);
+
+            /* istanbul ignore next */
+            function INTERNAL() { }
+
+            var handlers = {};
+
+            var REJECTED = ['REJECTED'];
+            var FULFILLED = ['FULFILLED'];
+            var PENDING = ['PENDING'];
+
+            module.exports = Promise;
+
+            function Promise(resolver) {
+                if (typeof resolver !== 'function') {
+                    throw new TypeError('resolver must be a function');
+                }
+                this.state = PENDING;
+                this.queue = [];
+                this.outcome = void 0;
+                if (resolver !== INTERNAL) {
+                    safelyResolveThenable(this, resolver);
+                }
+            }
+
+            Promise.prototype["catch"] = function (onRejected) {
+                return this.then(null, onRejected);
+            }
+                ;
+            Promise.prototype.then = function (onFulfilled, onRejected) {
+                if (typeof onFulfilled !== 'function' && this.state === FULFILLED || typeof onRejected !== 'function' && this.state === REJECTED) {
+                    return this;
+                }
+                var promise = new this.constructor(INTERNAL);
+                if (this.state !== PENDING) {
+                    var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
+                    unwrap(promise, resolver, this.outcome);
+                } else {
+                    this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+                }
+
+                return promise;
+            }
+                ;
+            function QueueItem(promise, onFulfilled, onRejected) {
+                this.promise = promise;
+                if (typeof onFulfilled === 'function') {
+                    this.onFulfilled = onFulfilled;
+                    this.callFulfilled = this.otherCallFulfilled;
+                }
+                if (typeof onRejected === 'function') {
+                    this.onRejected = onRejected;
+                    this.callRejected = this.otherCallRejected;
+                }
+            }
+            QueueItem.prototype.callFulfilled = function (value) {
+                handlers.resolve(this.promise, value);
+            }
+                ;
+            QueueItem.prototype.otherCallFulfilled = function (value) {
+                unwrap(this.promise, this.onFulfilled, value);
+            }
+                ;
+            QueueItem.prototype.callRejected = function (value) {
+                handlers.reject(this.promise, value);
+            }
+                ;
+            QueueItem.prototype.otherCallRejected = function (value) {
+                unwrap(this.promise, this.onRejected, value);
+            }
+                ;
+
+            function unwrap(promise, func, value) {
+                immediate(function () {
+                    var returnValue;
+                    try {
+                        returnValue = func(value);
+                    } catch (e) {
+                        return handlers.reject(promise, e);
+                    }
+                    if (returnValue === promise) {
+                        handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+                    } else {
+                        handlers.resolve(promise, returnValue);
+                    }
+                });
+            }
+
+            handlers.resolve = function (self, value) {
+                var result = tryCatch(getThen, value);
+                if (result.status === 'error') {
+                    return handlers.reject(self, result.value);
+                }
+                var thenable = result.value;
+
+                if (thenable) {
+                    safelyResolveThenable(self, thenable);
+                } else {
+                    self.state = FULFILLED;
+                    self.outcome = value;
+                    var i = -1;
+                    var len = self.queue.length;
+                    while (++i < len) {
+                        self.queue[i].callFulfilled(value);
+                    }
+                }
+                return self;
+            }
+                ;
+            handlers.reject = function (self, error) {
+                self.state = REJECTED;
+                self.outcome = error;
+                var i = -1;
+                var len = self.queue.length;
+                while (++i < len) {
+                    self.queue[i].callRejected(error);
+                }
+                return self;
+            }
+                ;
+
+            function getThen(obj) {
+                // Make sure we only access the accessor once as required by the spec
+                var then = obj && obj.then;
+                if (obj && (typeof obj === 'object' || typeof obj === 'function') && typeof then === 'function') {
+                    return function appyThen() {
+                        then.apply(obj, arguments);
+                    }
+                        ;
+                }
+            }
+
+            function safelyResolveThenable(self, thenable) {
+                // Either fulfill, reject or reject with error
+                var called = false;
+                function onError(value) {
+                    if (called) {
+                        return;
+                    }
+                    called = true;
+                    handlers.reject(self, value);
+                }
+
+                function onSuccess(value) {
+                    if (called) {
+                        return;
+                    }
+                    called = true;
+                    handlers.resolve(self, value);
+                }
+
+                function tryToUnwrap() {
+                    thenable(onSuccess, onError);
+                }
+
+                var result = tryCatch(tryToUnwrap);
+                if (result.status === 'error') {
+                    onError(result.value);
+                }
+            }
+
+            function tryCatch(func, value) {
+                var out = {};
+                try {
+                    out.value = func(value);
+                    out.status = 'success';
+                } catch (e) {
+                    out.status = 'error';
+                    out.value = e;
+                }
+                return out;
+            }
+
+            Promise.resolve = resolve;
+            function resolve(value) {
+                if (value instanceof this) {
+                    return value;
+                }
+                return handlers.resolve(new this(INTERNAL), value);
+            }
+
+            Promise.reject = reject;
+            function reject(reason) {
+                var promise = new this(INTERNAL);
+                return handlers.reject(promise, reason);
+            }
+
+            Promise.all = all;
+            function all(iterable) {
+                var self = this;
+                if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+                    return this.reject(new TypeError('must be an array'));
+                }
+
+                var len = iterable.length;
+                var called = false;
+                if (!len) {
+                    return this.resolve([]);
+                }
+
+                var values = new Array(len);
+                var resolved = 0;
+                var i = -1;
+                var promise = new this(INTERNAL);
+
+                while (++i < len) {
+                    allResolver(iterable[i], i);
+                }
+                return promise;
+                function allResolver(value, i) {
+                    self.resolve(value).then(resolveFromAll, function (error) {
+                        if (!called) {
+                            called = true;
+                            handlers.reject(promise, error);
+                        }
+                    });
+                    function resolveFromAll(outValue) {
+                        values[i] = outValue;
+                        if (++resolved === len && !called) {
+                            called = true;
+                            handlers.resolve(promise, values);
+                        }
+                    }
+                }
+            }
+
+            Promise.race = race;
+            function race(iterable) {
+                var self = this;
+                if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+                    return this.reject(new TypeError('must be an array'));
+                }
+
+                var len = iterable.length;
+                var called = false;
+                if (!len) {
+                    return this.resolve([]);
+                }
+
+                var i = -1;
+                var promise = new this(INTERNAL);
+
+                while (++i < len) {
+                    resolver(iterable[i]);
+                }
+                return promise;
+                function resolver(value) {
+                    self.resolve(value).then(function (response) {
+                        if (!called) {
+                            called = true;
+                            handlers.resolve(promise, response);
+                        }
+                    }, function (error) {
+                        if (!called) {
+                            called = true;
+                            handlers.reject(promise, error);
+                        }
+                    });
+                }
+            }
+
+        }
+            , {
+            "1": 1
+        }],
+        3: [function (_dereq_, module, exports) {
+            (function (global) {
+                'use strict';
+                if (typeof global.Promise !== 'function') {
+                    global.Promise = _dereq_(2);
+                }
+
+            }
+            ).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+        }
+            , {
+            "2": 2
+        }],
+        4: [function (_dereq_, module, exports) {
+            'use strict';
+
+            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");
+                }
+            }
+
+            function getIDB() {
+                /* global indexedDB,webkitIndexedDB,mozIndexedDB,OIndexedDB,msIndexedDB */
+                try {
+                    if (typeof indexedDB !== 'undefined') {
+                        return indexedDB;
+                    }
+                    if (typeof webkitIndexedDB !== 'undefined') {
+                        return webkitIndexedDB;
+                    }
+                    if (typeof mozIndexedDB !== 'undefined') {
+                        return mozIndexedDB;
+                    }
+                    if (typeof OIndexedDB !== 'undefined') {
+                        return OIndexedDB;
+                    }
+                    if (typeof msIndexedDB !== 'undefined') {
+                        return msIndexedDB;
+                    }
+                } catch (e) {
+                    return;
+                }
+            }
+
+            var idb = getIDB();
+
+            function isIndexedDBValid() {
+                try {
+                    // Initialize IndexedDB; fall back to vendor-prefixed versions
+                    // if needed.
+                    if (!idb || !idb.open) {
+                        return false;
+                    }
+                    // We mimic PouchDB here;
+                    //
+                    // We test for openDatabase because IE Mobile identifies itself
+                    // as Safari. Oh the lulz...
+                    var isSafari = typeof openDatabase !== 'undefined' && /(Safari|iPhone|iPad|iPod)/.test(navigator.userAgent) && !/Chrome/.test(navigator.userAgent) && !/BlackBerry/.test(navigator.platform);
+
+                    var hasFetch = typeof fetch === 'function' && fetch.toString().indexOf('[native code') !== -1;
+
+                    // Safari <10.1 does not meet our requirements for IDB support
+                    // (see: https://github.com/pouchdb/pouchdb/issues/5572).
+                    // Safari 10.1 shipped with fetch, we can use that to detect it.
+                    // Note: this creates issues with `window.fetch` polyfills and
+                    // overrides; see:
+                    // https://github.com/localForage/localForage/issues/856
+                    return (!isSafari || hasFetch) && typeof indexedDB !== 'undefined' && // some outdated implementations of IDB that appear on Samsung
+                        // and HTC Android devices <4.4 are missing IDBKeyRange
+                        // See: https://github.com/mozilla/localForage/issues/128
+                        // See: https://github.com/mozilla/localForage/issues/272
+                        typeof IDBKeyRange !== 'undefined';
+                } catch (e) {
+                    return false;
+                }
+            }
+
+            // Abstracts constructing a Blob object, so it also works in older
+            // browsers that don't support the native Blob constructor. (i.e.
+            // old QtWebKit versions, at least).
+            // Abstracts constructing a Blob object, so it also works in older
+            // browsers that don't support the native Blob constructor. (i.e.
+            // old QtWebKit versions, at least).
+            function createBlob(parts, properties) {
+                /* global BlobBuilder,MSBlobBuilder,MozBlobBuilder,WebKitBlobBuilder */
+                parts = parts || [];
+                properties = properties || {};
+                try {
+                    return new Blob(parts, properties);
+                } catch (e) {
+                    if (e.name !== 'TypeError') {
+                        throw e;
+                    }
+                    var Builder = typeof BlobBuilder !== 'undefined' ? BlobBuilder : typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder : typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : WebKitBlobBuilder;
+                    var builder = new Builder();
+                    for (var i = 0; i < parts.length; i += 1) {
+                        builder.append(parts[i]);
+                    }
+                    return builder.getBlob(properties.type);
+                }
+            }
+
+            // This is CommonJS because lie is an external dependency, so Rollup
+            // can just ignore it.
+            if (typeof Promise === 'undefined') {
+                // In the "nopromises" build this will just throw if you don't have
+                // a global promise object, but it would throw anyway later.
+                _dereq_(3);
+            }
+            var Promise$1 = Promise;
+
+            function executeCallback(promise, callback) {
+                if (callback) {
+                    promise.then(function (result) {
+                        callback(null, result);
+                    }, function (error) {
+                        callback(error);
+                    });
+                }
+            }
+
+            function executeTwoCallbacks(promise, callback, errorCallback) {
+                if (typeof callback === 'function') {
+                    promise.then(callback);
+                }
+
+                if (typeof errorCallback === 'function') {
+                    promise["catch"](errorCallback);
+                }
+            }
+
+            function normalizeKey(key) {
+                // Cast the key to a string, as that's all we can set as a key.
+                if (typeof key !== 'string') {
+                    console.warn(key + ' used as a key, but it is not a string.');
+                    key = String(key);
+                }
+
+                return key;
+            }
+
+            function getCallback() {
+                if (arguments.length && typeof arguments[arguments.length - 1] === 'function') {
+                    return arguments[arguments.length - 1];
+                }
+            }
+
+            // Some code originally from async_storage.js in
+            // [Gaia](https://github.com/mozilla-b2g/gaia).
+
+            var DETECT_BLOB_SUPPORT_STORE = 'local-forage-detect-blob-support';
+            var supportsBlobs = void 0;
+            var dbContexts = {};
+            var toString = Object.prototype.toString;
+
+            // Transaction Modes
+            var READ_ONLY = 'readonly';
+            var READ_WRITE = 'readwrite';
+
+            // Transform a binary string to an array buffer, because otherwise
+            // weird stuff happens when you try to work with the binary string directly.
+            // It is known.
+            // From http://stackoverflow.com/questions/14967647/ (continues on next line)
+            // encode-decode-image-with-base64-breaks-image (2013-04-21)
+            function _binStringToArrayBuffer(bin) {
+                var length = bin.length;
+                var buf = new ArrayBuffer(length);
+                var arr = new Uint8Array(buf);
+                for (var i = 0; i < length; i++) {
+                    arr[i] = bin.charCodeAt(i);
+                }
+                return buf;
+            }
+
+            //
+            // Blobs are not supported in all versions of IndexedDB, notably
+            // Chrome <37 and Android <5. In those versions, storing a blob will throw.
+            //
+            // Various other blob bugs exist in Chrome v37-42 (inclusive).
+            // Detecting them is expensive and confusing to users, and Chrome 37-42
+            // is at very low usage worldwide, so we do a hacky userAgent check instead.
+            //
+            // content-type bug: https://code.google.com/p/chromium/issues/detail?id=408120
+            // 404 bug: https://code.google.com/p/chromium/issues/detail?id=447916
+            // FileReader bug: https://code.google.com/p/chromium/issues/detail?id=447836
+            //
+            // Code borrowed from PouchDB. See:
+            // https://github.com/pouchdb/pouchdb/blob/master/packages/node_modules/pouchdb-adapter-idb/src/blobSupport.js
+            //
+            function _checkBlobSupportWithoutCaching(idb) {
+                return new Promise$1(function (resolve) {
+                    var txn = idb.transaction(DETECT_BLOB_SUPPORT_STORE, READ_WRITE);
+                    var blob = createBlob(['']);
+                    txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob, 'key');
+
+                    txn.onabort = function (e) {
+                        // If the transaction aborts now its due to not being able to
+                        // write to the database, likely due to the disk being full
+                        e.preventDefault();
+                        e.stopPropagation();
+                        resolve(false);
+                    }
+                        ;
+
+                    txn.oncomplete = function () {
+                        var matchedChrome = navigator.userAgent.match(/Chrome\/(\d+)/);
+                        var matchedEdge = navigator.userAgent.match(/Edge\//);
+                        // MS Edge pretends to be Chrome 42:
+                        // https://msdn.microsoft.com/en-us/library/hh869301%28v=vs.85%29.aspx
+                        resolve(matchedEdge || !matchedChrome || parseInt(matchedChrome[1], 10) >= 43);
+                    }
+                        ;
+                }
+                )["catch"](function () {
+                    return false;
+                    // error, so assume unsupported
+                });
+            }
+
+            function _checkBlobSupport(idb) {
+                if (typeof supportsBlobs === 'boolean') {
+                    return Promise$1.resolve(supportsBlobs);
+                }
+                return _checkBlobSupportWithoutCaching(idb).then(function (value) {
+                    supportsBlobs = value;
+                    return supportsBlobs;
+                });
+            }
+
+            function _deferReadiness(dbInfo) {
+                var dbContext = dbContexts[dbInfo.name];
+
+                // Create a deferred object representing the current database operation.
+                var deferredOperation = {};
+
+                deferredOperation.promise = new Promise$1(function (resolve, reject) {
+                    deferredOperation.resolve = resolve;
+                    deferredOperation.reject = reject;
+                }
+                );
+
+                // Enqueue the deferred operation.
+                dbContext.deferredOperations.push(deferredOperation);
+
+                // Chain its promise to the database readiness.
+                if (!dbContext.dbReady) {
+                    dbContext.dbReady = deferredOperation.promise;
+                } else {
+                    dbContext.dbReady = dbContext.dbReady.then(function () {
+                        return deferredOperation.promise;
+                    });
+                }
+            }
+
+            function _advanceReadiness(dbInfo) {
+                var dbContext = dbContexts[dbInfo.name];
+
+                // Dequeue a deferred operation.
+                var deferredOperation = dbContext.deferredOperations.pop();
+
+                // Resolve its promise (which is part of the database readiness
+                // chain of promises).
+                if (deferredOperation) {
+                    deferredOperation.resolve();
+                    return deferredOperation.promise;
+                }
+            }
+
+            function _rejectReadiness(dbInfo, err) {
+                var dbContext = dbContexts[dbInfo.name];
+
+                // Dequeue a deferred operation.
+                var deferredOperation = dbContext.deferredOperations.pop();
+
+                // Reject its promise (which is part of the database readiness
+                // chain of promises).
+                if (deferredOperation) {
+                    deferredOperation.reject(err);
+                    return deferredOperation.promise;
+                }
+            }
+
+            function _getConnection(dbInfo, upgradeNeeded) {
+                return new Promise$1(function (resolve, reject) {
+                    dbContexts[dbInfo.name] = dbContexts[dbInfo.name] || createDbContext();
+
+                    if (dbInfo.db) {
+                        if (upgradeNeeded) {
+                            _deferReadiness(dbInfo);
+                            dbInfo.db.close();
+                        } else {
+                            return resolve(dbInfo.db);
+                        }
+                    }
+
+                    var dbArgs = [dbInfo.name];
+
+                    if (upgradeNeeded) {
+                        dbArgs.push(dbInfo.version);
+                    }
+
+                    var openreq = idb.open.apply(idb, dbArgs);
+
+                    if (upgradeNeeded) {
+                        openreq.onupgradeneeded = function (e) {
+                            var db = openreq.result;
+                            try {
+                                db.createObjectStore(dbInfo.storeName);
+                                if (e.oldVersion <= 1) {
+                                    // Added when support for blob shims was added
+                                    db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);
+                                }
+                            } catch (ex) {
+                                if (ex.name === 'ConstraintError') {
+                                    console.warn('The database "' + dbInfo.name + '"' + ' has been upgraded from version ' + e.oldVersion + ' to version ' + e.newVersion + ', but the storage "' + dbInfo.storeName + '" already exists.');
+                                } else {
+                                    throw ex;
+                                }
+                            }
+                        }
+                            ;
+                    }
+
+                    openreq.onerror = function (e) {
+                        e.preventDefault();
+                        reject(openreq.error);
+                    }
+                        ;
+
+                    openreq.onsuccess = function () {
+                        resolve(openreq.result);
+                        _advanceReadiness(dbInfo);
+                    }
+                        ;
+                }
+                );
+            }
+
+            function _getOriginalConnection(dbInfo) {
+                return _getConnection(dbInfo, false);
+            }
+
+            function _getUpgradedConnection(dbInfo) {
+                return _getConnection(dbInfo, true);
+            }
+
+            function _isUpgradeNeeded(dbInfo, defaultVersion) {
+                if (!dbInfo.db) {
+                    return true;
+                }
+
+                var isNewStore = !dbInfo.db.objectStoreNames.contains(dbInfo.storeName);
+                var isDowngrade = dbInfo.version < dbInfo.db.version;
+                var isUpgrade = dbInfo.version > dbInfo.db.version;
+
+                if (isDowngrade) {
+                    // If the version is not the default one
+                    // then warn for impossible downgrade.
+                    if (dbInfo.version !== defaultVersion) {
+                        console.warn('The database "' + dbInfo.name + '"' + " can't be downgraded from version " + dbInfo.db.version + ' to version ' + dbInfo.version + '.');
+                    }
+                    // Align the versions to prevent errors.
+                    dbInfo.version = dbInfo.db.version;
+                }
+
+                if (isUpgrade || isNewStore) {
+                    // If the store is new then increment the version (if needed).
+                    // This will trigger an "upgradeneeded" event which is required
+                    // for creating a store.
+                    if (isNewStore) {
+                        var incVersion = dbInfo.db.version + 1;
+                        if (incVersion > dbInfo.version) {
+                            dbInfo.version = incVersion;
+                        }
+                    }
+
+                    return true;
+                }
+
+                return false;
+            }
+
+            // encode a blob for indexeddb engines that don't support blobs
+            function _encodeBlob(blob) {
+                return new Promise$1(function (resolve, reject) {
+                    var reader = new FileReader();
+                    reader.onerror = reject;
+                    reader.onloadend = function (e) {
+                        var base64 = btoa(e.target.result || '');
+                        resolve({
+                            __local_forage_encoded_blob: true,
+                            data: base64,
+                            type: blob.type
+                        });
+                    }
+                        ;
+                    reader.readAsBinaryString(blob);
+                }
+                );
+            }
+
+            // decode an encoded blob
+            function _decodeBlob(encodedBlob) {
+                var arrayBuff = _binStringToArrayBuffer(atob(encodedBlob.data));
+                return createBlob([arrayBuff], {
+                    type: encodedBlob.type
+                });
+            }
+
+            // is this one of our fancy encoded blobs?
+            function _isEncodedBlob(value) {
+                return value && value.__local_forage_encoded_blob;
+            }
+
+            // Specialize the default `ready()` function by making it dependent
+            // on the current database operations. Thus, the driver will be actually
+            // ready when it's been initialized (default) *and* there are no pending
+            // operations on the database (initiated by some other instances).
+            function _fullyReady(callback) {
+                var self = this;
+
+                var promise = self._initReady().then(function () {
+                    var dbContext = dbContexts[self._dbInfo.name];
+
+                    if (dbContext && dbContext.dbReady) {
+                        return dbContext.dbReady;
+                    }
+                });
+
+                executeTwoCallbacks(promise, callback, callback);
+                return promise;
+            }
+
+            // Try to establish a new db connection to replace the
+            // current one which is broken (i.e. experiencing
+            // InvalidStateError while creating a transaction).
+            function _tryReconnect(dbInfo) {
+                _deferReadiness(dbInfo);
+
+                var dbContext = dbContexts[dbInfo.name];
+                var forages = dbContext.forages;
+
+                for (var i = 0; i < forages.length; i++) {
+                    var forage = forages[i];
+                    if (forage._dbInfo.db) {
+                        forage._dbInfo.db.close();
+                        forage._dbInfo.db = null;
+                    }
+                }
+                dbInfo.db = null;
+
+                return _getOriginalConnection(dbInfo).then(function (db) {
+                    dbInfo.db = db;
+                    if (_isUpgradeNeeded(dbInfo)) {
+                        // Reopen the database for upgrading.
+                        return _getUpgradedConnection(dbInfo);
+                    }
+                    return db;
+                }).then(function (db) {
+                    // store the latest db reference
+                    // in case the db was upgraded
+                    dbInfo.db = dbContext.db = db;
+                    for (var i = 0; i < forages.length; i++) {
+                        forages[i]._dbInfo.db = db;
+                    }
+                })["catch"](function (err) {
+                    _rejectReadiness(dbInfo, err);
+                    throw err;
+                });
+            }
+
+            // FF doesn't like Promises (micro-tasks) and IDDB store operations,
+            // so we have to do it with callbacks
+            function createTransaction(dbInfo, mode, callback, retries) {
+                if (retries === undefined) {
+                    retries = 1;
+                }
+
+                try {
+                    var tx = dbInfo.db.transaction(dbInfo.storeName, mode);
+                    callback(null, tx);
+                } catch (err) {
+                    if (retries > 0 && (!dbInfo.db || err.name === 'InvalidStateError' || err.name === 'NotFoundError')) {
+                        return Promise$1.resolve().then(function () {
+                            if (!dbInfo.db || err.name === 'NotFoundError' && !dbInfo.db.objectStoreNames.contains(dbInfo.storeName) && dbInfo.version <= dbInfo.db.version) {
+                                // increase the db version, to create the new ObjectStore
+                                if (dbInfo.db) {
+                                    dbInfo.version = dbInfo.db.version + 1;
+                                }
+                                // Reopen the database for upgrading.
+                                return _getUpgradedConnection(dbInfo);
+                            }
+                        }).then(function () {
+                            return _tryReconnect(dbInfo).then(function () {
+                                createTransaction(dbInfo, mode, callback, retries - 1);
+                            });
+                        })["catch"](callback);
+                    }
+
+                    callback(err);
+                }
+            }
+
+            function createDbContext() {
+                return {
+                    // Running localForages sharing a database.
+                    forages: [],
+                    // Shared database.
+                    db: null,
+                    // Database readiness (promise).
+                    dbReady: null,
+                    // Deferred operations on the database.
+                    deferredOperations: []
+                };
+            }
+
+            // Open the IndexedDB 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] = options[i];
+                    }
+                }
+
+                // Get the current context of the database;
+                var dbContext = dbContexts[dbInfo.name];
+
+                // ...or create a new context.
+                if (!dbContext) {
+                    dbContext = createDbContext();
+                    // Register the new context in the global container.
+                    dbContexts[dbInfo.name] = dbContext;
+                }
+
+                // Register itself as a running localForage in the current context.
+                dbContext.forages.push(self);
+
+                // Replace the default `ready()` function with the specialized one.
+                if (!self._initReady) {
+                    self._initReady = self.ready;
+                    self.ready = _fullyReady;
+                }
+
+                // Create an array of initialization states of the related localForages.
+                var initPromises = [];
+
+                function ignoreErrors() {
+                    // Don't handle errors here,
+                    // just makes sure related localForages aren't pending.
+                    return Promise$1.resolve();
+                }
+
+                for (var j = 0; j < dbContext.forages.length; j++) {
+                    var forage = dbContext.forages[j];
+                    if (forage !== self) {
+                        // Don't wait for itself...
+                        initPromises.push(forage._initReady()["catch"](ignoreErrors));
+                    }
+                }
+
+                // Take a snapshot of the related localForages.
+                var forages = dbContext.forages.slice(0);
+
+                // Initialize the connection process only when
+                // all the related localForages aren't pending.
+                return Promise$1.all(initPromises).then(function () {
+                    dbInfo.db = dbContext.db;
+                    // Get the connection or open a new one without upgrade.
+                    return _getOriginalConnection(dbInfo);
+                }).then(function (db) {
+                    dbInfo.db = db;
+                    if (_isUpgradeNeeded(dbInfo, self._defaultConfig.version)) {
+                        // Reopen the database for upgrading.
+                        return _getUpgradedConnection(dbInfo);
+                    }
+                    return db;
+                }).then(function (db) {
+                    dbInfo.db = dbContext.db = db;
+                    self._dbInfo = dbInfo;
+                    // Share the final connection amongst related localForages.
+                    for (var k = 0; k < forages.length; k++) {
+                        var forage = forages[k];
+                        if (forage !== self) {
+                            // Self is already up-to-date.
+                            forage._dbInfo.db = dbInfo.db;
+                            forage._dbInfo.version = dbInfo.version;
+                        }
+                    }
+                });
+            }
+
+            function getItem(key, callback) {
+                var self = this;
+
+                key = normalizeKey(key);
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    self.ready().then(function () {
+                        createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+                                var req = store.get(key);
+
+                                req.onsuccess = function () {
+                                    var value = req.result;
+                                    if (value === undefined) {
+                                        value = null;
+                                    }
+                                    if (_isEncodedBlob(value)) {
+                                        value = _decodeBlob(value);
+                                    }
+                                    resolve(value);
+                                }
+                                    ;
+
+                                req.onerror = function () {
+                                    reject(req.error);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            // Iterate over all items stored in database.
+            function iterate(iterator, callback) {
+                var self = this;
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    self.ready().then(function () {
+                        createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+                                var req = store.openCursor();
+                                var iterationNumber = 1;
+
+                                req.onsuccess = function () {
+                                    var cursor = req.result;
+
+                                    if (cursor) {
+                                        var value = cursor.value;
+                                        if (_isEncodedBlob(value)) {
+                                            value = _decodeBlob(value);
+                                        }
+                                        var result = iterator(value, cursor.key, iterationNumber++);
+
+                                        // when the iterator callback returns any
+                                        // (non-`undefined`) value, then we stop
+                                        // the iteration immediately
+                                        if (result !== void 0) {
+                                            resolve(result);
+                                        } else {
+                                            cursor["continue"]();
+                                        }
+                                    } else {
+                                        resolve();
+                                    }
+                                }
+                                    ;
+
+                                req.onerror = function () {
+                                    reject(req.error);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+
+                return promise;
+            }
+
+            function setItem(key, value, callback) {
+                var self = this;
+
+                key = normalizeKey(key);
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    var dbInfo;
+                    self.ready().then(function () {
+                        dbInfo = self._dbInfo;
+                        if (toString.call(value) === '[object Blob]') {
+                            return _checkBlobSupport(dbInfo.db).then(function (blobSupport) {
+                                if (blobSupport) {
+                                    return value;
+                                }
+                                return _encodeBlob(value);
+                            });
+                        }
+                        return value;
+                    }).then(function (value) {
+                        createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+
+                                // The reason we don't _save_ null is because IE 10 does
+                                // not support saving the `null` type in IndexedDB. How
+                                // ironic, given the bug below!
+                                // See: https://github.com/mozilla/localForage/issues/161
+                                if (value === null) {
+                                    value = undefined;
+                                }
+
+                                var req = store.put(value, key);
+
+                                transaction.oncomplete = function () {
+                                    // Cast to undefined so the value passed to
+                                    // callback/promise is the same as what one would get out
+                                    // of `getItem()` later. This leads to some weirdness
+                                    // (setItem('foo', undefined) will return `null`), but
+                                    // it's not my fault localStorage is our baseline and that
+                                    // it's weird.
+                                    if (value === undefined) {
+                                        value = null;
+                                    }
+
+                                    resolve(value);
+                                }
+                                    ;
+                                transaction.onabort = transaction.onerror = function () {
+                                    var err = req.error ? req.error : req.transaction.error;
+                                    reject(err);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function removeItem(key, callback) {
+                var self = this;
+
+                key = normalizeKey(key);
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    self.ready().then(function () {
+                        createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+                                // We use a Grunt task to make this safe for IE and some
+                                // versions of Android (including those used by Cordova).
+                                // Normally IE won't like `.delete()` and will insist on
+                                // using `['delete']()`, but we have a build step that
+                                // fixes this for us now.
+                                var req = store["delete"](key);
+                                transaction.oncomplete = function () {
+                                    resolve();
+                                }
+                                    ;
+
+                                transaction.onerror = function () {
+                                    reject(req.error);
+                                }
+                                    ;
+
+                                // The request will be also be aborted if we've exceeded our storage
+                                // space.
+                                transaction.onabort = function () {
+                                    var err = req.error ? req.error : req.transaction.error;
+                                    reject(err);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function clear(callback) {
+                var self = this;
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    self.ready().then(function () {
+                        createTransaction(self._dbInfo, READ_WRITE, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+                                var req = store.clear();
+
+                                transaction.oncomplete = function () {
+                                    resolve();
+                                }
+                                    ;
+
+                                transaction.onabort = transaction.onerror = function () {
+                                    var err = req.error ? req.error : req.transaction.error;
+                                    reject(err);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function length(callback) {
+                var self = this;
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    self.ready().then(function () {
+                        createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+                                var req = store.count();
+
+                                req.onsuccess = function () {
+                                    resolve(req.result);
+                                }
+                                    ;
+
+                                req.onerror = function () {
+                                    reject(req.error);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function key(n, callback) {
+                var self = this;
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    if (n < 0) {
+                        resolve(null);
+
+                        return;
+                    }
+
+                    self.ready().then(function () {
+                        createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+                                var advanced = false;
+                                var req = store.openKeyCursor();
+
+                                req.onsuccess = function () {
+                                    var cursor = req.result;
+                                    if (!cursor) {
+                                        // this means there weren't enough keys
+                                        resolve(null);
+
+                                        return;
+                                    }
+
+                                    if (n === 0) {
+                                        // We have the first key, return it if that's what they
+                                        // wanted.
+                                        resolve(cursor.key);
+                                    } else {
+                                        if (!advanced) {
+                                            // Otherwise, ask the cursor to skip ahead n
+                                            // records.
+                                            advanced = true;
+                                            cursor.advance(n);
+                                        } else {
+                                            // When we get here, we've got the nth key.
+                                            resolve(cursor.key);
+                                        }
+                                    }
+                                }
+                                    ;
+
+                                req.onerror = function () {
+                                    reject(req.error);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function keys(callback) {
+                var self = this;
+
+                var promise = new Promise$1(function (resolve, reject) {
+                    self.ready().then(function () {
+                        createTransaction(self._dbInfo, READ_ONLY, function (err, transaction) {
+                            if (err) {
+                                return reject(err);
+                            }
+
+                            try {
+                                var store = transaction.objectStore(self._dbInfo.storeName);
+                                var req = store.openKeyCursor();
+                                var keys = [];
+
+                                req.onsuccess = function () {
+                                    var cursor = req.result;
+
+                                    if (!cursor) {
+                                        resolve(keys);
+                                        return;
+                                    }
+
+                                    keys.push(cursor.key);
+                                    cursor["continue"]();
+                                }
+                                    ;
+
+                                req.onerror = function () {
+                                    reject(req.error);
+                                }
+                                    ;
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    })["catch"](reject);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function dropInstance(options, callback) {
+                callback = getCallback.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 = Promise$1.reject('Invalid arguments');
+                } else {
+                    var isCurrentDb = options.name === currentConfig.name && self._dbInfo.db;
+
+                    var dbPromise = isCurrentDb ? Promise$1.resolve(self._dbInfo.db) : _getOriginalConnection(options).then(function (db) {
+                        var dbContext = dbContexts[options.name];
+                        var forages = dbContext.forages;
+                        dbContext.db = db;
+                        for (var i = 0; i < forages.length; i++) {
+                            forages[i]._dbInfo.db = db;
+                        }
+                        return db;
+                    });
+
+                    if (!options.storeName) {
+                        promise = dbPromise.then(function (db) {
+                            _deferReadiness(options);
+
+                            var dbContext = dbContexts[options.name];
+                            var forages = dbContext.forages;
+
+                            db.close();
+                            for (var i = 0; i < forages.length; i++) {
+                                var forage = forages[i];
+                                forage._dbInfo.db = null;
+                            }
+
+                            var dropDBPromise = new Promise$1(function (resolve, reject) {
+                                var req = idb.deleteDatabase(options.name);
+
+                                req.onerror = req.onblocked = function (err) {
+                                    var db = req.result;
+                                    if (db) {
+                                        db.close();
+                                    }
+                                    reject(err);
+                                }
+                                    ;
+
+                                req.onsuccess = function () {
+                                    var db = req.result;
+                                    if (db) {
+                                        db.close();
+                                    }
+                                    resolve(db);
+                                }
+                                    ;
+                            }
+                            );
+
+                            return dropDBPromise.then(function (db) {
+                                dbContext.db = db;
+                                for (var i = 0; i < forages.length; i++) {
+                                    var _forage = forages[i];
+                                    _advanceReadiness(_forage._dbInfo);
+                                }
+                            })["catch"](function (err) {
+                                (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function () { });
+                                throw err;
+                            });
+                        });
+                    } else {
+                        promise = dbPromise.then(function (db) {
+                            if (!db.objectStoreNames.contains(options.storeName)) {
+                                return;
+                            }
+
+                            var newVersion = db.version + 1;
+
+                            _deferReadiness(options);
+
+                            var dbContext = dbContexts[options.name];
+                            var forages = dbContext.forages;
+
+                            db.close();
+                            for (var i = 0; i < forages.length; i++) {
+                                var forage = forages[i];
+                                forage._dbInfo.db = null;
+                                forage._dbInfo.version = newVersion;
+                            }
+
+                            var dropObjectPromise = new Promise$1(function (resolve, reject) {
+                                var req = idb.open(options.name, newVersion);
+
+                                req.onerror = function (err) {
+                                    var db = req.result;
+                                    db.close();
+                                    reject(err);
+                                }
+                                    ;
+
+                                req.onupgradeneeded = function () {
+                                    var db = req.result;
+                                    db.deleteObjectStore(options.storeName);
+                                }
+                                    ;
+
+                                req.onsuccess = function () {
+                                    var db = req.result;
+                                    db.close();
+                                    resolve(db);
+                                }
+                                    ;
+                            }
+                            );
+
+                            return dropObjectPromise.then(function (db) {
+                                dbContext.db = db;
+                                for (var j = 0; j < forages.length; j++) {
+                                    var _forage2 = forages[j];
+                                    _forage2._dbInfo.db = db;
+                                    _advanceReadiness(_forage2._dbInfo);
+                                }
+                            })["catch"](function (err) {
+                                (_rejectReadiness(options, err) || Promise$1.resolve())["catch"](function () { });
+                                throw err;
+                            });
+                        });
+                    }
+                }
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            var asyncStorage = {
+                _driver: 'asyncStorage',
+                _initStorage: _initStorage,
+                _support: isIndexedDBValid(),
+                iterate: iterate,
+                getItem: getItem,
+                setItem: setItem,
+                removeItem: removeItem,
+                clear: clear,
+                length: length,
+                key: key,
+                keys: keys,
+                dropInstance: dropInstance
+            };
+
+            function isWebSQLValid() {
+                return typeof openDatabase === 'function';
+            }
+
+            // 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+/';
+
+            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$1 = 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$1.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$1.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 createBlob([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
+            };
+
+            /*
+             * 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$1(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 Promise$1(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 = localforageSerializer;
+                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$1(key, callback) {
+                var self = this;
+
+                key = normalizeKey(key);
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function iterate$1(iterator, callback) {
+                var self = this;
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function _setItem(key, value, callback, retriesLeft) {
+                var self = this;
+
+                key = normalizeKey(key);
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function setItem$1(key, value, callback) {
+                return _setItem.apply(this, [key, value, callback, 1]);
+            }
+
+            function removeItem$1(key, callback) {
+                var self = this;
+
+                key = normalizeKey(key);
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            // Deletes every item in the table.
+            // TODO: Find out if this resets the AUTO_INCREMENT number.
+            function clear$1(callback) {
+                var self = this;
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            // Does a simple `COUNT(key)` to get the number of items stored in
+            // localForage.
+            function length$1(callback) {
+                var self = this;
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(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$1(n, callback) {
+                var self = this;
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function keys$1(callback) {
+                var self = this;
+
+                var promise = new Promise$1(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);
+                }
+                );
+
+                executeCallback(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 Promise$1(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$1(options, callback) {
+                callback = getCallback.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 = Promise$1.reject('Invalid arguments');
+                } else {
+                    promise = new Promise$1(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 Promise$1(function (resolve, reject) {
+                            operationInfo.db.transaction(function (t) {
+                                function dropTable(storeName) {
+                                    return new Promise$1(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]));
+                                }
+
+                                Promise$1.all(operations).then(function () {
+                                    resolve();
+                                })["catch"](function (e) {
+                                    reject(e);
+                                });
+                            }, function (sqlError) {
+                                reject(sqlError);
+                            });
+                        }
+                        );
+                    });
+                }
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            var webSQLStorage = {
+                _driver: 'webSQLStorage',
+                _initStorage: _initStorage$1,
+                _support: isWebSQLValid(),
+                iterate: iterate$1,
+                getItem: getItem$1,
+                setItem: setItem$1,
+                removeItem: removeItem$1,
+                clear: clear$1,
+                length: length$1,
+                key: key$1,
+                keys: keys$1,
+                dropInstance: dropInstance$1
+            };
+
+            function isLocalStorageValid() {
+                try {
+                    return typeof localStorage !== 'undefined' && 'setItem' in localStorage && // in IE8 typeof localStorage.setItem === 'object'
+                        !!localStorage.setItem;
+                } catch (e) {
+                    return false;
+                }
+            }
+
+            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$2(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 Promise$1.reject();
+                }
+
+                self._dbInfo = dbInfo;
+                dbInfo.serializer = localforageSerializer;
+
+                return Promise$1.resolve();
+            }
+
+            // Remove all keys from the datastore, effectively destroying all data in
+            // the app's key/value store!
+            function clear$2(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);
+                        }
+                    }
+                });
+
+                executeCallback(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$2(key, callback) {
+                var self = this;
+
+                key = normalizeKey(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;
+                });
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            // Iterate over all items in the store.
+            function iterate$2(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;
+                        }
+                    }
+                });
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            // Same as localStorage's key() method, except takes a callback.
+            function key$2(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;
+                });
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function keys$2(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;
+                });
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            // Supply the number of keys in the datastore to the callback function.
+            function length$2(callback) {
+                var self = this;
+                var promise = self.keys().then(function (keys) {
+                    return keys.length;
+                });
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            // Remove an item from the store, nice and simple.
+            function removeItem$2(key, callback) {
+                var self = this;
+
+                key = normalizeKey(key);
+
+                var promise = self.ready().then(function () {
+                    var dbInfo = self._dbInfo;
+                    localStorage.removeItem(dbInfo.keyPrefix + key);
+                });
+
+                executeCallback(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$2(key, value, callback) {
+                var self = this;
+
+                key = normalizeKey(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 Promise$1(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);
+                                }
+                            }
+                        });
+                    }
+                    );
+                });
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            function dropInstance$2(options, callback) {
+                callback = getCallback.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 = Promise$1.reject('Invalid arguments');
+                } else {
+                    promise = new Promise$1(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);
+                            }
+                        }
+                    });
+                }
+
+                executeCallback(promise, callback);
+                return promise;
+            }
+
+            var localStorageWrapper = {
+                _driver: 'localStorageWrapper',
+                _initStorage: _initStorage$2,
+                _support: isLocalStorageValid(),
+                iterate: iterate$2,
+                getItem: getItem$2,
+                setItem: setItem$2,
+                removeItem: removeItem$2,
+                clear: clear$2,
+                length: length$2,
+                key: key$2,
+                keys: keys$2,
+                dropInstance: dropInstance$2
+            };
+
+            var sameValue = function sameValue(x, y) {
+                return x === y || typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y);
+            };
+
+            var includes = function includes(array, searchElement) {
+                var len = array.length;
+                var i = 0;
+                while (i < len) {
+                    if (sameValue(array[i], searchElement)) {
+                        return true;
+                    }
+                    i++;
+                }
+
+                return false;
+            };
+
+            var isArray = Array.isArray || function (arg) {
+                return Object.prototype.toString.call(arg) === '[object Array]';
+            }
+                ;
+
+            // Drivers are stored here when `defineDriver()` is called.
+            // They are shared across all instances of localForage.
+            var DefinedDrivers = {};
+
+            var DriverSupport = {};
+
+            var DefaultDrivers = {
+                INDEXEDDB: asyncStorage,
+                WEBSQL: webSQLStorage,
+                LOCALSTORAGE: localStorageWrapper
+            };
+
+            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 (isArray(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;
+                    }
+                }
+                    ;
+
+                // Used to define a custom driver, shared across all instances of
+                // localForage.
+
+                LocalForage.prototype.defineDriver = function defineDriver(driverObject, callback, errorCallback) {
+                    var promise = new Promise$1(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 = !includes(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 = Promise$1.reject(error);
+                                        executeCallback(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);
+                        }
+                    }
+                    );
+
+                    executeTwoCallbacks(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] ? Promise$1.resolve(DefinedDrivers[driverName]) : Promise$1.reject(new Error('Driver not found.'));
+
+                    executeTwoCallbacks(getDriverPromise, callback, errorCallback);
+                    return getDriverPromise;
+                }
+                    ;
+
+                LocalForage.prototype.getSerializer = function getSerializer(callback) {
+                    var serializerPromise = Promise$1.resolve(localforageSerializer);
+                    executeTwoCallbacks(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;
+                    });
+
+                    executeTwoCallbacks(promise, callback, callback);
+                    return promise;
+                }
+                    ;
+
+                LocalForage.prototype.setDriver = function setDriver(drivers, callback, errorCallback) {
+                    var self = this;
+
+                    if (!isArray(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 = Promise$1.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 Promise$1.resolve();
+                    }) : Promise$1.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 = Promise$1.reject(error);
+                        return self._driverSet;
+                    });
+
+                    executeTwoCallbacks(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;
+            }();
+
+            // The actual localForage object that we expose as a module or via a
+            // global. It's extended by pulling in one of our other libraries.
+
+            var localforage_js = new LocalForage();
+
+            module.exports = localforage_js;
+
+        }
+            , {
+            "3": 3
+        }]
+    }, {}, [4])(4)
+});
diff --git a/source/editor/plugins/phasereditor2d.scene/plugin.json b/source/editor/plugins/phasereditor2d.scene/plugin.json
index a1186d431..2787e9f33 100644
--- a/source/editor/plugins/phasereditor2d.scene/plugin.json
+++ b/source/editor/plugins/phasereditor2d.scene/plugin.json
@@ -4,6 +4,7 @@
         "styles/SceneEditor.css"
     ],
     "scripts": [
+        "libs/localforage.js",
         "_out/phasereditor2d.scene.js"
     ]
 }
\ No newline at end of file
diff --git a/source/editor/plugins/phasereditor2d.scene/src/localforage.ts b/source/editor/plugins/phasereditor2d.scene/src/localforage.ts
new file mode 100644
index 000000000..7fb8f58a9
--- /dev/null
+++ b/source/editor/plugins/phasereditor2d.scene/src/localforage.ts
@@ -0,0 +1,123 @@
+interface LocalForageDbInstanceOptions {
+    name?: string;
+
+    storeName?: string;
+}
+
+interface LocalForageOptions extends LocalForageDbInstanceOptions {
+    driver?: string | string[];
+
+    size?: number;
+
+    version?: number;
+
+    description?: string;
+}
+
+interface LocalForageDbMethodsCore {
+    getItem<T>(key: string, callback?: (err: any, value: T | null) => void): Promise<T | null>;
+
+    setItem<T>(key: string, value: T, callback?: (err: any, value: T) => void): Promise<T>;
+
+    removeItem(key: string, callback?: (err: any) => void): Promise<void>;
+
+    clear(callback?: (err: any) => void): Promise<void>;
+
+    length(callback?: (err: any, numberOfKeys: number) => void): Promise<number>;
+
+    key(keyIndex: number, callback?: (err: any, key: string) => void): Promise<string>;
+
+    keys(callback?: (err: any, keys: string[]) => void): Promise<string[]>;
+
+    iterate<T, U>(iteratee: (value: T, key: string, iterationNumber: number) => U,
+            callback?: (err: any, result: U) => void): Promise<U>;
+}
+
+interface LocalForageDropInstanceFn {
+    (dbInstanceOptions?: LocalForageDbInstanceOptions, callback?: (err: any) => void): Promise<void>;
+}
+
+interface LocalForageDriverMethodsOptional {
+    dropInstance?: LocalForageDropInstanceFn;
+}
+
+// duplicating LocalForageDriverMethodsOptional to preserve TS v2.0 support,
+// since Partial<> isn't supported there
+interface LocalForageDbMethodsOptional {
+    dropInstance: LocalForageDropInstanceFn;
+}
+
+interface LocalForageDriverDbMethods extends LocalForageDbMethodsCore, LocalForageDriverMethodsOptional {}
+
+interface LocalForageDriverSupportFunc {
+    (): Promise<boolean>;
+}
+
+interface LocalForageDriver extends LocalForageDriverDbMethods {
+    _driver: string;
+
+    _initStorage(options: LocalForageOptions): void;
+
+    _support?: boolean | LocalForageDriverSupportFunc;
+}
+
+interface LocalForageSerializer {
+    serialize<T>(value: T | ArrayBuffer | Blob, callback: (value: string, error: any) => void): void;
+
+    deserialize<T>(value: string): T | ArrayBuffer | Blob;
+
+    stringToBuffer(serializedString: string): ArrayBuffer;
+
+    bufferToString(buffer: ArrayBuffer): string;
+}
+
+interface LocalForageDbMethods extends LocalForageDbMethodsCore, LocalForageDbMethodsOptional {}
+
+interface LocalForage extends LocalForageDbMethods {
+    LOCALSTORAGE: string;
+    WEBSQL: string;
+    INDEXEDDB: string;
+
+    /**
+     * Set and persist localForage options. This must be called before any other calls to localForage are made, but can be called after localForage is loaded.
+     * If you set any config values with this method they will persist after driver changes, so you can call config() then setDriver()
+     * @param {LocalForageOptions} options?
+     */
+    config(options: LocalForageOptions): boolean;
+    config(options: string): any;
+    config(): LocalForageOptions;
+
+    /**
+     * Create a new instance of localForage to point to a different store.
+     * All the configuration options used by config are supported.
+     * @param {LocalForageOptions} options
+     */
+    createInstance(options: LocalForageOptions): LocalForage;
+
+    driver(): string;
+
+    /**
+     * Force usage of a particular driver or drivers, if available.
+     * @param {string} driver
+     */
+    setDriver(driver: string | string[], callback?: () => void, errorCallback?: (error: any) => void): Promise<void>;
+
+    defineDriver(driver: LocalForageDriver, callback?: () => void, errorCallback?: (error: any) => void): Promise<void>;
+
+    /**
+     * Return a particular driver
+     * @param {string} driver
+     */
+    getDriver(driver: string): Promise<LocalForageDriver>;
+
+    getSerializer(callback?: (serializer: LocalForageSerializer) => void): Promise<LocalForageSerializer>;
+
+    supports(driverName: string): boolean;
+
+    ready(callback?: (error: any) => void): Promise<void>;
+}
+
+declare module "localforage" {
+    let localforage: LocalForage;
+    export = localforage;
+}
diff --git a/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnail.ts b/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnail.ts
index dd1c3e95a..0f429e70d 100644
--- a/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnail.ts
+++ b/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnail.ts
@@ -65,9 +65,14 @@ namespace phasereditor2d.scene.ui {
 
                     const container = singleObject as sceneobjects.Container;
 
-                    container.getEditorSupport().trim();
-                    container.setPosition(s.borderX + s.borderWidth / 2, s.borderY + s.borderHeight / 2);
+                    //container.getEditorSupport().trim();
+                    //container.setPosition(s.borderX + s.borderWidth / 2, s.borderY + s.borderHeight / 2);
+                    this.breakContainers([container]);
                 }
+
+            } else {
+
+                this.breakContainers(children);
             }
 
             let bounds = this.computeSceneBounds();
@@ -120,6 +125,19 @@ namespace phasereditor2d.scene.ui {
             });
         }
 
+        private breakContainers(list: Phaser.GameObjects.GameObject[]) {
+
+            for (const obj of list) {
+
+                if (obj instanceof sceneobjects.Container) {
+
+                    sceneobjects.BreakContainerOperation.breakContainer(this, [obj]);
+
+                    this.breakContainers(obj.list);
+                }
+            }
+        }
+
         private computeSceneBounds() {
 
             const children = this.getDisplayListChildren();
@@ -224,6 +242,16 @@ namespace phasereditor2d.scene.ui {
             return controls.Controls.resolveNothingLoaded();
         }
 
+        getImageElement() {
+
+            if (this._image) {
+
+                return this._image.getImageElement();
+            }
+
+            return null;
+        }
+
         private createImageElement() {
 
             return new Promise<HTMLImageElement>((resolve, reject) => {
diff --git a/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnailCache.ts b/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnailCache.ts
index 1cc599170..bea375d2b 100644
--- a/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnailCache.ts
+++ b/source/editor/plugins/phasereditor2d.scene/src/ui/SceneThumbnailCache.ts
@@ -3,30 +3,109 @@ namespace phasereditor2d.scene.ui {
     import controls = colibri.ui.controls;
     import core = colibri.core;
 
+    const localForage = window["localforage"] as LocalForage;
+
     export class SceneThumbnailCache extends core.io.FileContentCache<controls.IImage> {
 
         static _instance: SceneThumbnailCache;
+        static _database: LocalForage;
 
         static getInstance() {
 
             if (!this._instance) {
+
+                this._database = localForage.createInstance({
+                    name: "phasereditor2d.scene.ui.SceneThumbnailCache",
+                    driver: localForage.INDEXEDDB
+                });
+
                 this._instance = new SceneThumbnailCache();
             }
 
             return this._instance;
         }
 
+        static async clearCache() {
+
+            SceneThumbnailCache.getInstance();
+
+            await this._database.clear();
+        }
+
         private constructor() {
-            super(async (file) => {
+            super(async (file, force) => {
+
+                const db = SceneThumbnailCache._database;
+
+                const imageKey = file.getFullName() + "@image";
+                const modTimeKey = file.getFullName() + "@modTime";
+
+                const currentFileTime = file.getModTime();
+
+                if (!force) {
+
+                    const blob = await db.getItem(imageKey) as Blob;
+                    const savedFileTime = await db.getItem(modTimeKey) as number;
+
+                    if (blob) {
+
+                        if (currentFileTime === savedFileTime) {
+
+                            const imgElement = createImageFromBlob(blob);
+
+                            return new controls.ImageWrapper(imgElement);
+                        }
+                    }
+                }
 
                 const image = new SceneThumbnail(file);
 
                 await image.preload();
 
+                const element = image.getImageElement();
+
+                if (element) {
+
+                    const newBlob = await createBlobFromImage(element);
+
+                    db.setItem(imageKey, newBlob);
+                    db.setItem(modTimeKey, currentFileTime);
+                }
+
                 return Promise.resolve(image);
             });
         }
+    }
+
+    async function createBlobFromImage(img: HTMLImageElement): Promise<Blob> {
+
+        return new Promise((resolve, reject) => {
+
+            const canvas = document.createElement("canvas");
+            canvas.width = img.width;
+            canvas.height = img.height;
+            canvas.style.width = img.width + "px";
+            canvas.style.height = img.height + "px";
 
+            const ctx = canvas.getContext("2d");
+            ctx.imageSmoothingEnabled = false;
+
+            ctx.drawImage(img, 0, 0);
+
+            canvas.toBlob((blob) => {
+
+                resolve(blob);
+
+            }, 'image/png');
+        });
     }
 
+    function createImageFromBlob(blob: Blob) {
+
+        const img = document.createElement("img");
+
+        img.src = URL.createObjectURL(blob);
+
+        return img;
+    }
 }
\ No newline at end of file
diff --git a/source/editor/plugins/phasereditor2d.scene/src/ui/editor/SceneEditor.ts b/source/editor/plugins/phasereditor2d.scene/src/ui/editor/SceneEditor.ts
index 1afdd21c6..e1b31e071 100644
--- a/source/editor/plugins/phasereditor2d.scene/src/ui/editor/SceneEditor.ts
+++ b/source/editor/plugins/phasereditor2d.scene/src/ui/editor/SceneEditor.ts
@@ -112,7 +112,7 @@ namespace phasereditor2d.scene.ui.editor {
 
                 this.setDirty(false);
 
-                this.updateTitleIcon();
+                await this.updateTitleIcon();
 
             } catch (e) {
 
@@ -217,7 +217,7 @@ namespace phasereditor2d.scene.ui.editor {
             super.setInput(file);
 
             // we do this here because the icon should be shown even if the editor is not created yet.
-            this.updateTitleIcon();
+            this.updateTitleIcon(true);
         }
 
         protected createPart() {
@@ -328,6 +328,7 @@ namespace phasereditor2d.scene.ui.editor {
                 const img = SceneThumbnailCache.getInstance().getContent(file);
 
                 if (img) {
+
                     return img;
                 }
             }
@@ -776,7 +777,7 @@ namespace phasereditor2d.scene.ui.editor {
                 this._game.loop.stop();
             }, 500);
 
-            this.updateTitleIcon(true);
+            await this.updateTitleIcon(true);
         }
 
         repaint(): void {
diff --git a/source/editor/plugins/phasereditor2d.scene/src/ui/editor/commands/SceneEditorCommands.ts b/source/editor/plugins/phasereditor2d.scene/src/ui/editor/commands/SceneEditorCommands.ts
index 0806e516f..fd99ec5a9 100644
--- a/source/editor/plugins/phasereditor2d.scene/src/ui/editor/commands/SceneEditorCommands.ts
+++ b/source/editor/plugins/phasereditor2d.scene/src/ui/editor/commands/SceneEditorCommands.ts
@@ -34,6 +34,7 @@ namespace phasereditor2d.scene.ui.editor.commands {
     export const CMD_MOVE_OBJECT_DOWN = "phasereditor2d.scene.ui.editor.commands.MoveObjectDown";
     export const CMD_FIX_SCENE_FILES_ID = "phasereditor2d.scene.ui.editor.commands.FixSceneFilesID";
     export const CMD_DUPLICATE_SCENE_FILE = "phasereditor2d.scene.ui.editor.commands.DuplicateSceneFile";
+    export const CMD_CLEAR_SCENE_THUMBNAIL_CACHE = "phasereditor2d.scene.ui.editor.commands.ClearSceneThumbnailCache";
 
     function isSceneScope(args: colibri.ui.ide.commands.HandlerArgs) {
 
@@ -178,6 +179,21 @@ namespace phasereditor2d.scene.ui.editor.commands {
                 }
             });
 
+            // clear scene thumbnail database
+            manager.add({
+                command: {
+                    id: CMD_CLEAR_SCENE_THUMBNAIL_CACHE,
+                    name: "Clear Scene Thumbnail Cache",
+                    tooltip: "Clear the thumbnail images cache.",
+                    category: CAT_SCENE_EDITOR,
+                },
+                handler: {
+                    executeFunc: args => {
+
+                        ui.SceneThumbnailCache.clearCache();
+                    }
+                }
+            })
         }
 
         static registerSnappingCommands(manager: colibri.ui.ide.commands.CommandManager) {
diff --git a/source/editor/plugins/phasereditor2d.scene/src/ui/sceneobjects/container/BreakContainerOperation.ts b/source/editor/plugins/phasereditor2d.scene/src/ui/sceneobjects/container/BreakContainerOperation.ts
index 01571d927..9b0effea2 100644
--- a/source/editor/plugins/phasereditor2d.scene/src/ui/sceneobjects/container/BreakContainerOperation.ts
+++ b/source/editor/plugins/phasereditor2d.scene/src/ui/sceneobjects/container/BreakContainerOperation.ts
@@ -6,11 +6,24 @@ namespace phasereditor2d.scene.ui.sceneobjects {
 
         protected async performModification() {
 
-            const displayList = this.getEditor().getScene().sys.displayList;
+            const editor = this.getEditor();
+
+            const scene = editor.getScene();
+
+            const selectedObjects = editor.getSelectedGameObjects();
+
+            const sel = BreakContainerOperation.breakContainer(scene, selectedObjects);
+
+            this.getEditor().setSelection(sel);
+        }
+
+        static breakContainer(scene: Scene, selectedObjects: ISceneGameObject[]) {
+
+            const displayList = scene.sys.displayList;
 
             const sel = [];
 
-            for (const obj of this._editor.getSelectedGameObjects()) {
+            for (const obj of selectedObjects) {
 
                 const container = obj as sceneobjects.Container;
 
@@ -46,7 +59,7 @@ namespace phasereditor2d.scene.ui.sceneobjects {
                 container.getEditorSupport().destroy();
             }
 
-            this.getEditor().setSelection(sel);
+            return sel;
         }
     }
 }
\ No newline at end of file
diff --git a/source/editor/plugins/phasereditor2d.scene/src/ui/viewers/SceneFileCellRenderer.ts b/source/editor/plugins/phasereditor2d.scene/src/ui/viewers/SceneFileCellRenderer.ts
index 1a4589336..2a9fb4a01 100644
--- a/source/editor/plugins/phasereditor2d.scene/src/ui/viewers/SceneFileCellRenderer.ts
+++ b/source/editor/plugins/phasereditor2d.scene/src/ui/viewers/SceneFileCellRenderer.ts
@@ -12,11 +12,13 @@ namespace phasereditor2d.scene.ui.viewers {
             const image = SceneThumbnailCache.getInstance().getContent(file);
 
             if (image) {
+
                 image.paint(args.canvasContext, args.x, args.y, args.w, args.h, args.center);
             }
         }
 
         cellHeight(args: controls.viewers.RenderCellArgs): number {
+
             return args.viewer.getCellSize();
         }