diff --git a/libraries/idb.filesystem.js b/libraries/idb.filesystem.js
new file mode 100644
index 0000000..520d523
--- /dev/null
+++ b/libraries/idb.filesystem.js
@@ -0,0 +1,999 @@
+/**
+ * Copyright 2013 - Eric Bidelman
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+
+ * @fileoverview
+ * A polyfill implementation of the HTML5 Filesystem API which sits on top of
+ * IndexedDB as storage layer. Files and folders are stored as FileEntry and
+ * FolderEntry objects in a single object store. IDBKeyRanges are used to query
+ * into a folder. A single object store is sufficient because we can utilize the
+ * properties of ASCII. Namely, ASCII / is followed by ASCII 0. Thus,
+ * "/one/two/" comes before "/one/two/ANYTHING" comes before "/one/two/0".
+ *
+ * @author Eric Bidelman (ebidel@gmail.com)
+ */
+
+'use strict';
+
+(function(exports) {
+
+// Bomb out if the Filesystem API is available natively.
+if (exports.requestFileSystem || exports.webkitRequestFileSystem) {
+  return;
+}
+
+// Bomb out if no indexedDB available
+const indexedDB = exports.indexedDB || exports.mozIndexedDB ||
+                  exports.msIndexedDB;
+if (!indexedDB) {
+  return;
+}
+
+let IDB_SUPPORTS_BLOB = true;
+
+// Check to see if IndexedDB support blobs.
+const support = new function() {
+  var dbName = "blob-support";
+  indexedDB.deleteDatabase(dbName).onsuccess = function() {
+    var request = indexedDB.open(dbName, 1);
+    request.onerror = function() {
+      IDB_SUPPORTS_BLOB = false;
+    };
+    request.onsuccess = function() {
+      var db = request.result;
+      try {
+        var blob = new Blob(["test"], {type: "text/plain"});
+        var transaction = db.transaction("store", "readwrite");
+        transaction.objectStore("store").put(blob, "key");
+        IDB_SUPPORTS_BLOB = true;
+      } catch (err) {
+        IDB_SUPPORTS_BLOB = false;
+      } finally {
+        db.close();
+        indexedDB.deleteDatabase(dbName);
+      }
+    };
+    request.onupgradeneeded = function() {
+      request.result.createObjectStore("store");
+    };
+  };
+};
+
+const Base64ToBlob = function(dataURL) {
+  var BASE64_MARKER = ';base64,';
+  if (dataURL.indexOf(BASE64_MARKER) == -1) {
+    var parts = dataURL.split(',');
+    var contentType = parts[0].split(':')[1];
+    var raw = decodeURIComponent(parts[1]);
+
+    return new Blob([raw], {type: contentType});
+  }
+
+  var parts = dataURL.split(BASE64_MARKER);
+  var contentType = parts[0].split(':')[1];
+  var raw = window.atob(parts[1]);
+  var rawLength = raw.length;
+
+  var uInt8Array = new Uint8Array(rawLength);
+
+  for (var i = 0; i < rawLength; ++i) {
+    uInt8Array[i] = raw.charCodeAt(i);
+  }
+
+  return new Blob([uInt8Array], {type: contentType});
+};
+
+const BlobToBase64 = function(blob, onload) {
+  var reader = new FileReader();
+  reader.readAsDataURL(blob);
+  reader.onloadend = function() {
+    onload(reader.result);
+  };
+};
+
+if (!exports.PERSISTENT) {
+  exports.TEMPORARY = 0;
+  exports.PERSISTENT = 1;
+}
+
+// Prevent errors in browsers that don't support FileError.
+// TODO: FF 13+ supports DOM4 Events (DOMError). Use them instead?
+if (exports.FileError === undefined) {
+  window.FileError = function() {};
+  FileError.prototype.prototype = Error.prototype;
+}
+
+if (!FileError.INVALID_MODIFICATION_ERR) {
+  FileError.INVALID_MODIFICATION_ERR = 9;
+  FileError.NOT_FOUND_ERR  = 1;
+}
+
+function MyFileError(obj) {
+  var code_ = obj.code;
+  var name_ = obj.name;
+
+    // Required for FF 11.
+  Object.defineProperty(this, 'code', {
+    set: function(code) {
+      code_ = code;
+    },
+    get: function() {
+      return code_;
+    }
+  });
+
+  Object.defineProperty(this, 'name', {
+    set: function(name) {
+      name_ = name;
+    },
+    get: function() {
+      return name_;
+    }
+  });
+}
+
+MyFileError.prototype = FileError.prototype;
+MyFileError.prototype.toString = Error.prototype.toString;
+
+const INVALID_MODIFICATION_ERR = new MyFileError({
+      code: FileError.INVALID_MODIFICATION_ERR,
+      name: 'INVALID_MODIFICATION_ERR'});
+const NOT_IMPLEMENTED_ERR = new MyFileError({code: 1000,
+                                             name: 'Not implemented'});
+const NOT_FOUND_ERR = new MyFileError({code: FileError.NOT_FOUND_ERR,
+                                       name: 'Not found'});
+
+let fs_ = null;
+
+// Browsers other than Chrome don't implement persistent vs. temporary storage.
+// but default to temporary anyway.
+let storageType_ = 'temporary';
+const idb_ = {db: null};
+const FILE_STORE_ = 'entries';
+
+const DIR_SEPARATOR = '/';
+const DIR_OPEN_BOUND = String.fromCharCode(DIR_SEPARATOR.charCodeAt(0) + 1);
+
+// When saving an entry, the fullPath should always lead with a slash and never
+// end with one (e.g. a directory). Also, resolve '.' and '..' to an absolute
+// one. This method ensures path is legit!
+function resolveToFullPath_(cwdFullPath, path) {
+  var fullPath = path;
+
+  var relativePath = path[0] != DIR_SEPARATOR;
+  if (relativePath) {
+    fullPath = cwdFullPath + DIR_SEPARATOR + path;
+  }
+
+  // Normalize '.'s,  '..'s and '//'s.
+  var parts = fullPath.split(DIR_SEPARATOR);
+  var finalParts = [];
+  for (var i = 0; i < parts.length; ++i) {
+    var part = parts[i];
+    if (part === '..') {
+      // Go up one level.
+      if (!finalParts.length) {
+        throw Error('Invalid path');
+      }
+      finalParts.pop();
+    } else if (part === '.') {
+      // Skip over the current directory.
+    } else if (part !== '') {
+      // Eliminate sequences of '/'s as well as possible leading/trailing '/'s.
+      finalParts.push(part);
+    }
+  }
+
+  fullPath = DIR_SEPARATOR + finalParts.join(DIR_SEPARATOR);
+
+  // fullPath is guaranteed to be normalized by construction at this point:
+  // '.'s, '..'s, '//'s will never appear in it.
+
+  return fullPath;
+}
+
+// // Path can be relative or absolute. If relative, it's taken from the cwd_.
+// // If a filesystem URL is passed it, it is simple returned
+// function pathToFsURL_(path) {
+//   path = resolveToFullPath_(cwdFullPath, path);
+//   path = fs_.root.toURL() + path.substring(1);
+//   return path;
+// };
+
+/**
+ * Interface to wrap the native File interface.
+ *
+ * This interface is necessary for creating zero-length (empty) files,
+ * something the Filesystem API allows you to do. Unfortunately, File's
+ * constructor cannot be called directly, making it impossible to instantiate
+ * an empty File in JS.
+ *
+ * @param {Object} opts Initial values.
+ * @constructor
+ */
+function MyFile(opts) {
+  var blob_ = null;
+
+  this.size = opts.size || 0;
+  this.name = opts.name || '';
+  this.type = opts.type || '';
+  this.lastModifiedDate = opts.lastModifiedDate || null;
+  //this.slice = Blob.prototype.slice; // Doesn't work with structured clones.
+
+  // Need some black magic to correct the object's size/name/type based on the
+  // blob that is saved.
+  Object.defineProperty(this, 'blob_', {
+    enumerable: true,
+    get: function() {
+      return blob_;
+    },
+    set: function (val) {
+      blob_ = val;
+      this.size = blob_.size;
+      this.name = blob_.name;
+      this.type = blob_.type;
+      this.lastModifiedDate = blob_.lastModifiedDate;
+    }.bind(this)
+  });
+}
+MyFile.prototype.constructor = MyFile;
+//MyFile.prototype.slice = Blob.prototype.slice;
+
+/**
+ * Interface to writing a Blob/File.
+ *
+ * Modeled from:
+ * dev.w3.org/2009/dap/file-system/file-writer.html#the-filewriter-interface
+ *
+ * @param {FileEntry} fileEntry The FileEntry associated with this writer.
+ * @constructor
+ */
+function FileWriter(fileEntry) {
+  if (!fileEntry) {
+    throw Error('Expected fileEntry argument to write.');
+  }
+
+  var position_ = 0;
+  var blob_ = fileEntry.file_ ? fileEntry.file_.blob_ : null;
+
+  Object.defineProperty(this, 'position', {
+    get: function() {
+      return position_;
+    }
+  });
+
+  Object.defineProperty(this, 'length', {
+    get: function() {
+      return blob_ ? blob_.size : 0;
+    }
+  });
+
+  this.seek = function(offset) {
+    position_ = offset;
+
+    if (position_ > this.length) {
+      position_ = this.length;
+    }
+    if (position_ < 0) {
+      position_ += this.length;
+    }
+    if (position_ < 0) {
+      position_ = 0;
+    }
+  };
+
+  this.truncate = function(size) {
+    if (blob_) {
+      if (size < this.length) {
+        blob_ = blob_.slice(0, size);
+      } else {
+        blob_ = new Blob([blob_, new Uint8Array(size - this.length)],
+                         {type: blob_.type});
+      }
+    } else {
+      blob_ = new Blob([]);
+    }
+
+    position_ = 0; // truncate from beginning of file.
+
+    this.write(blob_); // calls onwritestart and onwriteend.
+  };
+
+  this.write = function(data) {
+    if (!data) {
+      throw Error('Expected blob argument to write.');
+    }
+
+    // Call onwritestart if it was defined.
+    if (this.onwritestart) {
+      this.onwritestart();
+    }
+
+    // TODO: not handling onprogress, onwrite, onabort. Throw an error if
+    // they're defined.
+
+    if (blob_) {
+      // Calc the head and tail fragments
+      var head = blob_.slice(0, position_);
+      var tail = blob_.slice(position_ + data.size);
+
+      // Calc the padding
+      var padding = position_ - head.size;
+      if (padding < 0) {
+        padding = 0;
+      }
+
+      // Do the "write". In fact, a full overwrite of the Blob.
+      // TODO: figure out if data.type should overwrite the exist blob's type.
+      blob_ = new Blob([head, new Uint8Array(padding), data, tail],
+                       {type: blob_.type});
+    } else {
+      blob_ = new Blob([data], {type: data.type});
+    }
+
+    const writeFile = function(blob) {
+      // Blob might be a DataURI depending on browser support.
+      fileEntry.file_.blob_ = blob;
+      fileEntry.file_.lastModifiedDate = data.lastModifiedDate || new Date();
+      idb_.put(fileEntry, function(entry) {
+        if (!IDB_SUPPORTS_BLOB) {
+          // Set the blob we're writing on this file entry so we can recall it later.
+          fileEntry.file_.blob_ = blob_;
+          fileEntry.file_.lastModifiedDate = data.lastModifiedDate || null;
+        }
+
+        // Add size of data written to writer.position.
+        position_ += data.size;
+
+        if (this.onwriteend) {
+          this.onwriteend();
+        }
+      }.bind(this), this.onerror);
+    }.bind(this);
+
+    if (IDB_SUPPORTS_BLOB) {
+      writeFile(blob_);
+    } else {
+      BlobToBase64(blob_, writeFile);
+    }
+  };
+}
+
+
+/**
+ * Interface for listing a directory's contents (files and folders).
+ *
+ * Modeled from:
+ * dev.w3.org/2009/dap/file-system/pub/FileSystem/#idl-def-DirectoryReader
+ *
+ * @constructor
+ */
+function DirectoryReader(dirEntry) {
+  var dirEntry_ = dirEntry;
+  var used_ = false;
+
+  this.readEntries = function(successCallback, opt_errorCallback) {
+    if (!successCallback) {
+      throw Error('Expected successCallback argument.');
+    }
+
+    // This is necessary to mimic the way DirectoryReader.readEntries() should
+    // normally behavior.  According to spec, readEntries() needs to be called
+    // until the length of result array is 0. To handle someone implementing
+    // a recursive call to readEntries(), get everything from indexedDB on the
+    // first shot. Then (DirectoryReader has been used), return an empty
+    // result array.
+    if (!used_) {
+      idb_.getAllEntries(dirEntry_.fullPath, function(entries) {
+        used_= true;
+        successCallback(entries);
+      }, opt_errorCallback);
+    } else {
+      successCallback([]);
+    }
+  };
+};
+
+/**
+ * Interface supplies information about the state of a file or directory.
+ *
+ * Modeled from:
+ * dev.w3.org/2009/dap/file-system/file-dir-sys.html#idl-def-Metadata
+ *
+ * @constructor
+ */
+function Metadata(modificationTime, size) {
+  this.modificationTime_ = modificationTime || null;
+  this.size_ = size || 0;
+}
+
+Metadata.prototype = {
+  get modificationTime() {
+    return this.modificationTime_;
+  },
+  get size() {
+    return this.size_;
+  }
+}
+
+/**
+ * Interface representing entries in a filesystem, each of which may be a File
+ * or DirectoryEntry.
+ *
+ * Modeled from:
+ * dev.w3.org/2009/dap/file-system/pub/FileSystem/#idl-def-Entry
+ *
+ * @constructor
+ */
+function Entry() {}
+
+Entry.prototype = {
+  name: null,
+  fullPath: null,
+  filesystem: null,
+  copyTo: function() {
+    throw NOT_IMPLEMENTED_ERR;
+  },
+  getMetadata: function(successCallback, opt_errorCallback) {
+    if (!successCallback) {
+      throw Error('Expected successCallback argument.');
+    }
+
+    try {
+      if (this.isFile) {
+        successCallback(
+            new Metadata(this.file_.lastModifiedDate, this.file_.size));
+      } else {
+        opt_errorCallback(new MyFileError({code: 1001,
+            name: 'getMetadata() not implemented for DirectoryEntry'}));
+      }
+    } catch(e) {
+      opt_errorCallback && opt_errorCallback(e);
+    }
+  },
+  getParent: function() {
+    throw NOT_IMPLEMENTED_ERR;
+  },
+  moveTo: function() {
+    throw NOT_IMPLEMENTED_ERR;
+  },
+  remove: function(successCallback, opt_errorCallback) {
+    if (!successCallback) {
+      throw Error('Expected successCallback argument.');
+    }
+    // TODO: This doesn't protect against directories that have content in it.
+    // Should throw an error instead if the dirEntry is not empty.
+    idb_['delete'](this.fullPath, function() {
+      successCallback();
+    }, opt_errorCallback);
+  },
+  toURL: function() {
+    var origin = location.protocol + '//' + location.host;
+    return 'filesystem:' + origin + DIR_SEPARATOR + storageType_.toLowerCase() +
+           this.fullPath;
+  },
+};
+
+/**
+ * Interface representing a file in the filesystem.
+ *
+ * Modeled from:
+ * dev.w3.org/2009/dap/file-system/pub/FileSystem/#the-fileentry-interface
+ *
+ * @param {FileEntry} opt_fileEntry Optional FileEntry to initialize this
+ *     object from.
+ * @constructor
+ * @extends {Entry}
+ */
+function FileEntry(opt_fileEntry) {
+  this.file_ = null;
+
+  Object.defineProperty(this, 'isFile', {
+    enumerable: true,
+    get: function() {
+      return true;
+    }
+  });
+  Object.defineProperty(this, 'isDirectory', {
+    enumerable: true,
+    get: function() {
+      return false;
+    }
+  });
+
+  // Create this entry from properties from an existing FileEntry.
+  if (opt_fileEntry) {
+    this.file_ = opt_fileEntry.file_;
+    this.name = opt_fileEntry.name;
+    this.fullPath = opt_fileEntry.fullPath;
+    this.filesystem = opt_fileEntry.filesystem;
+    if (typeof(this.file_.blob_) === "string") {
+      this.file_.blob_ = Base64ToBlob(this.file_.blob_);
+    }
+  }
+}
+FileEntry.prototype = new Entry();
+FileEntry.prototype.constructor = FileEntry;
+FileEntry.prototype.createWriter = function(callback) {
+  // TODO: figure out if there's a way to dispatch onwrite event as we're writing
+  // data to IDB. Right now, we're only calling onwritend/onerror
+  // FileEntry.write().
+  callback(new FileWriter(this));
+};
+FileEntry.prototype.file = function(successCallback, opt_errorCallback) {
+  if (!successCallback) {
+    throw Error('Expected successCallback argument.');
+  }
+
+  if (this.file_ == null) {
+    if (opt_errorCallback) {
+      opt_errorCallback(NOT_FOUND_ERR);
+    } else {
+      throw NOT_FOUND_ERR;
+    }
+    return;
+  }
+
+  // If we're returning a zero-length (empty) file, return the fake file obj.
+  // Otherwise, return the native File object that we've stashed.
+  var file = this.file_.blob_ == null ? this.file_ : this.file_.blob_;
+  file.lastModifiedDate = this.file_.lastModifiedDate;
+
+  // Add Blob.slice() to this wrapped object. Currently won't work :(
+  /*if (!val.slice) {
+    val.slice = Blob.prototype.slice; // Hack to add back in .slice().
+  }*/
+  successCallback(file);
+};
+
+/**
+ * Interface representing a directory in the filesystem.
+ *
+ * Modeled from:
+ * dev.w3.org/2009/dap/file-system/pub/FileSystem/#the-directoryentry-interface
+ *
+ * @param {DirectoryEntry} opt_folderEntry Optional DirectoryEntry to
+ *     initialize this object from.
+ * @constructor
+ * @extends {Entry}
+ */
+function DirectoryEntry(opt_folderEntry) {
+  Object.defineProperty(this, 'isFile', {
+    enumerable: true,
+    get: function() {
+      return false;
+    }
+  });
+  Object.defineProperty(this, 'isDirectory', {
+    enumerable: true,
+    get: function() {
+      return true;
+    }
+  });
+
+  // Create this entry from properties from an existing DirectoryEntry.
+  if (opt_folderEntry) {
+    this.name = opt_folderEntry.name;
+    this.fullPath = opt_folderEntry.fullPath;
+    this.filesystem = opt_folderEntry.filesystem;
+  }
+}
+DirectoryEntry.prototype = new Entry();
+DirectoryEntry.prototype.constructor = DirectoryEntry;
+DirectoryEntry.prototype.createReader = function() {
+  return new DirectoryReader(this);
+};
+DirectoryEntry.prototype.getDirectory = function(path, options, successCallback,
+                                                 opt_errorCallback) {
+
+  // Create an absolute path if we were handed a relative one.
+  path = resolveToFullPath_(this.fullPath, path);
+
+  idb_.get(path, function(folderEntry) {
+    if (!options) {
+      options = {};
+    }
+
+    if (options.create === true && options.exclusive === true && folderEntry) {
+      // If create and exclusive are both true, and the path already exists,
+      // getDirectory must fail.
+      if (opt_errorCallback) {
+        opt_errorCallback(INVALID_MODIFICATION_ERR);
+        return;
+      }
+    } else if (options.create === true && !folderEntry) {
+      // If create is true, the path doesn't exist, and no other error occurs,
+      // getDirectory must create it as a zero-length file and return a corresponding
+      // DirectoryEntry.
+      var dirEntry = new DirectoryEntry();
+      dirEntry.name = path.split(DIR_SEPARATOR).pop(); // Just need filename.
+      dirEntry.fullPath = path;
+      dirEntry.filesystem = fs_;
+
+      idb_.put(dirEntry, successCallback, opt_errorCallback);
+    } else if (options.create === true && folderEntry) {
+
+      if (folderEntry.isDirectory) {
+        // IDB won't save methods, so we need re-create the DirectoryEntry.
+        successCallback(new DirectoryEntry(folderEntry));
+      } else {
+        if (opt_errorCallback) {
+          opt_errorCallback(INVALID_MODIFICATION_ERR);
+          return;
+        }
+      }
+    } else if ((!options.create || options.create === false) && !folderEntry) {
+      // Handle root special. It should always exist.
+      if (path == DIR_SEPARATOR) {
+        folderEntry = new DirectoryEntry();
+        folderEntry.name = '';
+        folderEntry.fullPath = DIR_SEPARATOR;
+        folderEntry.filesystem = fs_;
+        successCallback(folderEntry);
+        return;
+      }
+
+      // If create is not true and the path doesn't exist, getDirectory must fail.
+      if (opt_errorCallback) {
+        opt_errorCallback(NOT_FOUND_ERR);
+        return;
+      }
+    } else if ((!options.create || options.create === false) && folderEntry &&
+               folderEntry.isFile) {
+      // If create is not true and the path exists, but is a file, getDirectory
+      // must fail.
+      if (opt_errorCallback) {
+        opt_errorCallback(INVALID_MODIFICATION_ERR);
+        return;
+      }
+    } else {
+      // Otherwise, if no other error occurs, getDirectory must return a
+      // DirectoryEntry corresponding to path.
+
+      // IDB won't' save methods, so we need re-create DirectoryEntry.
+      successCallback(new DirectoryEntry(folderEntry));
+    }
+  }, opt_errorCallback);
+};
+
+DirectoryEntry.prototype.getFile = function(path, options, successCallback,
+                                            opt_errorCallback) {
+
+  // Create an absolute path if we were handed a relative one.
+  path = resolveToFullPath_(this.fullPath, path);
+
+  idb_.get(path, function(fileEntry) {
+    if (!options) {
+      options = {};
+    }
+
+    if (options.create === true && options.exclusive === true && fileEntry) {
+      // If create and exclusive are both true, and the path already exists,
+      // getFile must fail.
+
+      if (opt_errorCallback) {
+        opt_errorCallback(INVALID_MODIFICATION_ERR);
+        return;
+      }
+    } else if (options.create === true && !fileEntry) {
+      // If create is true, the path doesn't exist, and no other error occurs,
+      // getFile must create it as a zero-length file and return a corresponding
+      // FileEntry.
+      var fileEntry = new FileEntry();
+      fileEntry.name = path.split(DIR_SEPARATOR).pop(); // Just need filename.
+      fileEntry.fullPath = path;
+      fileEntry.filesystem = fs_;
+      fileEntry.file_ = new MyFile({size: 0, name: fileEntry.name,
+                                    lastModifiedDate: new Date()});
+
+      idb_.put(fileEntry, successCallback, opt_errorCallback);
+
+    } else if (options.create === true && fileEntry) {
+      if (fileEntry.isFile) {
+        // IDB won't save methods, so we need re-create the FileEntry.
+        successCallback(new FileEntry(fileEntry));
+      } else {
+        if (opt_errorCallback) {
+          opt_errorCallback(INVALID_MODIFICATION_ERR);
+          return;
+        }
+      }
+    } else if ((!options.create || options.create === false) && !fileEntry) {
+      // If create is not true and the path doesn't exist, getFile must fail.
+      if (opt_errorCallback) {
+        opt_errorCallback(NOT_FOUND_ERR);
+        return;
+      }
+    } else if ((!options.create || options.create === false) && fileEntry &&
+               fileEntry.isDirectory) {
+      // If create is not true and the path exists, but is a directory, getFile
+      // must fail.
+      if (opt_errorCallback) {
+        opt_errorCallback(INVALID_MODIFICATION_ERR);
+        return;
+      }
+    } else {
+      // Otherwise, if no other error occurs, getFile must return a FileEntry
+      // corresponding to path.
+
+      // IDB won't' save methods, so we need re-create the FileEntry.
+      successCallback(new FileEntry(fileEntry));
+    }
+  }, opt_errorCallback);
+};
+
+DirectoryEntry.prototype.removeRecursively = function(successCallback,
+                                                      opt_errorCallback) {
+  if (!successCallback) {
+    throw Error('Expected successCallback argument.');
+  }
+
+  this.remove(successCallback, opt_errorCallback);
+};
+
+/**
+ * Interface representing a filesystem.
+ *
+ * Modeled from:
+ * dev.w3.org/2009/dap/file-system/pub/FileSystem/#idl-def-LocalFileSystem
+ *
+ * @param {number} type Kind of storage to use, either TEMPORARY or PERSISTENT.
+ * @param {number} size Storage space (bytes) the application expects to need.
+ * @constructor
+ */
+function DOMFileSystem(type, size) {
+  storageType_ = type == exports.TEMPORARY ? 'Temporary' : 'Persistent';
+  this.name = (location.protocol + location.host).replace(/:/g, '_') +
+              ':' + storageType_;
+  this.root = new DirectoryEntry();
+  this.root.fullPath = DIR_SEPARATOR;
+  this.root.filesystem = this;
+  this.root.name = '';
+}
+
+function requestFileSystem(type, size, successCallback, opt_errorCallback) {
+  if (type != exports.TEMPORARY && type != exports.PERSISTENT) {
+    if (opt_errorCallback) {
+      opt_errorCallback(INVALID_MODIFICATION_ERR);
+      return;
+    }
+  }
+
+  fs_ = new DOMFileSystem(type, size);
+  idb_.open(fs_.name, function(e) {
+    successCallback(fs_);
+  }, opt_errorCallback);
+}
+
+function resolveLocalFileSystemURL(url, successCallback, opt_errorCallback) {
+  var origin = location.protocol + '//' + location.host;
+  var base = 'filesystem:' + origin + DIR_SEPARATOR + storageType_.toLowerCase();
+  url = url.replace(base, '');
+  if (url.substr(-1) === '/') {
+    url = url.slice(0, -1);
+  }
+  if (url) {
+    idb_.get(url, function(entry) {
+      if (entry) {
+        if (entry.isFile) {
+          return successCallback(new FileEntry(entry));
+        } else if (entry.isDirectory) {
+          return successCallback(new DirectoryEntry(entry));
+        }
+      } else {
+        opt_errorCallback && opt_errorCallback(NOT_FOUND_ERR);
+      }
+    }, opt_errorCallback);
+  } else {
+    successCallback(fs_.root);
+  }
+}
+
+// Core logic to handle IDB operations =========================================
+
+idb_.open = function(dbName, successCallback, opt_errorCallback) {
+  var self = this;
+
+  // TODO: FF 12.0a1 isn't liking a db name with : in it.
+  var request = indexedDB.open(dbName.replace(':', '_')/*, 1 /*version*/);
+
+  request.onerror = opt_errorCallback || onError;
+
+  request.onupgradeneeded = function(e) {
+    // First open was called or higher db version was used.
+
+   // console.log('onupgradeneeded: oldVersion:' + e.oldVersion,
+   //           'newVersion:' + e.newVersion);
+
+    self.db = e.target.result;
+    self.db.onerror = onError;
+
+    if (!self.db.objectStoreNames.contains(FILE_STORE_)) {
+      var store = self.db.createObjectStore(FILE_STORE_/*,{keyPath: 'id', autoIncrement: true}*/);
+    }
+  };
+
+  request.onsuccess = function(e) {
+    self.db = e.target.result;
+    self.db.onerror = onError;
+    successCallback(e);
+  };
+
+  request.onblocked = opt_errorCallback || onError;
+};
+
+idb_.close = function() {
+  this.db.close();
+  this.db = null;
+};
+
+// TODO: figure out if we should ever call this method. The filesystem API
+// doesn't allow you to delete a filesystem once it is 'created'. Users should
+// use the public remove/removeRecursively API instead.
+idb_.drop = function(successCallback, opt_errorCallback) {
+  if (!this.db) {
+    return;
+  }
+
+  var dbName = this.db.name;
+
+  var request = indexedDB.deleteDatabase(dbName);
+  request.onsuccess = function(e) {
+    successCallback(e);
+  };
+  request.onerror = opt_errorCallback || onError;
+
+  idb_.close();
+};
+
+idb_.get = function(fullPath, successCallback, opt_errorCallback) {
+  if (!this.db) {
+    return;
+  }
+
+  var tx = this.db.transaction([FILE_STORE_], 'readonly');
+
+  //var request = tx.objectStore(FILE_STORE_).get(fullPath);
+  var range = IDBKeyRange.bound(fullPath, fullPath + DIR_OPEN_BOUND,
+                                false, true);
+  var request = tx.objectStore(FILE_STORE_).get(range);
+
+  tx.onabort = opt_errorCallback || onError;
+  tx.oncomplete = function(e) {
+    successCallback(request.result);
+  };
+};
+
+idb_.getAllEntries = function(fullPath, successCallback, opt_errorCallback) {
+  if (!this.db) {
+    return;
+  }
+
+  var results = [];
+
+  //var range = IDBKeyRange.lowerBound(fullPath, true);
+  //var range = IDBKeyRange.upperBound(fullPath, true);
+
+  // Treat the root entry special. Querying it returns all entries because
+  // they match '/'.
+  var range = null;
+  if (fullPath != DIR_SEPARATOR) {
+    //console.log(fullPath + '/', fullPath + DIR_OPEN_BOUND)
+    range = IDBKeyRange.bound(
+        fullPath + DIR_SEPARATOR, fullPath + DIR_OPEN_BOUND, false, true);
+  }
+
+  var tx = this.db.transaction([FILE_STORE_], 'readonly');
+  tx.onabort = opt_errorCallback || onError;
+  tx.oncomplete = function(e) {
+    // TODO: figure out how to do be range queries instead of filtering result
+    // in memory :(
+    results = results.filter(function(val) {
+      var valPartsLen = val.fullPath.split(DIR_SEPARATOR).length;
+      var fullPathPartsLen = fullPath.split(DIR_SEPARATOR).length;
+
+      if (fullPath == DIR_SEPARATOR && valPartsLen < fullPathPartsLen + 1) {
+        // Hack to filter out entries in the root folder. This is inefficient
+        // because reading the entires of fs.root (e.g. '/') returns ALL
+        // results in the database, then filters out the entries not in '/'.
+        return val;
+      } else if (fullPath != DIR_SEPARATOR &&
+                 valPartsLen == fullPathPartsLen + 1) {
+        // If this a subfolder and entry is a direct child, include it in
+        // the results. Otherwise, it's not an entry of this folder.
+        return val;
+      }
+    });
+
+    successCallback(results);
+  };
+
+  var request = tx.objectStore(FILE_STORE_).openCursor(range);
+
+  request.onsuccess = function(e) {
+    var cursor = e.target.result;
+    if (cursor) {
+      var val = cursor.value;
+
+      results.push(val.isFile ? new FileEntry(val) : new DirectoryEntry(val));
+      cursor['continue']();
+    }
+  };
+};
+
+idb_['delete'] = function(fullPath, successCallback, opt_errorCallback) {
+  if (!this.db) {
+    return;
+  }
+
+  var tx = this.db.transaction([FILE_STORE_], 'readwrite');
+  tx.oncomplete = successCallback;
+  tx.onabort = opt_errorCallback || onError;
+
+  //var request = tx.objectStore(FILE_STORE_).delete(fullPath);
+  var range = IDBKeyRange.bound(
+      fullPath, fullPath + DIR_OPEN_BOUND, false, true);
+  var request = tx.objectStore(FILE_STORE_)['delete'](range);
+};
+
+idb_.put = function(entry, successCallback, opt_errorCallback) {
+  if (!this.db) {
+    return;
+  }
+
+  var tx = this.db.transaction([FILE_STORE_], 'readwrite');
+  tx.onabort = opt_errorCallback || onError;
+  tx.oncomplete = function(e) {
+    // TODO: Error is thrown if we pass the request event back instead.
+    successCallback(entry);
+  };
+
+  var request = tx.objectStore(FILE_STORE_).put(entry, entry.fullPath);
+};
+
+// Global error handler. Errors bubble from request, to transaction, to db.
+function onError(e) {
+  switch (e.target.errorCode) {
+    case 12:
+      console.log('Error - Attempt to open db with a lower version than the ' +
+                  'current one.');
+      break;
+    default:
+      console.log('errorCode: ' + e.target.errorCode);
+  }
+
+  console.log(e, e.code, e.message);
+}
+
+// Clean up.
+// TODO: decide if this is the best place for this.
+exports.addEventListener('beforeunload', function(e) {
+  idb_.db && idb_.db.close();
+}, false);
+
+//exports.idb = idb_;
+exports.requestFileSystem = requestFileSystem;
+exports.resolveLocalFileSystemURL = resolveLocalFileSystemURL;
+
+// Export more stuff (to window) for unit tests to do their thing.
+if (exports === window && exports.RUNNING_TESTS) {
+  exports['Entry'] = Entry;
+  exports['FileEntry'] = FileEntry;
+  exports['DirectoryEntry'] = DirectoryEntry;
+  exports['resolveToFullPath_'] = resolveToFullPath_;
+  exports['Metadata'] = Metadata;
+  exports['Base64ToBlob'] = Base64ToBlob;
+}
+
+})(self); // Don't use window because we want to run in workers.
diff --git a/libraries/idbfs/css/app.css b/libraries/idbfs/css/app.css
new file mode 100644
index 0000000..b329ee6
--- /dev/null
+++ b/libraries/idbfs/css/app.css
@@ -0,0 +1,566 @@
+body ::-webkit-scrollbar {
+  height: 16px;
+  overflow: visible;
+  width: 16px;
+}
+
+body ::-webkit-scrollbar-thumb {
+  background-color: rgba(0, 0, 0, .2);
+  background-clip: padding-box;
+  border: solid transparent;
+  min-height: 28px;
+  padding: 100px 0 0;
+  box-shadow: inset 1px 1px 0 rgba(0,0,0,.1), inset 0 -1px 0 rgba(0,0,0,.07);
+  border-width: 1px 1px 1px 6px;
+}
+
+body ::-webkit-scrollbar-button {
+  height: 0;
+  width: 0;
+}
+
+body ::-webkit-scrollbar-track {
+  background-clip: padding-box;
+  border: solid transparent;
+  border-width: 0 0 0 4px;
+  }
+
+body ::-webkit-scrollbar-corner {
+  background: transparent;
+}
+
+html, body {
+  font: 15px 'Open Sans', Trebuchet, Arial, sans-serif;
+  color: #444;
+  margin: 0;
+  height: 100%;
+  width: 100%;
+  overflow: hidden;
+}
+body {
+  background: -webkit-radial-gradient(center center, #fff, #eee) no-repeat;
+  background: -moz-radial-gradient(center center, #fff, #eee) no-repeat;
+  background: -ms-radial-gradient(center center, #fff, #eee) no-repeat;
+  background: -o-radial-gradient(center center, #fff, #eee) no-repeat;
+  color: #222;
+  overflow-x: hidden;
+  -webkit-transition: -webkit-transform 300ms ease-in-out;
+  -webkit-transform-origin: 50% 100%;
+  -webkit-font-smoothing: antialiased;
+  -moz-transition: -moz-transform 300ms ease-in-out;
+  -moz-transform-origin: 50% 100%;
+  -moz-font-smoothing: antialiased;
+  -ms-transition: -moz-transform 300ms ease-in-out;
+  -ms-transform-origin: 50% 100%;
+  -ms-font-smoothing: antialiased;
+  -o-transition: -moz-transform 300ms ease-in-out;
+  -o-transform-origin: 50% 100%;
+  -o-font-smoothing: antialiased;
+}
+label {
+  cursor: pointer;
+  margin-left: 3px;
+}
+[contenteditable] {
+  border: 1px dashed transparent;
+  outline: none;
+  border-radius: 5px;
+}
+[contenteditable]:hover {
+  border: 1px dashed #999;
+}
+a {
+  color: navy;
+  text-decoration: none;
+}
+a:hover {
+  text-decoration: underline;
+}
+ul, li {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+li {
+  padding-bottom: 2px;
+}
+.dropping {
+  -webkit-transform: scale(0.95);
+  -moz-transform: scale(0.95);
+  -ms-transform: scale(0.95);
+  -o-transform: scale(0.95);
+  background-image: -webkit-gradient(
+    linear, left bottom, left top,
+    color-stop(0.13, rgb(209,144,23)),
+    color-stop(0.57, rgb(251,173,51)),
+    color-stop(0.79, rgb(255,208,77))
+  );
+  background-image: -moz-gradient(
+    linear, left bottom, left top,
+    color-stop(0.13, rgb(209,144,23)),
+    color-stop(0.57, rgb(251,173,51)),
+    color-stop(0.79, rgb(255,208,77))
+  );
+  background-image: -ms-gradient(
+    linear, left bottom, left top,
+    color-stop(0.13, rgb(209,144,23)),
+    color-stop(0.57, rgb(251,173,51)),
+    color-stop(0.79, rgb(255,208,77))
+  );
+  background-image: -o-gradient(
+    linear, left bottom, left top,
+    color-stop(0.13, rgb(209,144,23)),
+    color-stop(0.57, rgb(251,173,51)),
+    color-stop(0.79, rgb(255,208,77))
+  );
+}
+.dropping #container {
+  background: white;
+  border-radius: 10px;
+  opacity: 0.8;
+}
+.fakebutton {
+  text-align: center;
+  line-height: 0;
+  display: inline-block;
+}
+.fakebutton > div {
+  width: 15px;
+  height: 15px;
+  display: inline-block;
+  background: url(../images/icons/sprite_black.png) -65px -23px no-repeat;
+}
+:-webkit-any(button, .fakebutton),
+input[type="file"].button:before {
+  background: -webkit-linear-gradient(#F9F9F9 40%, #E3E3E3 70%);
+  border: 1px solid #888;
+  border-radius: 3px;
+  margin: 0 8px 0 0;
+  color: black;
+  padding: 5px 8px;
+  outline: none;
+  white-space: nowrap;
+  vertical-align: middle;
+  -webkit-user-select:none;
+  user-select: none;
+  cursor: pointer;
+  text-shadow: 1px 1px #fff;
+  font-weight: 700;
+}
+:-webkit-any(button, .fakebutton):not(:disabled):hover,
+input[type="file"].button:not(:disabled):hover:before {
+  border: 1px solid #000;
+}
+:-webkit-any(button, .fakebutton):not(:disabled):active,
+input[type="file"].button:not(:disabled):active:before {
+  background: -webkit-linear-gradient(#E3E3E3 40%, #F9F9F9 70%);
+}
+:-moz-any(button, .fakebutton),
+input[type="file"].button:before {
+  background: -moz-linear-gradient(#F9F9F9 40%, #E3E3E3 70%);
+  border: 1px solid #888;
+  border-radius: 3px;
+  margin: 0 8px 0 0;
+  color: black;
+  padding: 5px 8px;
+  outline: none;
+  white-space: nowrap;
+  vertical-align: middle;
+  -moz-user-select:none;
+  user-select: none;
+  cursor: pointer;
+  text-shadow: 1px 1px #fff;
+  font-weight: 700;
+}
+:-moz-any(button, .fakebutton):not(:disabled):hover,
+input[type="file"].button:not(:disabled):hover:before {
+  border: 1px solid #000;
+}
+:-moz-any(button, .fakebutton):not(:disabled):active,
+input[type="file"].button:not(:disabled):active:before {
+  background: -moz-linear-gradient(#E3E3E3 40%, #F9F9F9 70%);
+}
+input[type="file"].button {
+  width: 112px;
+  height: 26px;
+}
+input[type="file"].button::-webkit-file-upload-button {
+  visibility: hidden;
+}
+input[type="file"].button:before {
+  content: 'Import directory';
+  display: inline-block;
+  outline: none;
+  white-space: nowrap;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  cursor: pointer;
+}
+input[type="file"]#fileElem {
+  /* Note: display:none on the input won't trigger the click event in WebKit.
+     Setting visibility to hidden and width 0 works.*/
+  visibility: hidden;
+  width: 0;
+  height: 0;
+}
+:disabled,
+input[type="file"].button:disabled:before {
+  color: #ccc;
+}
+input[type='text'], textarea, iframe {
+  margin: 0;
+  padding: 5px;
+  border-radius: 3px;
+  border: 1px solid #ccc;
+  box-shadow: 0 3px 3px #eee inset;
+  outline: none;
+  background: white;
+}
+input {
+  vertical-align: middle;
+}
+body #container {
+  padding: 1em;
+}
+
+header, footer {
+  padding: 2px 0;
+  display: -webkit-flex;
+  /*display: -moz-box;*/
+  border-radius: 5px;
+  box-shadow: 0 5px 5px #ccc;
+  background: white;
+  background: rgb(207,231,250);
+  background: -webkit-linear-gradient(top, rgba(207,231,250,1) 0%, rgba(99,147,193,1) 100%);
+  background: -moz-linear-gradient(top, rgba(207,231,250,1) 0%, rgba(99,147,193,1) 100%);
+  background: -ms-linear-gradient(top, rgba(207,231,250,1) 0%, rgba(99,147,193,1) 100%);
+  background: -o-linear-gradient(top, rgba(207,231,250,1) 0%, rgba(99,147,193,1) 100%);
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  -o-user-select:none;
+  user-select: none;
+  -webkit-transform: translateY(0) translateZ(0);
+  -webkit-transition: -webkit-transform 1s ease-in-out;
+  /*-webkit-transition-delay: 0.5s;*/
+  -moz-transform: translateY(0) translateZ(0);
+  -moz-transition: -moz-transform 1s ease-in-out;
+  -ms-transform: translateY(0) translateZ(0);
+  -ms-transition: -ms-transform 1s ease-in-out;
+  -o-transform: translateY(0) translateZ(0);
+  -o-transition: -o-transform 1s ease-in-out;
+}
+footer {
+  height: 38px;
+  margin-top: 10px;
+  clear: both;
+}
+.offscreen header {
+  -webkit-transform: translateY(-500px);
+  -moz-transform: translateY(-500px);
+  -ms-transform: translateY(-500px);
+  -o-transform: translateY(-500px);
+}
+.offscreen footer {
+  -webkit-transform: translateY(500px);
+  -moz-transform: translateY(500px);
+  -ms-transform: translateY(500px);
+  -o-transform: translateY(500px);
+}
+header > * {
+  -webkit-align-items: center;
+  -moz-align-items: center;
+  -o-align-items: center;
+  -ms-align-items: center;
+  display: inline-block;
+}
+header > div {
+  -webkit-flex: 1;
+  -moz-flex: 1;
+  -ms-flex: 1;
+  -o-flex: 1;
+  text-align: right;
+}
+header > div > span {
+  border-right: 2px solid rgba(255,255,255,0.25);
+  padding: 0 10px;
+  vertical-align: middle;
+  color: white;
+}
+header > div > span:last-child {
+  border-right: none;
+}
+header > div > span a {
+  color: inherit;
+  font-weight: bold;
+}
+header img {
+  height: 45px;
+  width: 45px;
+  margin: -15px 7px 0 7px;
+}
+header h1 {
+  font-family: 'Open Sans';
+  font-size: 21px;
+  text-shadow: 0px -1px black;
+  color: white;
+  margin: 0;
+}
+header h1 a {
+  color: inherit;
+}
+#files {
+  float: left;
+  clear: both;
+  height: 400px;
+  display: inline-block;
+  overflow-y: auto;
+  overflow-x: hidden;
+  border: 1px solid #eee;
+  border-radius: 7px;
+  box-shadow: 0 -2px 3px #ddd inset, 0 2px 3px #ddd inset;
+  padding: 10px;
+  background: -webkit-linear-gradient(#fff 80%, #eee);
+  background: -moz-linear-gradient(#fff 80%, #eee);
+  background: -o-linear-gradient(#fff 80%, #eee);
+  background: -ms-linear-gradient(#fff 80%, #eee);
+  box-sizing: border-box;
+}
+#files li {
+  -webkit-transition: all 0.2s ease-out;
+  -webkit-column-break-inside: avoid;
+  -moz-transition: all 0.2s ease-out;
+  -moz-column-break-inside: avoid;
+  -ms-transition: all 0.2s ease-out;
+  -ms-column-break-inside: avoid;
+  -o-transition: all 0.2s ease-out;
+  -o-column-break-inside: avoid;
+  white-space: nowrap;
+  padding: 10px;
+  border-radius: 12px;
+  border: 3px solid transparent;
+}
+#files li.on {
+  background: rgba(207,231,250,1);
+  border-color: rgba(99,147,193,1);
+}
+#files li img {
+  height: 16px;
+  width: 16px;
+}
+img.folder,
+img.file,
+img.download {
+  cursor: pointer;
+}
+.parentDir:hover {
+  text-decoration: none;
+}
+.parentDir img {
+  vertical-align: bottom;
+}
+#files li img,
+#files li > div {
+  vertical-align: middle;
+  display: inline-block;
+}
+#files li > a {
+  font-size: small;
+}
+#files li:hover img.icon {
+  opacity: 0.25;
+}
+#files li a img.icon {
+  height: 25px;
+  width: 25px;
+  opacity: 0;
+  /*-webkit-transition: opacity 0.4s ease-out;*/
+}
+#files li a[download] img.icon {
+  height: 21px;
+  width: 21px;
+  margin: 0 2px 0 6px;
+}
+#files li a img.icon:hover {
+  opacity: 1;
+}
+#files li.fadeout {
+  opacity: 0;
+}
+#files li div[data-filename] {
+  width: 150px;
+  min-width: 150px;
+  margin: 0 5px;
+  padding: 1px 2px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+#files li div[data-filename]:hover {
+  overflow: visible;
+  width: auto;
+}
+#file-info {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(0, 0, 0, 0.5);
+  box-sizing: border-box;
+  text-align: center;
+  display: none;
+}
+#file-info.show {
+  z-index: 1000;
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-box-pack: center;
+  display: -moz-box;
+  -moz-box-orient: vertical;
+  -moz-box-pack: center;
+  display: -ms-box;
+  -ms-box-orient: vertical;
+  -ms-box-pack: center;
+  display: -o-box;
+  -o-box-orient: vertical;
+  -o-box-pack: center;
+}
+#file-info > div,
+#file-info p {
+  padding: 10px;
+  background: #fff;
+  margin-bottom: 2em;
+  box-shadow: 0 0 15px #222;
+}
+#file-info p {
+  display: inline-block;
+  margin: 1em 0 0 0;
+  padding: 5em;
+}
+#file-info textarea {
+  width: 400px;
+  height: 100px;
+}
+#file-info img {
+  max-height: 350px;
+  border-radius: 5px;
+  box-shadow: 0 0 15px #222;
+}
+#file-info iframe {
+  width: 500px;
+  height: 300px;
+}
+#errors:not(:empty) {
+  margin: 15px 0 -15px 0;
+  text-align: center;
+}
+#errors::before {
+  content: '';
+}
+.error {
+  color: red !important;
+}
+.error::before {
+  content: 'Error: ';
+}
+header .active {
+  text-decoration: underline;
+}
+#log {
+  font: 90% 'Courier New';
+  position: absolute;
+  background: -webkit-linear-gradient(#fff 40%, #eee);
+  background: -moz-linear-gradient(#fff 40%, #eee);
+  background: -ms-linear-gradient(#fff 40%, #eee);
+  background: -o-linear-gradient(#fff 40%, #eee);
+  top: 0;
+  right: 0;
+  width: 375px;
+  height: 100%;
+  overflow: auto;
+  overflow-x: hidden;
+  padding: 40px 10px 10px 10px;
+  box-sizing: border-box;
+  box-shadow: -3px 0 10px #ddd;
+  -webkit-transition: -webkit-transform 0.2s ease-out;
+  -webkit-transform: translate(500px) translateZ(0);
+  -moz-transition: -moz-transform 0.2s ease-out;
+  -moz-transform: translate(500px) translateZ(0);
+  -ms-transition: -ms-transform 0.2s ease-out;
+  -ms-transform: translate(500px) translateZ(0);
+  -o-transition: -webkit-transform 0.2s ease-out;
+  -o-transform: translate(500px) translateZ(0);
+  z-index: 100;
+}
+#log.active {
+  -webkit-transform: translateX(0) translateZ(0);
+  -moz-transform: translateX(0) translateZ(0);
+  -ms-transform: translateX(0) translateZ(0);
+  -o-transform: translateX(0) translateZ(0);
+}
+#log button {
+  position: absolute;
+  right: 0;
+  top: 0;
+  margin: 10px;
+}
+#log p {
+  color: navy;
+  margin: 3px 0;
+}
+#files.large {
+  float: none;
+  width: 100%;
+  /*height: auto;*/
+}
+#files.large ul {
+  -webkit-column-count: 3;
+  -webkit-column-gap: 0;
+  -moz-column-count: 3;
+  -moz-column-gap: 0;
+  -ms-column-count: 3;
+  -ms-column-gap: 0;
+  -o-column-count: 3;
+  -o-column-gap: 0;
+}
+#files.large li {
+  padding-bottom: 10px;
+}
+#files.large li:first-child {
+  -webkit-column-span: all;
+  -moz-column-span: all;
+  -ms-column-span: all;
+  -o-column-span: all;
+}
+#files.large li .parentDir img {
+  height: 16px;
+  width: 16px;
+}
+#files.large li img {
+  height: 50px;
+  width: 50px;
+}
+#cwd {
+  width: 80%;
+  -webkit-user-select:none;
+  -moz-user-select: none;
+  user-select: none;
+}
+#ticker {
+  opacity: 0;
+  -webkit-transition: opacity 1s ease-in-out;
+  -moz-transition: opacity 1s ease-in-out;
+  -ms-transition: opacity 1s ease-in-out;
+  -o-transition: opacity 1s ease-in-out;
+}
+#ticker.fadedIn {
+  opacity: 1;
+}
+#ticker .icon {
+  height: 25px;
+  width: 25px;
+  vertical-align: middle;
+}
diff --git a/libraries/idbfs/images/demo_screenshot.png b/libraries/idbfs/images/demo_screenshot.png
new file mode 100644
index 0000000..8f1a2d8
Binary files /dev/null and b/libraries/idbfs/images/demo_screenshot.png differ
diff --git a/libraries/idbfs/images/icons/automatic_updates.png b/libraries/idbfs/images/icons/automatic_updates.png
new file mode 100644
index 0000000..29f2976
Binary files /dev/null and b/libraries/idbfs/images/icons/automatic_updates.png differ
diff --git a/libraries/idbfs/images/icons/download.png b/libraries/idbfs/images/icons/download.png
new file mode 100644
index 0000000..d2ffe45
Binary files /dev/null and b/libraries/idbfs/images/icons/download.png differ
diff --git a/libraries/idbfs/images/icons/easy_eject.png b/libraries/idbfs/images/icons/easy_eject.png
new file mode 100644
index 0000000..3d29c81
Binary files /dev/null and b/libraries/idbfs/images/icons/easy_eject.png differ
diff --git a/libraries/idbfs/images/icons/favicon.png b/libraries/idbfs/images/icons/favicon.png
new file mode 100644
index 0000000..dd2c78c
Binary files /dev/null and b/libraries/idbfs/images/icons/favicon.png differ
diff --git a/libraries/idbfs/images/icons/file.png b/libraries/idbfs/images/icons/file.png
new file mode 100644
index 0000000..653ef2b
Binary files /dev/null and b/libraries/idbfs/images/icons/file.png differ
diff --git a/libraries/idbfs/images/icons/folder.png b/libraries/idbfs/images/icons/folder.png
new file mode 100644
index 0000000..c6a9e73
Binary files /dev/null and b/libraries/idbfs/images/icons/folder.png differ
diff --git a/libraries/idbfs/images/icons/library.png b/libraries/idbfs/images/icons/library.png
new file mode 100644
index 0000000..edef90c
Binary files /dev/null and b/libraries/idbfs/images/icons/library.png differ
diff --git a/libraries/idbfs/images/icons/settings.png b/libraries/idbfs/images/icons/settings.png
new file mode 100644
index 0000000..7694331
Binary files /dev/null and b/libraries/idbfs/images/icons/settings.png differ
diff --git a/libraries/idbfs/images/icons/sprite_black.png b/libraries/idbfs/images/icons/sprite_black.png
new file mode 100644
index 0000000..e675952
Binary files /dev/null and b/libraries/idbfs/images/icons/sprite_black.png differ
diff --git a/libraries/idbfs/images/icons/tools.png b/libraries/idbfs/images/icons/tools.png
new file mode 100644
index 0000000..64d07d6
Binary files /dev/null and b/libraries/idbfs/images/icons/tools.png differ
diff --git a/libraries/idbfs/images/icons/trash_empty.png b/libraries/idbfs/images/icons/trash_empty.png
new file mode 100644
index 0000000..48dc2ec
Binary files /dev/null and b/libraries/idbfs/images/icons/trash_empty.png differ
diff --git a/libraries/idbfs/index.html b/libraries/idbfs/index.html
new file mode 100755
index 0000000..9b15283
--- /dev/null
+++ b/libraries/idbfs/index.html
@@ -0,0 +1,114 @@
+<!DOCTYPE html>
+<!--
+Copyright 2012 - Eric Bidelman
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Author: Eric Bidelman (ebidel@gmail.com)
+-->
+<html>
+<head>
+<meta charset="utf-8" />
+<meta http-equiv="X-UA-Compatible" content="chrome=1" />
+<title>HTML5 Filesystem Playground</title>
+<link rel="stylesheet" href="http://fonts.googleapis.com/css?family=Open+Sans" type="text/css" />
+<link rel="stylesheet" href="css/app.css" type="text/css" />
+<link rel="shortcut icon" href="images/icons/favicon.png" />
+</head>
+<body>
+
+<!--
+HTML5 tech used:
+- Filesystem API
+- DnD
+- <input type="file" webkitdirectory>
+- a[download] attribute
+- contenteditable
+- input placeholder
+- <audio> ( to play audio files )
+- Element.[dataset|classList], querySelector[All]()
+- CSS3: gradients, transforms, transitions, rounded corners, multiple bgs, webfonts,
+        text-overflow: ellipsis;, box shadow, text shadow, columns, -webkit-any(),
+        new flexbox, :not(), :empty, :disabled, styled scrollbars
+- <script defer>
+Other:
+- Chrome Frame
+-->
+
+<div id="container" class="offscreen">
+<header>
+  <img src="images/icons/favicon.png" alt="HTML5 Filesystem Playground" title="HTML5 Filesystem Playground">
+  <h1>HTML5 <a href="http://www.html5rocks.com/tutorials/file/filesystem/" target="_blank">Filesystem</a> Playground</h1>
+  <div>
+    <span><input type="checkbox" onclick="toggleLog()" id="toggle-log">
+      <label for="toggle-log">Show log</label>
+    </span>
+    <span>Display as: <a href="javascript:" data-display-type="list" onclick="display(this, 'list')">list</a> / <a href="javascript:" data-display-type="icons" onclick="display(this, 'large')" class="active">icons</a></span>
+    <span>
+      <!--<input type="file" class="button" webkitdirectory mozdirectory disabled alt="Import directory into the current folder" title="Import directory into the current folder">-->
+      <input type="file" id="fileElem" multiple directory webkitdirectory mozdirectory>
+      <button id="importButton" alt="Import directory into the current folder" title="Import directory into the current folder" disabled>Import directory</button>
+    </span>
+    <span>
+      <input type="text" id="entry-name" placeholder="test.txt / foldername"/>
+      <select id="entry-type" title="Select to create a folder or file">
+        <option value="dir">Directory</option>
+        <option value="file">File</option>
+      </select>
+      <button id="createButton" onclick="createNewEntry()" title="Create a new folder or empty file" disabled>Create</button>
+    </span>
+  </div>
+</header>
+<section>
+  <div id="errors" class="error"></div>
+  <div style="margin: 25px 0 15px 0;">
+    <div style="width: 55%;display:inline-block;">
+      <input type="text" id="cwd" disabled alt="Current directory path" title="Current directory path">
+      <button id="openFsButton" onclick="refreshFolder()" alt="Refresh view" title="Refresh view">Open file system</button>
+    </div>
+    <div id="ticker" style="width:45%;text-align:right;color:#999;float:right;">
+    </div>
+  </div>
+  <div id="files" class="large"><ul></ul></div>
+  <div id="file-info"></div>
+</section>
+<section style="clear:both">
+  <div id="log">
+    <button onclick="logger.clear()">Clear</button>
+    <div></div>
+  </div>
+</section>
+<footer></footer>
+</div>
+<script src="../idb.filesystem.js" defer></script>
+<script src="js/filer.js" defer></script>
+<script src="js/logger.js" defer></script>
+<script src="js/dnd.js" defer></script>
+<script src="js/app.js" onload="openFS()" defer></script>
+<script>
+var _gaq = _gaq || [];
+_gaq.push(['_setAccount', 'UA-22014378-1']);
+_gaq.push(['_trackPageview']);
+
+(function() {
+  var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+  ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+  var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+})();
+</script>
+<!--[if IE]>
+  <script src="http://ajax.googleapis.com/ajax/libs/chrome-frame/1/CFInstall.min.js"></script>
+  <script>CFInstall.check({mode: 'overlay'});</script>
+<![endif]-->
+</body>
+</html>
\ No newline at end of file
diff --git a/libraries/idbfs/js/app.js b/libraries/idbfs/js/app.js
new file mode 100644
index 0000000..00378b2
--- /dev/null
+++ b/libraries/idbfs/js/app.js
@@ -0,0 +1,532 @@
+var filer = new Filer();
+var logger = new Logger('#log div');
+
+var entries = []; // Cache of current working directory's entries.
+var currentLi = 1; // Keeps track of current highlighted el for keyboard nav.
+
+// If the OS doesn't reconize certain types, let's help it. These (extra) types
+// will be read as plaintext.
+var PREVIEWABLE_FILES = [
+  '.as',
+  '.txt',
+  '.pl',
+  '.h',
+  '.cc', '.cpp',
+  '.csv', '.tsv',
+  '.js',
+  '.sh'
+];
+
+var TICKER_LIST = [
+  'Drag in files from the desktop to import them.',
+  'Use the "Import directory" button to import entire directories.',
+  'Use the keyboard to navigate and browser folders or preview files.',
+  'Some files can be previewed by clicking their <img src="images/icons/library.png" class="icon"> icon.',
+  'ESC gets you out of preview mode.',
+];
+
+// Cache some frequently used DOM elements.
+var filePreview = document.querySelector('#file-info');
+var filesContainer = document.querySelector('#files');
+var fileList = filesContainer.querySelector('ul');
+var openFsButton = document.querySelector('#openFsButton');
+var errors = document.querySelector('#errors');
+//var importButton = document.querySelector('[type="file"]');
+var importButton = document.querySelector('#importButton');
+var fileDirInput = document.querySelector('input[type="file"]');
+var createButton = document.querySelector('#createButton');
+var ticker = document.querySelector('#ticker');
+
+function toURL(entry) {
+  // Can't polyfill opening filesystem: URLs, so create a blob: URL instead.
+  // TODO(ericbidelman): cleanup URLs created using revokeObjectUR().
+  if (entry.isFile && entry.file_.blob_) {
+    var blob = entry.file_.blob_;
+  } else {
+    var blob = new Blob([]);
+  }
+
+  return window.URL.createObjectURL(blob);
+}
+
+function createNewEntry() {
+  var type = document.querySelector('#entry-type').value;
+  var name = document.querySelector('#entry-name').value;
+  switch (type) {
+    case 'dir':
+      mkdir(name);
+      break;
+    case 'file':
+      newFile(name);
+      break;
+  }
+}
+
+function onError(e) {
+  logger.log('<p class="error">' + e.name + '</p>');
+  errors.textContent = e.name;
+}
+
+function refreshFolder(e) {
+  errors.textContent = ''; // Reset errors.
+
+  // Open the FS, otherwise list the files.
+  if (filer && !filer.isOpen) {
+    openFS();
+  } else {
+    filer.ls('.', function(entries) {
+      renderEntries(entries);
+    }, onError);
+  }
+}
+function display(el, type) {
+  Util.toArray(document.querySelectorAll('[data-display-type]')).forEach(function(el, i) {
+    el.classList.remove('active');
+  });
+
+  if (type == 'list') {
+    filesContainer.classList.remove('large');
+    document.querySelector('[data-display-type="list"]').classList.add('active');
+  } else {
+    filesContainer.classList.add('large');
+    document.querySelector('[data-display-type="icons"]').classList.add('active');
+  }
+}
+
+function toggleContentEditable(el) {
+  if (el.isContentEditable) {
+    el.removeAttribute('contenteditable');
+  } else {
+    el.setAttribute('contenteditable', '');
+    el.focus();
+  }
+}
+
+function toggleLog(opt_hide) {
+  if (opt_hide) {
+    document.querySelector('#log').classList.remove('active');
+    document.querySelector('#toggle-log').checked = false;
+  } else {
+    document.querySelector('#log').classList.toggle('active');
+  }
+}
+
+
+function click(el) {
+  // Simulate link click on an element.
+  var evt = document.createEvent('Event');
+  evt.initEvent('click', false, false);
+  el.dispatchEvent(evt);
+}
+
+
+function constructEntryHTML(entry, i) {
+  var img = entry.isDirectory ?
+      '<img src="images/icons/folder.png" class="folder" onclick="cd(' + i + ')" title="Open folder" alt="Open folder">' :
+      '<img src="images/icons/file.png" class="file" onclick="openFile(' + i + ')" title="Open file" alt="Open file">';
+
+  var html = [img, '<div data-filename ondblclick="toggleContentEditable(this)" onblur="rename(this, ', i, ')" title="Double-click to rename this entry">',
+              entry.name, '</div>'];
+
+  if (entry.isFile) {
+    html.push('<a href="javascript:" data-preview-link onclick="readFile(', i, ')"><img src="images/icons/library.png" class="icon" title="Preview file" alt="Preview file"></a>');
+    html.push('<a href="', toURL(entry), '" download><img src="images/icons/download.png" class="icon" title="Download" alt="Download"></a>');
+  }
+
+  html.push('<a href="javascript:" data-remove-link onclick="remove(this,', i, ');"><img src="images/icons/trash_empty.png" class="icon" title="Remove" alt="Remove"></a>');
+
+  return html.join('');
+}
+
+function addEntryToList(entry, opt_idx) {
+
+  // If an index isn't passed, we're creating a dir or adding a file. Append it.
+  if (opt_idx == undefined) {
+    entries.push(entry);
+  }
+
+  var idx = (opt_idx === undefined) ? entries.length - 1 : opt_idx;
+
+  var li = document.createElement('li');
+  li.innerHTML = constructEntryHTML(entry, idx);
+  fileList.appendChild(li);
+}
+
+function renderEntries(resultEntries) {
+  entries = resultEntries; // Cache the result set.
+
+  fileList.innerHTML = ''; // Clear out existing entries and reset HTML.
+
+  var li = document.createElement('li');
+  li.innerHTML = '<a href="javascript:" onclick="cd(-1)" class="parentDir">' + 
+      '<img src="images/icons/folder.png" class="folder" onclick="cd(-1)">' + 
+      ' [ parent directory ]</a>';
+  fileList.appendChild(li);
+
+  if (!resultEntries.length) {
+    var li = document.createElement('li');
+    li.innerHTML = 'No files. Import some!'
+    fileList.appendChild(li);
+    return;
+  }
+
+  resultEntries.forEach(function(entry, i) {
+    entry.getMetadata(function(meta) {
+      console.log(meta.modificationTime, meta.size);
+    }, function(e) {
+      console.log(e.name);
+    });
+    addEntryToList(entry, i);
+  });
+}
+
+function openFS() {
+  try {
+    filer.init({persistent: false, size: 1024 * 1024}, function(fs) {
+      logger.log(fs.root.toURL());
+      logger.log('<p>Opened: ' + fs.name, + '</p>');
+
+      setCwd('/'); // Display current path as root.
+      refreshFolder();
+      openFsButton.innerHTML = '<div></div>';
+      openFsButton.classList.add('fakebutton');
+      importButton.disabled = true; // mozdirectory doesn't work in FF.
+      createButton.disabled = false;
+    }, function(e) {
+      if (e.name == 'SECURITY_ERR') {
+        errors.textContent = 'SECURITY_ERR: Are you running in incognito mode?';
+        openFsButton.innerHTML = '<div></div>';
+        openFsButton.classList.add('fakebutton');
+        return;
+      }
+      onError(e);
+    });
+  } catch(e) {
+    if (e.code == FileError.BROWSER_NOT_SUPPORTED) {
+      fileList.innerHTML = 'BROWSER_NOT_SUPPORTED';
+    }
+  }
+}
+
+function setCwd(path) {
+  var cwd = document.querySelector('#cwd').value;
+  var rootPath = filer.pathToFilesystemURL('/');
+
+  if (path == '/' || (path == '..' && (rootPath == cwd))) {
+    document.querySelector('#cwd').value = filer.pathToFilesystemURL('/');
+    return;
+  } else if (path == '..') {
+    var parts = cwd.split('/');
+    parts.pop();
+    path = parts.join('/');
+    if (path == rootPath.substring(0, rootPath.length - 1)) {
+      path += '/';
+    }
+  }
+
+  document.querySelector('#cwd').value = filer.pathToFilesystemURL(path);
+}
+
+function mkdir(name, opt_callback) {
+  if (!name) return;
+
+  errors.textContent = ''; // Reset errors.
+
+  try {
+    if (opt_callback) {
+      filer.mkdir(name, false, opt_callback, onError);
+    } else {
+      filer.mkdir(name, true, addEntryToList, onError);
+    }
+  } catch(e) {
+    logger.log('<p class="error">' + e + '</p>');
+  }
+}
+
+function cd(i, opt_callback) {
+  errors.textContent = ''; // Reset errors.
+
+  if (i == -1) {
+    var path = '..';
+  } else {
+    var path = entries[i].fullPath;
+  }
+
+  setCwd(path);
+
+  if (opt_callback) {
+    filer.ls(path, opt_callback, onError);
+  } else {
+    filer.ls(path, renderEntries, onError);
+  }
+}
+
+function openFile(i) {
+  errors.textContent = ''; // Reset errors.
+  var fileWin = self.open(toURL(entries[i]), 'fileWin');
+}
+
+function newFile(name) {
+  if (!name) return;
+
+  errors.textContent = ''; // Reset errors.
+
+  try {
+    filer.create(name, true, addEntryToList, onError);
+  } catch(e) {
+    onError(e);
+  }
+}
+
+function writeFile(fileName, file, opt_rerender) {
+  if (!file) return;
+
+  var rerender = opt_rerender == undefined ? true : false;
+
+  errors.textContent = ''; // Reset errors.
+
+  filer.write(fileName, {data: file, type: file.type},
+    function(fileEntry, fileWriter) {
+      if (rerender) {
+        addEntryToList(fileEntry);
+        filer.ls('.', renderEntries, onError); // Just re-read this dir.
+      }
+    },
+    onError
+  );
+}
+
+function rename(el, i) {
+  errors.textContent = ''; // Reset errors.
+
+  filer.mv(entries[i].fullPath, '.', el.textContent, function(entry) {
+    logger.log('<p>' + entries[i].name + ' renamed to ' + entry.name + '</p>');
+    entries[i] = entry;
+
+    // Fill download link with updated filsystem URL.
+    var downloadLink = el.parentElement.querySelector('[download]');
+    if (downloadLink) {
+      downloadLink.href = toURL(entry);
+    }
+  });
+  toggleContentEditable(el);
+}
+
+function remove(link, i) {
+  errors.textContent = ''; // Reset errors.
+
+  var entry = entries[i];
+
+  if (!confirm('Delete ' + entry.name + '?')) {
+    return;
+  }
+
+  filer.rm(entry, function() {
+    var li = link.parentNode;
+    li.classList.add('fadeout');
+    li.addEventListener('webkitTransitionEnd', function(e) {
+      this.parentNode.removeChild(this);
+      filer.ls('.', renderEntries, onError); // Just re-read this dir.
+    }, false);
+    li.addEventListener('mozTransitionEnd', function(e) {
+      this.parentNode.removeChild(this);
+      filer.ls('.', renderEntries, onError); // Just re-read this dir.
+    }, false);
+  }, onError);
+}
+
+function copy(el, i) {
+  errors.textContent = ''; // Reset errors.
+
+  filer.cp(entries[i], el.textContent, function(entry) {
+    logger.log('<p>' + entries[i].name + ' renamed to ' + entry.name + '</p>');
+    entries[i] = entry;
+  });
+  toggleContentEditable(el);
+}
+
+function readFile(i) {
+  errors.textContent = ''; // Reset errors.
+
+  var entry = entries[i];
+
+  try {
+    filer.open(entry.name, function(file) {
+
+      filePreview.classList.toggle('show');
+
+      filePreview.innerHTML = [
+        '<div><b>', file.name, '</b> ',
+        (file.type ? '(' + file.type + ')' : ''), ' - ', file.size,
+        ' bytes, modified: ', file.lastModifiedDate.toLocaleDateString(),
+        '</div>'].join('');
+
+      if (file.type.match(/audio.*/)) {
+        var player = document.createElement('audio');
+        player.controls = true;
+        player.src = toURL(entry);
+
+        filePreview.appendChild(player);
+
+        player.load();
+        player.play();
+
+      } else if (file.type.match(/text.*/) ||
+                 file.type.match(/application\/pdf/)) {
+
+        var iframe = document.createElement('iframe');
+        iframe.src = toURL(entry);
+
+        filePreview.appendChild(iframe);
+
+      } else if (file.type.match(/image.*/)) {
+
+        var img = document.createElement('img');
+        img.src = toURL(entry);
+
+        filePreview.appendChild(img);
+
+     } else if (PREVIEWABLE_FILES.indexOf(Util.getFileExtension(file.name)) != -1) {
+        var reader = new FileReader();
+        reader.onload = function(e) {
+          var textarea = document.createElement('textarea');
+          textarea.style.width = '50%';
+          textarea.style.height = '350px';
+          textarea.textContent = e.target.result;
+          filePreview.appendChild(textarea);
+        };
+        reader.readAsText(file);
+      } else {
+        var p = document.createElement('p');
+        p.textContent = 'No preview.'
+        filePreview.appendChild(p);
+      }
+
+    }, onError);
+  } catch(e) {
+    logger.log('<p class="error">' + e + '</p>');
+  }
+}
+
+function onKeydown(e) {
+  var target = e.target;
+
+  // Prevent enter key from inserting carriage return in the contenteditable
+  // file/folder renaming.
+  if (target.isContentEditable && 'filename' in target.dataset) {
+    if (e.keyCode == 13) { // Enter
+      e.preventDefault();
+      e.stopPropagation();
+      target.blur();
+    }
+    return;
+  }
+
+  var active = document.querySelector('#files li.on');
+
+  if (e.keyCode == 27) { // ESC
+    filePreview.classList.remove('show');
+    filePreview.innerHTML = '';
+
+    if (active) {
+      active.classList.remove('on');
+    }
+
+    toggleLog(true);
+
+    e.preventDefault();
+    e.stopPropagation();
+    return;
+  }
+
+  if (target.nodeName != 'INPUT') {
+    if (e.keyCode == 8) { // Backspace.
+      if (active) {
+        click(active.querySelector('a[data-remove-link]'));
+      }
+      e.preventDefault();
+      return;
+    } else if (e.keyCode == 13) {  // Enter
+      if (active) {
+        if (active.querySelector('.folder')) {
+          currentLi = 1; // reset current active to first item in current folder.
+        }
+        click(active.querySelector('a[data-preview-link]') || active.querySelector('img'));
+        e.preventDefault();
+        return;
+      }
+    }
+  }
+
+  if (active) {
+    active.classList.remove('on');
+  }
+
+  var count = entries.length + 1;
+
+  if (e.keyCode == 39 || e.keyCode == 40) { // Right/down arrow.
+    currentLi = currentLi == count ? 1 : ++currentLi;
+    document.querySelector('#files li:nth-of-type(' + currentLi + ')').classList.toggle('on');
+    e.preventDefault();
+  } else if (e.keyCode == 37 || e.keyCode == 38) { // Left/up arrow.
+    currentLi = currentLi == 1 ? count : --currentLi;
+    document.querySelector('#files li:nth-of-type(' + currentLi + ')').classList.toggle('on');
+    e.preventDefault();
+  }
+}
+
+function onImport(e) {
+  var files = e.target.files;
+  if (files.length) {
+    var count = 0;
+    Util.toArray(files).forEach(function(file, i) {
+
+      var folders = file.webkitRelativePath.split('/');
+      folders = folders.slice(0, folders.length - 1);
+
+      // Add each directory. If it already exists, then a noop.
+      mkdir(folders.join('/'), function(dirEntry) {
+        var path = file.webkitRelativePath;
+
+        ++count;
+
+        // Write each file by it's path. Skipt '/.' (which is a directory).
+        if (path.lastIndexOf('/.') !=  path.length - 2) {
+          writeFile(path, file, false);
+          if (count == files.length) {
+            filer.ls('.', renderEntries, onError); // Rerender view on final file.
+          }
+        }
+      });
+    });
+  }
+}
+
+function addListeners() {
+  importButton.addEventListener('click', function(e) {
+    fileDirInput.click();
+  }, false);
+  fileDirInput.addEventListener('change', onImport, false);
+  document.addEventListener('keydown', onKeydown, false);
+
+  var dnd = new DnDFileController('body', function(files) {
+    Util.toArray(files).forEach(function(file, i) {
+      writeFile(file.name, file);
+    });
+  });
+}
+
+// DOMContentLoaded seems to be an issue with FF.
+window.addEventListener('load', function(e) {
+  var count = 0;
+  setInterval(function() {
+    ticker.innerHTML =
+        'Tip: ' + TICKER_LIST[count++ % TICKER_LIST.length];
+    ticker.classList.add('fadedIn');
+  }, 7000);
+}, false);
+
+window.addEventListener('load', function(e) {
+  addListeners();
+  document.querySelector('.offscreen').classList.remove('offscreen');
+}, false);
diff --git a/libraries/idbfs/js/dnd.js b/libraries/idbfs/js/dnd.js
new file mode 100644
index 0000000..e2ebf71
--- /dev/null
+++ b/libraries/idbfs/js/dnd.js
@@ -0,0 +1,34 @@
+function DnDFileController(selector, onDropCallback) {
+  var el_ = document.querySelector(selector);
+
+  this.dragenter = function(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    el_.classList.add('dropping');
+  };
+
+  this.dragover = function(e) {
+    e.stopPropagation();
+    e.preventDefault();
+  };
+
+  this.dragleave = function(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    //el_.classList.remove('dropping');
+  };
+
+  this.drop = function(e) {
+    e.stopPropagation();
+    e.preventDefault();
+
+    el_.classList.remove('dropping');
+
+    onDropCallback(e.dataTransfer.files)
+  };
+
+  el_.addEventListener('dragenter', this.dragenter, false);
+  el_.addEventListener('dragover', this.dragover, false);
+  el_.addEventListener('dragleave', this.dragleave, false);
+  el_.addEventListener('drop', this.drop, false);
+};
diff --git a/libraries/idbfs/js/filer.js b/libraries/idbfs/js/filer.js
new file mode 100755
index 0000000..ca8b95e
--- /dev/null
+++ b/libraries/idbfs/js/filer.js
@@ -0,0 +1,16 @@
+var self=this;self.URL=self.URL||self.webkitURL;self.requestFileSystem=self.requestFileSystem||self.webkitRequestFileSystem;self.resolveLocalFileSystemURL=self.resolveLocalFileSystemURL||self.webkitResolveLocalFileSystemURL;navigator.temporaryStorage=navigator.temporaryStorage||navigator.webkitTemporaryStorage;navigator.persistentStorage=navigator.persistentStorage||navigator.webkitPersistentStorage;self.BlobBuilder=self.BlobBuilder||self.MozBlobBuilder||self.WebKitBlobBuilder;
+if(void 0===self.FileError){var FileError=function(){};FileError.prototype.prototype=Error.prototype}
+var Util={toArray:function(a){return Array.prototype.slice.call(a||[],0)},strToDataURL:function(a,b,c){return(void 0!=c?c:1)?"data:"+b+";base64,"+self.btoa(a):"data:"+b+","+a},strToObjectURL:function(a,b){for(var c=new Uint8Array(a.length),e=0;e<c.length;++e)c[e]=a.charCodeAt(e);c=new Blob([c],b?{type:b}:{});return self.URL.createObjectURL(c)},fileToObjectURL:function(a){return self.URL.createObjectURL(a)},fileToArrayBuffer:function(a,b,c){var e=new FileReader;e.onload=function(a){b(a.target.result)};
+e.onerror=function(a){c&&c(a)};e.readAsArrayBuffer(a)},dataURLToBlob:function(a){if(-1==a.indexOf(";base64,")){var b=a.split(","),a=b[0].split(":")[1],b=b[1];return new Blob([b],{type:a})}for(var b=a.split(";base64,"),a=b[0].split(":")[1],b=window.atob(b[1]),c=b.length,e=new Uint8Array(c),i=0;i<c;++i)e[i]=b.charCodeAt(i);return new Blob([e],{type:a})},arrayBufferToBlob:function(a,b){var c=new Uint8Array(a);return new Blob([c],b?{type:b}:{})},arrayBufferToBinaryString:function(a,b,c){var e=new FileReader;
+e.onload=function(a){b(a.target.result)};e.onerror=function(a){c&&c(a)};a=new Uint8Array(a);e.readAsBinaryString(new Blob([a]))},arrayToBinaryString:function(a){if("object"!=typeof a)return null;for(var b=a.length,c=Array(b);b--;)c[b]=String.fromCharCode(a[b]);return c.join("")},getFileExtension:function(a){var b=a.lastIndexOf(".");return-1!=b?a.substring(b):""}},MyFileError=function(a){this.prototype=FileError.prototype;this.code=a.code;this.name=a.name};FileError.BROWSER_NOT_SUPPORTED=1E3;
+FileError.prototype.__defineGetter__("name",function(){for(var a=Object.keys(FileError),b=0,c;c=a[b];++b)if(FileError[c]==this.code)return c;return"Unknown Error"});
+var Filer=new function(){function a(d){if(b=d||null)c=b.root,e=!0}var b=null,c=null,e=!1,i=function(d){return 0==d.indexOf("filesystem:")},k=function(d){i(d)||(d="/"==d[0]?b.root.toURL()+d.substring(1):0==d.indexOf("./")||0==d.indexOf("../")?"../"==d&&c!=b.root?c.toURL()+"/"+d:c.toURL()+d:c.toURL()+"/"+d);return d},j=function(d,a){var b=arguments[1],f=arguments[2],c=function(d){if(d.code==FileError.NOT_FOUND_ERR){if(f)throw Error('"'+b+'" or "'+f+'" does not exist.');throw Error('"'+b+'" does not exist.');
+}throw Error("Problem getting Entry for one or more paths.");},l=k(b);if(3==arguments.length){var e=k(f);self.resolveLocalFileSystemURL(l,function(a){self.resolveLocalFileSystemURL(e,function(b){d(a,b)},c)},c)}else self.resolveLocalFileSystemURL(l,d,c)},o=function(d,a,c,f,h,l){if(!b)throw Error("Filesystem has not been initialized.");if(typeof d!=typeof a)throw Error("These method arguments are not supported.");var e=c||null,m=void 0!=l?l:!1;(d.isFile||a.isDirectory)&&a.isDirectory?m?d.moveTo(a,e,
+f,h):d.copyTo(a,e,f,h):j(function(d,a){if(a.isDirectory)m?d.moveTo(a,e,f,h):d.copyTo(a,e,f,h);else{var b=Error('Oops! "'+a.name+" is not a directory!");if(h)h(b);else throw b;}},d,a)};a.DEFAULT_FS_SIZE=1048576;a.version="0.4.3";a.prototype={get fs(){return b},get isOpen(){return e},get cwd(){return c}};a.prototype.pathToFilesystemURL=function(d){return k(d)};a.prototype.init=function(d,a,g){if(!self.requestFileSystem)throw new MyFileError({code:FileError.BROWSER_NOT_SUPPORTED,name:"BROWSER_NOT_SUPPORTED"});
+var d=d?d:{},f=d.size||1048576;this.type=self.TEMPORARY;if("persistent"in d&&d.persistent)this.type=self.PERSISTENT;var h=function(d){this.size=f;b=d;c=b.root;e=!0;a&&a(d)};this.type==self.PERSISTENT&&navigator.persistentStorage?navigator.persistentStorage.requestQuota(f,function(d){self.requestFileSystem(this.type,d,h.bind(this),g)}.bind(this),g):self.requestFileSystem(this.type,f,h.bind(this),g)};a.prototype.ls=function(d,a,g){if(!b)throw Error("Filesystem has not been initialized.");var f=function(d){c=
+d;var b=[],f=c.createReader(),e=function(){f.readEntries(function(d){d.length?(b=b.concat(Util.toArray(d)),e()):(b.sort(function(d,a){return d.name<a.name?-1:a.name<d.name?1:0}),a(b))},g)};e()};d.isDirectory?f(d):i(d)?j(f,d):c.getDirectory(d,{},f,g)};a.prototype.mkdir=function(d,a,g,f){if(!b)throw Error("Filesystem has not been initialized.");var h=null!=a?a:!1,e=d.split("/"),n=function(a,b){if("."==b[0]||""==b[0])b=b.slice(1);a.getDirectory(b[0],{create:!0,exclusive:h},function(a){if(a.isDirectory)b.length&&
+1!=e.length?n(a,b.slice(1)):g&&g(a);else if(a=Error(d+" is not a directory"),f)f(a);else throw a;},function(a){if(a.code==FileError.INVALID_MODIFICATION_ERR)if(a.message="'"+d+"' already exists",f)f(a);else throw a;})};n(c,e)};a.prototype.open=function(a,c,e){if(!b)throw Error("Filesystem has not been initialized.");a.isFile?a.file(c,e):j(function(a){a.file(c,e)},k(a))};a.prototype.create=function(a,e,g,f){if(!b)throw Error("Filesystem has not been initialized.");c.getFile(a,{create:!0,exclusive:null!=
+e?e:!0},g,function(b){if(b.code==FileError.INVALID_MODIFICATION_ERR)b.message="'"+a+"' already exists";if(f)f(b);else throw b;})};a.prototype.mv=function(a,b,c,f,e){o.bind(this,a,b,c,f,e,!0)()};a.prototype.rm=function(a,c,e){if(!b)throw Error("Filesystem has not been initialized.");var f=function(a){a.isFile?a.remove(c,e):a.isDirectory&&a.removeRecursively(c,e)};a.isFile||a.isDirectory?f(a):j(f,a)};a.prototype.cd=function(a,e,g){if(!b)throw Error("Filesystem has not been initialized.");a.isDirectory?
+(c=a,e&&e(c)):(a=k(a),j(function(a){if(a.isDirectory)c=a,e&&e(c);else if(a=Error("Path was not a directory."),g)g(a);else throw a;},a))};a.prototype.cp=function(a,b,c,e,h){o.bind(this,a,b,c,e,h)()};a.prototype.write=function(a,e,g,f){if(!b)throw Error("Filesystem has not been initialized.");var h=function(a){a.createWriter(function(b){b.onerror=f;if(e.append)b.onwriteend=function(){g&&g(a,this)},b.seek(b.length);else{var d=!1;b.onwriteend=function(){d?g&&g(a,this):(d=!0,this.truncate(this.position))}}if(e.data.__proto__==
+ArrayBuffer.prototype)e.data=new Uint8Array(e.data);var c=new Blob([e.data],e.type?{type:e.type}:{});b.write(c)},f)};a.isFile?h(a):i(a)?j(h,a):c.getFile(a,{create:!0,exclusive:!1},h,f)};a.prototype.df=function(a,b){var c=function(b,c){a(b,c-b,c)};if(!navigator.temporaryStorage.queryUsageAndQuota||!navigator.persistentStorage.queryUsageAndQuota)throw Error("Not implemented.");self.TEMPORARY==this.type?navigator.temporaryStorage.queryUsageAndQuota(c,b):self.PERSISTENT==this.type&&navigator.persistentStorage.queryUsageAndQuota(c,
+b)};return a};
diff --git a/libraries/idbfs/js/logger.js b/libraries/idbfs/js/logger.js
new file mode 100644
index 0000000..ba102a5
--- /dev/null
+++ b/libraries/idbfs/js/logger.js
@@ -0,0 +1,11 @@
+function Logger(selector) {
+  this.el = document.querySelector(selector);
+}
+
+Logger.prototype.log = function(msg) {
+  this.el.innerHTML += msg
+};
+
+Logger.prototype.clear = function() {
+  this.el.textContent = '';
+};