chore(deps-dev): bump karma from 6.3.8 to 6.3.14

Bumps [karma](https://github.com/karma-runner/karma) from 6.3.8 to 6.3.14.
- [Release notes](https://github.com/karma-runner/karma/releases)
- [Changelog](https://github.com/karma-runner/karma/blob/master/CHANGELOG.md)
- [Commits](https://github.com/karma-runner/karma/compare/v6.3.8...v6.3.14)

---
updated-dependencies:
- dependency-name: karma
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>

.eslintignore

@@ -0,0 +1 @@
+tests/dist/

.eslintrc.json

@@ -0,0 +1,36 @@
+{
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es6": true,
+        "mocha": true,
+        "node": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "ecmaVersion": 2017,
+        "sourceType": "module"
+    },
+    "rules": {
+        "indent": [
+            "error",
+            2
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ],
+        "eqeqeq": [
+            "error",
+            "always"
+        ]
+    }
+}

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

.github/workflows/node-js-ci.yml

@@ -0,0 +1,27 @@
+name: node-js-ci
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        node: ['14', '16']
+
+    name: Node ${{ matrix.node }} on ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Test
+        uses: actions/setup-node@v2.4.1
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm install
+      - run: npm test

.gitignore

@@ -1,5 +1,13 @@
 node_modules
-bower_components
 .env
 *~
-dist/filer-issue225.js
+.vscode
+.idea
+
+# Parcel build dirs
+.cache
+tests/dist
+
+# nyc code coverage
+.nyc_output
+coverage

.npmrc

@@ -0,0 +1 @@
+loglevel=silent

.release-it.json

@@ -0,0 +1,17 @@
+{
+  "hooks": {
+    "before:init": ["npm run test"],
+    "before:bump": ["npm run build"]
+  },
+  "git": {
+    "pushRepo": "git@github.com:filerjs/filer.git",
+    "tagName": "v${version}"
+  },
+  "npm": {
+    "publish": true
+  },
+  "github": {
+    "pushRepo": "git@github.com:filerjs/filer.git",
+    "release": true
+  }
+}

.travis.yml

@@ -1,9 +1,32 @@
+sudo: false
 language: node_js
+
 node_js:
-  - "0.10"
-before_install: npm install -g grunt-cli
+  - "lts/*"
+
+cache:
+  directories:
+    - "node_modules"
+
+os:
+  - linux
+  - osx
+
+# Setup headless Firefox and Chrome support
+# https://docs.travis-ci.com/user/gui-and-headless-browsers/#Using-the-Chrome-addon-in-the-headless-mode
+env:
+  - MOZ_HEADLESS=1
+addons:
+  chrome: stable
+  firefox: latest
+before_install:
+  - google-chrome-stable --headless --disable-gpu --remote-debugging-port=9222 http://localhost &
+
+after_success:
+  - npm install -g codecov
+  - npm run coverage
+  - codecov
+
 notifications:
   email: false
   irc: "irc.mozilla.org#filer"
-env:
-  - "FILER_UPSTREAM_URI=\"default\" FILER_UPSTREAM_BRANCH=\"default\" FILER_UPSTREAM_REMOTE_NAME=\"default\""

AUTHORS

@@ -5,3 +5,5 @@ Barry Tulchinsky <barry.tulchinsky@gmail.com> (@btulchinsky)
 Kieran Sedgwick <kieran.sedgwick@gmail.com> (@sedge)
 Yoav Gurevich <ygurevich@ymail.com>
 Gideon Thomas <r.gideonthomas@gmail.com>
+Abdirahman Guled <aguled2@myseneca.ca>
+Ben Heidemann <ben@heidemann.co.uk>

CNAME

@@ -1 +0,0 @@
-filer.js.org

CONTRIBUTING.md

@@ -9,78 +9,67 @@ message and I'll update it.
 
 ## Setup
 
-The Filer build system is based on [grunt](http://gruntjs.com/). To get a working build system
-do the following:
+To get a working build system do the following:
 
 ```
 npm install
-npm install -g grunt-cli
 ```
 
-You can now run the following grunt tasks:
-* `grunt jshint` will run [JSHint](http://www.jshint.com/) on your code (do this before submitting a pull request) to catch errors
-* `grunt develop` will create a single file version of the library for testing in `dist/idbfs.js`
-* `grunt release` like `develop` but will also create a minified version of the library in `dist/idbfs.min.js`
-* `grunt test` or `grunt test-node` will run [JSHint](http://www.jshint.com/) on your code and the test suite in the context of `nodejs`
-* `grunt test-browser` will run [JSHint](http://www.jshint.com/) and start a localhost server on port `1234`. Navigating to `localhost:1234/tests/index.html` will run the test suite in the context of the browser. **NOTE:** When finished, you will have to manually shut off the server by pressing `cmd/ctrl`+`c` in the same terminal session you ran `grunt test-browser`.
+Next, make sure you have installed Chrome and Firefox, which are needed for
+running headless versions of the tests with `npm test`.
 
-Once you've done some hacking and you'd like to have your work merged, you'll need to
-make a pull request. If you're patch includes code, make sure to check that all the
-unit tests pass, including any new tests you wrote. Finally, make sure you add yourself
-to the `AUTHORS` file.
-
-=======
-### Releasing a new version
-=======
-
-`grunt publish` will:
-
-* Run the `grunt release` task
-* Bump `bower.json` & `package.json` version numbers according to a [Semver](http://semver.org/) compatible scheme (see ["How to Publish"](#how-to-publish) below)
-* Create a git tag at the new version number
-* Create a release commit including `dist/filer.js`, `dist/filer.min.js`, `bower.json` and `package.json`
-* Push tag & commit to `origin/develop`
-* Update the `gh-pages` branch with the contents of the `develop` branch
-* Force push the `gh-pages` branch to `origin/gh-pages`
-* Publish the new version of the module to NPM
-
-#### How to configure
-1. Copy `env.sample` to `.env`
-2. Modify as needed, or leave alone for defaults
-
-#### How to Publish
-`grunt publish` can be run in four ways:
-
-1.  `grunt publish` - does a patch (x.x.X) bump
-2.  `grunt publish:patch` - also does a patch (x.x.X) bump
-3.  `grunt publish:minor` - does a minor (x.X.x) bump
-4.  `grunt publish:major` - does a major (X.x.x) bump
-
-The user *must* be on their local `develop` branch before running any form of `grunt publish`, or else the task will fail loudly.
-
-=======
 ## Tests
 
-Tests are writting using [Mocha](http://visionmedia.github.io/mocha/) and [Chai](http://chaijs.com/api/bdd/).
-You can run the tests in your browser by running `grunt test-browser` and opening the `tests` directory @ `http://localhost:1234/tests`, or in a nodejs context by running `grunt test`.
+Tests are written using [Mocha](https://mochajs.org/) and [Chai](http://chaijs.com/api/bdd/).
+There are a number of ways to run the tests.  The preferred way is:
+
+```
+npm test
+```
+
+This will do a build, run the linting, start a server, and load the tests into
+headless versions of Chrome and Firefox.
+
+If you want more control over how tests are run, you can use other scripts:
+
+* Linting is done via `npm run lint` or `npm run eslint`, both of which will run `eslint` on the `src` and `tests` directories.  You can also use `npm run lint:fix` or `npm run eslint:fix`, which will run `eslint` with `--fix` on the `src` and `tests` directories, automatically fixing minor issues.  Linting is run by default as part of `npm test`
+
+* In headless versions of Chrome and Firefox using `npm test`.  A report at the end will tell you what happened with each browser.  Browser tests are preferred because they also test our providers (e.g., IndexedDB).  They do take longer to run.  You can also use `npm run karma-mocha-firefox` or `npm run karma-mocha-chrome` to run the tests in only one of the two headless browsers.
+
+* In node.js using the Memory provider using `npm run test:node`.  These run much faster, but don't run all tests (e.g., providers, watches).
+
+* If you need to debug browser tests, or want to run them in a different browser, use `npm run test:manual`, which will start a server and you can point your browser to [http://localhost:1234](http://localhost:1234).  Running the tests this way will also automatically watch your files, and hot-reload your code and tests, which is useful for debugging and trial/error testing.
+
+* If you need to debug node.js test runs, you can do so using `npm run test:node-debug`.  Then, open Chrome and browse to [chrome://inspect](chrome://inspect) and click on your tests in the inspector.  The easiest way to get a breakpoint is to manually add a `debugger` keyword to your test code where you want the tests to stop.
+
+> Tip: you can add `skip()` to any `it()` or `describe()` in Mocha to skip a test, or `only()` to have only that test run.  For example: `describe.skip(...)` or `it.only(...)`.
+
+* If you want to run migration tests separate from unit tests, use `npm run test:migrations`.  Migration tests run at the end of a typical `npm test` run.  If you need to create a new migration test, see [`tools/fs-image.js`](tools/fs-image.js) for details on how to generate a filesystem image, and [tests/filesystems/images/README.md](tests/filesystems/images/README.md) for more docs.
+
+* If you want to manually generate coverage info for the tests, use `npm run coverage`.  This is done automatically in Travis, so you shouldn't need to do it.  You can see [https://codecov.io/gh/filerjs/filer](https://codecov.io/gh/filerjs/filer) for detailed reports.
 
 There are a number of configurable options for the test suite, which are set via query string params.
-First, you can choose which filer source to use (i.e., src/, dist/filer-test.js, dist/filer.js or dist/filer.min.js).
-The default is to use what is in /dist/filer-test.js, and you can switch to other versions like so:
+First, you can choose which filer source to use (i.e., src/, dist/filer-test.js, dist/filer.js or dist/filer.min.js). The default is to use what is in /dist/filer-test.js, and you can switch to other versions like so:
+
 * tests/index.html?filer-dist/filer.js
 * tests/index.html?filer-dist/filer.min.js
 * tests/index.html?filer-src/filer.js (from src)
 
 Second, you can specify which provider to use for all non-provider specific tests (i.e., most of the tests).
 The default provider is `Memory`, and you can switch it like so:
+
 * tests/index.html?filer-provider=memory
 * tests/index.html?filer-provider=indexeddb
-* tests/index.html?filer-provider=websql
 
 If you're writing tests, make sure you write them in the same style as existing tests, which are
-provider agnostic. See `tests/lib/test-utils.js` and how it gets used in various tests as
-an example.
+provider agnostic. See [`tests/lib/test-utils.js`](tests/lib/test-utils.js) and how it gets used
+in various tests as an example.
 
-## Communication
+## Releases
 
-If you'd like to talk to someone about the project, you can reach us on irc.mozilla.org in the #filer or #mofodev channel. Look for "ack" or "humph".
+In order to perform a release, you'll need commit access to the main Filer repo,
+as well as access to publish to Filer's npm module.  To do a release:
+
+1. Make sure you have a .env file, with your `GITHUB_TOKEN` included.  See [`env.sample`](env.sample) for more info on how to create one.
+1. Login to the `npm` registry if you haven't already using `npm login`
+1. Run `npm run release`.  Releases are done interactively using [release-it](https://www.npmjs.com/package/release-it), and our config is defined in [`.release-it.json`](.release-it.json).

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013, Alan Kligman
+Copyright (c) 2013 - 2019 Alan Kligman and the Filer contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

README.md

@@ -1,26 +1,26 @@
 [![NPM](https://nodei.co/npm/filer.png?downloads=true&stars=true)](https://nodei.co/npm/filer/)
 
-[![Build Status](https://secure.travis-ci.org/filerjs/filer.png?branch=develop)](http://travis-ci.org/filerjs/filer)
+[![Build Status](https://secure.travis-ci.org/filerjs/filer.png?branch=develop)](http://travis-ci.org/filerjs/filer) [![codecov](https://codecov.io/gh/filerjs/filer/branch/master/graph/badge.svg)](https://codecov.io/gh/filerjs/filer)
 
-###Filer
+### Filer
 
-Filer is a POSIX-like file system interface for node.js and browser-based JavaScript.
+Filer is a drop-in replacement for node's `fs` module, a POSIX-like file system
+for browsers.
 
-###Compatibility
+### Compatibility
 
-Filer is known to work in the following browsers/versions, with the specified [Storage Providers](#providers):
+Filer uses [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API)
+and is [known to work in the following browsers/versions](https://caniuse.com/#feat=indexeddb):
 
 * node.js: v0.10.*+
-* IE: 10+ (IndexedDB)
-* Firefox: 26+ (IndexedDB)
-* Chrome: 31+ (IndexedDB, WebSQL)
-* Safari: 7.0+ (WebSQL)
-* Opera: 19+ (IndexedDB, WebSQL)
-* iOS: 3.2+ (WebSQL)
-* Android Browser: 2.1-4.4 (WebSQL), 4.4+ (IndexedDB)
-
-NOTE: if you're interested in maximum compatibility, use the `Fallback` provider instead of `Default`.
-See the section on [Storage Providers](#providers).
+* IE: 10+
+* Edge: 12+
+* Firefox: 10+
+* Chrome: 23+
+* Safari: 10+
+* Opera: 15+
+* iOS: 10+
+* Android Browser: 4.4+
 
 ### Contributing
 
@@ -30,16 +30,15 @@ Want to join the fun? We'd love to have you! See [CONTRIBUTING](https://github.c
 
 Filer can be obtained in a number of ways:
 
-1. npm - `npm install filer`
-2. bower - `bower install filer`
-3. download pre-built versions: [filer.js](https://raw.github.com/filerjs/filer/develop/dist/filer.js), [filer.min.js](https://raw.github.com/filerjs/filer/develop/dist/filer.min.js)
+1. Via npm: `npm install filer`
+1. Via unpkg: `<script src="https://unpkg.com/filer"></script>` or specify a version directly, for example: [https://unpkg.com/filer@1.0.1/dist/filer.min.js](https://unpkg.com/filer@1.0.1/dist/filer.min.js)
 
 ### Loading and Usage
 
 Filer is built as a UMD module and can therefore be loaded as a CommonJS or AMD module, or used via the global.
 
 ```javascript
-// Option 1: Filer loaded via require() in node/browserify
+// Option 1: Filer loaded via require()
 var Filer = require('filer');
 
 // Option 2: Filer loaded via RequireJS
@@ -55,13 +54,84 @@ requirejs(['filer'], function(Filer) {...}
 var Filer = window.Filer;
 ```
 
+### Webpack Plugin
+
+Filer can be used as a drop-in replacement for the node.js [fs](http://nodejs.org/api/fs.html) and
+[path](http://nodejs.org/api/path.html) modules. For convenience, filer provides a webpack plugin which
+will shim the desired node.js functionality. This plugin can be used by inserting the following into
+your webpack config:
+
+```javascript
+// webpack.config.js
+var { FilerWebpackPlugin } = require('filer/webpack');
+
+module.exports = {
+  plugins: [
+    new FilerWebpackPlugin(),
+  ],
+}
+```
+
+---
+**NOTE**
+
+Previously it was recommended to access the `FilerWebpackPlugin` class by importing the main filer module. This was depracated due [this issue](https://github.com/filerjs/filer/issues/790). For anyone using ***filer version 1.4.0 or earlier***, please import the plugin class like this:
+
+```javascript
+var FilerWebpackPlugin = require('filer/src/webpack-plugin');
+```
+
+---
+
+You can then import the node.js [fs](http://nodejs.org/api/fs.html) and [path](http://nodejs.org/api/path.html)
+modules as normal and `FilerWebpackPlugin` will ensure that webpack will resolve references to these modules to
+the appropriate filer shims. You will then be able to use these modules as normal (with the exception of the
+synchronous fs methods e.g. `mkdirSync()`).
+
+```javascript
+import fs from 'fs';
+import path from 'path';
+```
+
+The filer webpack plugin will, by default, shim the [fs](http://nodejs.org/api/fs.html) and
+[path](http://nodejs.org/api/path.html) modules. However, it's behaviour can be customised by passing an
+options object.
+
+```javascript
+// webpack.config.js
+module.exports = {
+  plugins: [
+    new FilerWebpackPlugin({
+      // Options
+    }),
+  ],
+}
+```
+
+The following options can be passed to the filer webpack plugin:
+
+| Option        | Type    | Optional | Default                                          | Description                                                                                                                                      |
+|---------------|---------|----------|--------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| filerDir      | string  | yes      | '\<rootDir\>/node_modules/filer'                 | The directory in which filer is installed.                                                                                                       |
+| shimsDir      | string  | yes      | '\<rootDir\>/node_modules/filer/shims'           | The directory in which the shims are installed.                                                                                                  |
+| fsProviderDir | string  | yes      | '\<rootDir\>/node_modules/filer/shims/providers' | The directory in which the shims are located. This option is required when using a custom provider.                                              |
+| shimFs        | boolean | yes      | true                                             | Should the fs module be shimmed.                                                                                                                 |
+| shimPath      | boolean | yes      | true                                             | Should the path module be shimmed.                                                                                                               |
+| fsProvider    | string  | yes      | 'default'                                        | The file system provider to use. Should be one of 'default', 'indexeddb', 'memory', 'custom'. The 'default' option is equivalent to 'indexeddb'. |
+
+NOTE: '\<rootDir\>' will be resolved to the current working directory.
+
+Though filer also exposes the Buffer object, it is left up to the user to shim this as appropriate. This is because filer offers
+no custom implementation. Currently, filer uses the [node-libs-browser](https://github.com/webpack/node-libs-browser) Buffer implementation
+internally, though any faithful implementation of the [node.js Buffer object](http://nodejs.org/api/buffer.html) should play nicely
+with filer.
+
 ### Getting Started
 
 Filer is as close to the node.js [fs module](http://nodejs.org/api/fs.html) as possible,
 with the following differences:
 
 * No synchronous versions of methods (e.g., `mkdir()` but not `mkdirSync()`).
-* No permissions (e.g., no `chown()`, `chmod()`, etc.).
 * No support for stream-based operations (e.g., `fs.ReadStream`, `fs.WriteStream`).
 
 Filer has other features lacking in node.js (e.g., swappable backend
@@ -78,18 +148,32 @@ they are invoked. Ensure proper ordering by chaining operations in callbacks.
 To create a new file system or open an existing one, create a new `FileSystem`
 instance.  By default, a new [IndexedDB](https://developer.mozilla.org/en/docs/IndexedDB)
 database is created for each file system. The file system can also use other
-backend storage providers, for example [WebSQL](http://en.wikipedia.org/wiki/Web_SQL_Database)
-or even RAM (i.e., for temporary storage). See the section on [Storage Providers](#providers).
+backend storage providers, for example `Memory`. See the section on [Storage Providers](#providers).
 
-```javascript
-var fs = new Filer.FileSystem();
-fs.open('/myfile', 'w+', function(err, fd) {
-  if (err) throw err;
-  fs.close(fd, function(err) {
-    if (err) throw err;
-    fs.stat('/myfile', function(err, stats) {
-      if (err) throw err;
-      console.log('stats: ' + JSON.stringify(stats));
+<a name="overviewExample"></a>
+
+```js
+const { fs, path } = require('filer');
+
+fs.mkdir('/docs', (err) => {
+  if (err) {
+    return console.error('Unable to create /docs dir', err);
+  }
+  
+  const filename = path.join('/docs', 'first.txt');
+  const data = 'Hello World!\n';
+
+  fs.writeFile(filename, data, (err) => {
+    if (err) {
+      return console.error('Unable to write /docs/first.txt', err);
+    }
+
+    fs.stat(filename, (err, stats) =>  {
+      if (err) {
+        return console.error('Unable to stat /docs/first.txt', err);
+      }
+
+      console.log('Stats for /docs/first.txt:', stats);
     });
   });
 });
@@ -98,7 +182,7 @@ fs.open('/myfile', 'w+', function(err, fd) {
 For a complete list of `FileSystem` methods and examples, see the [FileSystem Instance Methods](#FileSystemMethods)
 section below.
 
-Filer also supports node's Path module. See the [Filer.Path](#FilerPath) section below.
+Filer also includes node's `path` and `Buffer` modules. See the [Filer.Path](#FilerPath) and [Filer.Buffer](#FilerBuffer) sections below.
 
 In addition, common shell operations (e.g., rm, touch, cat, etc.) are supported via the
 `FileSystemShell` object, which can be obtained from, and used with a `FileSystem`.
@@ -110,11 +194,29 @@ Like node.js, callbacks for methods that accept them are optional but suggested
 you omit the callback, errors will be thrown as exceptions). The first callback parameter is
 reserved for passing errors. It will be `null` if no errors occurred and should always be checked.
 
+#### Support for Promises
+
+The Promise based API mimics the way node [implements](https://nodejs.org/api/fs.html#fs_fs_promises_api) them. Both `Shell` and `FileSystem` now have a `promises` property, which gives access to Promise based versions of methods in addition to the regular callback style methods. Method names are identical to their callback counterparts with the difference that instead of receiving a final argument as a callback, they return a Promise that is resolved or rejected based on the success of method execution.
+
+See example below:
+
+```javascript
+const fs = new Filer.FileSystem().promises;
+fs.writeFile('/myfile', 'some data')
+  .then(() => fs.stat('/myfile'))
+  .then(stats => { console.log(`stats: ${JSON.stringify(stats)}`); })
+  .catch(err => { console.error(err); });
+```
+
 #### Filer.FileSystem(options, callback) constructor
 
-File system constructor, invoked to open an existing file system or create a new one.
-Accepts two arguments: an `options` object, and an optional `callback`. The `options`
-object can specify a number of optional arguments, including:
+In most cases, using `Filer.fs` will be sufficient, and provide a working filesystem.
+However, if you need more control over the filesystem, you can also use the `FileSystem`
+constructor, invoked to open an existing file system or create a new one.
+
+`Filer.FileSystem()` It accepts two arguments: an `options` object, and an optional
+`callback` function. The `options` object can specify a number of optional arguments,
+including:
 
 * `name`: the name of the file system, defaults to `'"local'`
 * `flags`: an Array of one or more flags to use when creating/opening the file system:
@@ -147,17 +249,19 @@ NOTE: if the optional callback argument is not passed to the `FileSystem` constr
 operations done on the resulting file system will be queued and run in sequence when
 it becomes ready.
 
-####Filer.FileSystem.providers - Storage Providers<a name="providers"></a>
+#### Filer.FileSystem.providers - Storage Providers<a name="providers"></a>
 
-Filer can be configured to use a number of different storage providers. The provider object encapsulates all aspects
-of data access, making it possible to swap in different backend storage options.  There are currently 4 different
-providers to choose from:
+Filer can be configured to use a number of different storage providers. The provider object encapsulates all aspects of data access, making it possible to swap in different backend storage options.  There are currently 2 providers to choose from:
 
 * `FileSystem.providers.IndexedDB()` - uses IndexedDB
-* `FileSystem.providers.WebSQL()` - uses WebSQL
-* `FileSystem.providers.Fallback()` - attempts to use IndexedDB if possible, falling-back to WebSQL if necessary
+if necessary
 * `FileSystem.providers.Memory()` - uses memory (not suitable for data that needs to survive the current session)
 
+**NOTE**: previous versions of Filer also supported `FileSystem.providers.WebSQL()` and
+`FileSystem.providers.Fallback()`, which could be used in browsers that supported
+WebSQL but not IndexedDB.  [WebSQL has been deprecated](https://www.w3.org/TR/webdatabase/),
+and this functionality was removed in `v1.0.0`.  If for some reason you still need it, use [`v0.0.44`](https://github.com/filerjs/filer/releases/tag/v0.0.44).
+
 You can choose your provider when creating a `FileSystem`:
 
 ```javascript
@@ -167,45 +271,62 @@ var providers = FileSystem.providers;
 // Example 1: Use the default provider (currently IndexedDB)
 var fs1 = new FileSystem();
 
-// Example 2: Explicitly use IndexedDB
-var fs2 = new FileSystem({ provider: new providers.IndexedDB() });
-
-// Example 3: Use one of IndexedDB or WebSQL, whichever is supported
-var fs3 = new FileSystem({ provider: new providers.Fallback() });
+// Example 2: Use the Memory provider
+var fs2 = new FileSystem({ provider: new providers.Memory() });
 ```
 
 Every provider has an `isSupported()` method, which returns `true` if the browser supports this provider:
 
 ```javascript
-if( Filer.FileSystem.providers.WebSQL.isSupported() ) {
-  // WebSQL provider will work in current environment...
+if( Filer.FileSystem.providers.IndexedDB.isSupported() ) {
+  // IndexedDB provider will work in current environment...
 }
 ```
 
 You can also write your own provider if you need a different backend. See the code in `src/providers` for details.
 
-A number of other providers have been written, including:
-
-* node.js fs provider: https://github.com/humphd/filer-fs
-* node.js Amazon S3 provider: https://github.com/alicoding/filer-s3
-
-####Filer.Buffer<a name="FilerBuffer"></a>
+#### Filer.Buffer<a name="FilerBuffer"></a>
 
 When reading and writing data, Filer follows node.js and uses [`Buffer`](http://nodejs.org/api/buffer.html).
 When in a node.js environment, native `Buffer`s can be used, or Filer.Buffer, which is a shortcut
 to node's `Buffer`.  In a browser, you can use also use `Filer.Buffer`.
 
 NOTE: a `Filer.Buffer` in a browser is really an augmented `Uint8Array` (i.e., the node `Buffer` api
-methods are added to the instance). See https://github.com/feross/buffer for more details. Additionally, unlike native `Buffer`, `Filer.Buffer`'s constructor can accept `ArrayBuffer` objects, which will be interpreted as `Uint8Array`s.
+methods are added to the instance). See https://github.com/feross/buffer for more details.
 
-####Filer.Path<a name="FilerPath"></a>
+NOTE: `Filer.Buffer` currently includes the older, deprecated [constructor functions](https://nodejs.org/api/buffer.html#buffer_new_buffer_array), but these will be removed
+at some point.  You are encouraged to switch to use the newer class methods `Buffer.from()`
+and `Buffer.alloc()`.  See the [node.js Buffer docs](https://nodejs.org/api/buffer.html).
 
-The node.js [path module](http://nodejs.org/api/path.html) is available via the `Filer.Path` object. It is
-identical to the node.js version with the following differences:
-* No notion of a current working directory in `resolve` (the root dir is used instead)
+```js
+/* Deprecated - see https://nodejs.org/api/buffer.html#buffer_new_buffer_array */
+new Buffer(array)
+new Buffer(arrayBuffer[, byteOffset[, length]])
+new Buffer(buffer)
+new Buffer(string[, encoding])
+new Buffer(size)
+
+/* Use Instead */
+Buffer.from(array)
+Buffer.from(arrayBuffer[, byteOffset[, length]])
+Buffer.from(buffer)
+Buffer.from(string[, encoding])
+Buffer.alloc(size)
+Buffer.allocUnsafe(size)
+```
+
+#### Filer.Path<a name="FilerPath"></a>
+
+The node.js [path module](http://nodejs.org/api/path.html) is available via `Filer.path` or
+`Filer.Path` (both are supported for historical reasons, and to match node). The Filer `path`
+module is identical to the node.js version (see [https://github.com/browserify/path-browserify](https://github.com/browserify/path-browserify)), with the following differences:
+
+* The CWD always defaults to `/`
+* No support for Windows style paths (assume you are on a POSIX system)
+* Additional utility methods (see below)
 
 ```javascript
-var path = Filer.Path;
+var path = Filer.path;
 var dir = path.dirname('/foo/bar/baz/asdf/quux');
 // dir is now '/foo/bar/baz/asdf'
 
@@ -220,17 +341,38 @@ var newpath = path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
 ```
 
 For more info see the docs in the [path module](http://nodejs.org/api/path.html) for a particular method:
-* `path.normalize(p)`
+* `path.normalize(p)` - NOTE: Filer.Path.normalize does *not* add a trailing slash
 * `path.join([path1], [path2], [...])`
 * `path.resolve([from ...], to)`
 * `path.relative(from, to)`
 * `path.dirname(p)`
-* `path.basename(p, [ext])`
+* `path.basename(p, [ext])` - NOTE: Filer.Path.basename will return `'/'` vs. `''`
 * `path.extname(p)`
 * `path.sep`
 * `path.delimiter`
 
-####Filer.Errors<a name="Errors"></a>
+Filer.Path also includes the following extra methods:
+
+* `isNull(p)` returns `true` or `false` if the path contains a null character (`'\u0000'`)
+* `addTrailing(p)` returns the path `p` with a single trailing slash added
+* `removeTrailing(p)` returns the path `p` with trailing slash(es) removed
+
+[As with node.js](https://nodejs.org/api/fs.html#fs_file_paths), all methods below that
+accept a `path` argument as a `String` can also take a [`file://` URL](https://nodejs.org/api/fs.html#fs_url_object_support)
+or a `Buffer`. For example, all of the following cases will work the same way with Filer:
+
+```js
+// 1. path as a String
+fs.writeFile('/dir/file.txt', 'data', function(err) {...});
+
+// 2. path as a URL
+fs.writeFile(new URL('file:///dir/file.txt'), 'data', function(err) {...});
+
+// 3. path as a Buffer
+fs.writeFile(Buffer.from('/dir/file.txt'), 'data', function(err) {...});
+```
+
+#### Filer.Errors<a name="Errors"></a>
 
 The error objects used internally by Filer are also exposed via the `Filer.Errors` object. As much as possible
 these match their node.js counterparts, with a few Filer-specifc additions.
@@ -266,13 +408,17 @@ function callback(err) {
 console.log(err.message);
 ```
 
-###FileSystem Instance Methods<a name="FileSystemMethods"></a>
+### FileSystem Instance Methods<a name="FileSystemMethods"></a>
 
 Once a `FileSystem` is created, it has the following methods. NOTE: code examples below assume
 a `FileSystem` instance named `fs` has been created like so:
 
 ```javascript
-var fs = new Filer.FileSystem();
+// 1. Using Filer.fs for a default filesystem
+const { fs } = require('filer');
+
+// 2. Or via the FileSystem constructor with specified options
+const fs = new Filer.FileSystem(options, callback);
 ```
 
 * [fs.rename(oldPath, newPath, callback)](#rename)
@@ -290,10 +436,16 @@ var fs = new Filer.FileSystem();
 * [fs.mknod(path, mode, callback)](#mknod)
 * [fs.rmdir(path, callback)](#rmdir)
 * [fs.mkdir(path, [mode], callback)](#mkdir)
+* [fs.access(path, [mode], callback)](#access)
+* [fs.mkdtemp(path, [options], callback)](#mkdtemp)
 * [fs.readdir(path, callback)](#readdir)
 * [fs.close(fd, callback)](#close)
 * [fs.open(path, flags, [mode], callback)](#open)
 * [fs.utimes(path, atime, mtime, callback)](#utimes)
+* [fs.chown(path, uid, gid, callback)](#chown)
+* [fs.fchown(fd, uid, gid, callback)](#fchown)
+* [fs.chmod(path, mode, callback)](#chmod)
+* [fs.fchmod(fd, mode, callback)](#fchmod)
 * [fs.futimes(fd, atime, mtime, callback)](#fsutimes)
 * [fs.fsync(fd, callback)](#fsync)
 * [fs.write(fd, buffer, offset, length, position, callback)](#write)
@@ -335,7 +487,7 @@ Example:
 
 ```javascript
 // Create a file, shrink it, expand it.
-var buffer = new Filer.Buffer([1, 2, 3, 4, 5, 6, 7, 8]);
+var buffer = Filer.Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
 fs.open('/myfile', 'w', function(err, fd) {
   if(err) throw error;
@@ -366,7 +518,7 @@ Example:
 
 ```javascript
 // Create a file, shrink it, expand it.
-var buffer = new Filer.Buffer([1, 2, 3, 4, 5, 6, 7, 8]);
+var buffer = Filer.Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
 fs.open('/myfile', 'w', function(err, fd) {
   if(err) throw error;
@@ -397,14 +549,22 @@ Callback gets `(error, stats)`, where `stats` is an object with the following pr
 
 ```
 {
-  node: <string>   // internal node id (unique)
-  dev: <string>    // file system name
-  size: <number>   // file size in bytes
-  nlinks: <number> // number of links
-  atime: <number>  // last access time
-  mtime: <number>  // last modified time
-  ctime: <number>  // creation time
-  type: <string>   // file type (FILE, DIRECTORY, SYMLINK)
+  node: <string>    // internal node id (unique)
+  dev: <string>     // file system name
+  name: <string>    // the entry's name (basename)
+  size: <number>    // file size in bytes
+  nlinks: <number>  // number of links
+  atime: <date>   // last access time as JS Date Object
+  mtime: <date>   // last modified time as JS Date Object
+  ctime: <date>   // creation time as JS Date Object
+  atimeMs: <number>   // last access time as Unix Timestamp
+  mtimeMs: <number>   // last modified time as Unix Timestamp
+  ctimeMs: <number>   // creation time as Unix Timestamp
+  type: <string>    // file type (FILE, DIRECTORY, SYMLINK),
+  gid: <number>     // group name
+  uid: <number>     // owner name
+  mode: <number>    // permissions
+  version: <number> // version of the node
 }
 ```
 
@@ -498,8 +658,8 @@ fs.link("/data/logs/august", "/data/logs/current", function(err) {
 
 #### fs.exists(path, callback)<a name="exists"></a>
 
-Test whether or not the given path exists by checking with the file system. 
-Then call the callback argument with either true or false. 
+Test whether or not the given path exists by checking with the file system.
+Then call the callback argument with either true or false.
 
 Example:
 
@@ -536,10 +696,12 @@ Create a symbolic link to the file at `dstPath` containing the path `srcPath`. A
 Symbolic links are files that point to other paths.
 
 NOTE: Filer allows for, but ignores the optional `type` parameter used in node.js.
+The `srcPath` may be a relative path, which will be resolved relative to `dstPath`
 
 Example:
 
 ```javascript
+// Absolute path
 fs.symlink('/logs/august.log', '/logs/current', function(err) {
   if(err) throw err;
   fs.readFile('/logs/current', 'utf8', function(err, data) {
@@ -547,11 +709,21 @@ fs.symlink('/logs/august.log', '/logs/current', function(err) {
     var currentLog = data;
   });
 });
+
+// Relative path
+fs.symlink('../file', '/dir/symlink', function(err) {
+  if(err) throw err;
+  // The /dir/symlink file is now a symlink to /file
+});
 ```
 
 #### fs.readlink(path, callback)<a name="readlink"></a>
 
-Reads the contents of a symbolic link. Asynchronous [readlink(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/readlink.html). Callback gets `(error, linkContents)`, where `linkContents` is a string containing the symbolic link's link path.
+Reads the contents of a symbolic link. Asynchronous [readlink(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/readlink.html).
+Callback gets `(error, linkContents)`, where `linkContents` is a string
+containing the symbolic link's link path.  If the original `srcPath` given
+to `symlink()` was a relative path, it will be fully resolved relative
+to `dstPath` when returned by `readlink()`.
 
 Example:
 
@@ -596,7 +768,7 @@ Example:
 fs.mknod('/dir', 'DIRECTORY', function(err) {
   if(err) throw err;
   // /dir is now created
-  
+
   // Create a file inside /dir
   fs.mknod('/dir/myfile', 'FILE', function(err) {
     if(err) throw err;
@@ -648,7 +820,47 @@ fs.mkdir('/home', function(err) {
 });
 ```
 
-#### fs.readdir(path, callback)<a name="readdir"></a>
+#### fs.access(path, [mode], callback)<a name="access"></a>
+
+Tests a user's permissions for the file or directory supplied in `path` argument. Asynchronous [access(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/access.html). Callback gets no additional arguments. The `mode` argument can be one of the following (constants are available on `fs.constants` and `fs`):
+
+* `F_OK`: Test for existence of file.
+* `R_OK`: Test whether the file exists and grants read permission.
+* `W_OK`: Test whether the file exists and grants write permission.
+* `X_OK`: Test whether the file exists and grants execute permission.
+
+NOTE: you can also create a mask consisting of the bitwise OR of two or more values (e.g. `fs.constants.W_OK | fs.constants.R_OK`).
+
+Example:
+
+```javascript
+// Check if the file exists in the current directory.
+fs.access(file, fs.F_OK, function(err) {
+  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);
+});
+```
+
+#### fs.mkdtemp(prefix, options, callback)<a name="mkdtemp"></a>
+
+Makes a temporary directory with prefix supplied in `path` argument. Method will append six random characters directly to the prefix. Asynchronous. Callback gets `(error, path)`, where path is the path to the created directory.
+
+NOTE: Filer allows for, but ignores the optional `options` argument used in node.js.
+
+Example:
+
+```javascript
+// Create tmp directory with prefix foo
+fs.mkdtemp("/foo-", function (error, path) {
+    // A new folder foo-xxxxxx will be created. Path contains a path to created folder.    
+});
+
+fs.mkdtemp("/myDir/tmp", function (error, path) {
+    // Will create a new folder tmpxxxxxx inside myDir directory. 
+    // Will throw error if myDir does not exist    
+});
+```
+
+#### fs.readdir(path, [options], callback)<a name="readdir"></a>
 
 Reads the contents of a directory. Asynchronous [readdir(3)](http://pubs.opengroup.org/onlinepubs/009695399/functions/readdir.html).
 Callback gets `(error, files)`, where `files` is an array containing the names of each directory entry (i.e., file, directory, link) in the directory, excluding `.` and `..`.
@@ -669,6 +881,12 @@ fs.readdir('/docs', function(err, files) {
 });
 ```
 
+Optionally accepts an options parameter, which can be either an encoding (e.g. "utf8") or an object with optional properties `encoding` and `withFileTypes`.
+
+The `encoding` property is a `string` which will determine the character encoding to use for the names of each directory entry. The `withFileTypes` property is a `boolean` which defaults to `false`. If `true`, this method will return an array of [fs.Dirent](https://nodejs.org/api/fs.html#fs_class_fs_dirent) objects.
+
+The `name` property on the [fs.Dirent](https://nodejs.org/api/fs.html#fs_class_fs_dirent) objects will be encoded using the specified character encoding.
+
 #### fs.close(fd, callback)<a name="close"></a>
 
 Closes a file descriptor. Asynchronous [close(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/close.html).
@@ -716,7 +934,7 @@ fs.open('/myfile', 'w', function(err, fd) {
 
 #### fs.utimes(path, atime, mtime, callback)<a name="utimes"></a>
 
-Changes the file timestamps for the file given at path `path`. Asynchronous [utimes(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/utimes.html). Callback gets no additional arguments. Both `atime` (access time) and `mtime` (modified time) arguments should be a JavaScript Date.
+Changes the file timestamps for the file given at path `path`. Asynchronous [utimes(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/utimes.html). Callback gets no additional arguments. Both `atime` (access time) and `mtime` (modified time) arguments should be a JavaScript Date or Number.
 
 Example:
 
@@ -730,7 +948,7 @@ fs.utimes('/myfile.txt', now, now, function(err) {
 
 #### fs.futimes(fd, atime, mtime, callback)<a name="futimes"></a>
 
-Changes the file timestamps for the open file represented by the file descriptor `fd`. Asynchronous [utimes(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/utimes.html). Callback gets no additional arguments. Both `atime` (access time) and `mtime` (modified time) arguments should be a JavaScript Date.
+Changes the file timestamps for the open file represented by the file descriptor `fd`. Asynchronous [utimes(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/utimes.html). Callback gets no additional arguments. Both `atime` (access time) and `mtime` (modified time) arguments should be a JavaScript Date or Number.
 
 Example:
 
@@ -749,9 +967,107 @@ fs.open('/myfile.txt', function(err, fd) {
 });
 ```
 
+#### fs.chown(path, uid, gid, callback)<a name="chown"></a>
+
+Changes the owner and group of a file. Asynchronous [chown(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/chown.html). Callback gets no additional arguments. Both `uid` (user id) and `gid` (group id) arguments should be a JavaScript Number.  By default, `0x0` is used (i.e., `root:root` ownership).
+
+Example:
+
+```javascript
+fs.chown('/myfile.txt', 500, 500, function(err) {
+  if(err) throw err;
+
+  // /myfile.txt is now owned by user with id 500, group 500
+});
+```
+
+#### fs.fchown(fd, uid, gid, callback)<a name="fchown"></a>
+
+Changes the owner and group of a file. Asynchronous [chown(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/chown.html). Callback gets no additional arguments. Both `uid` (user id) and `gid` (group id) arguments should be a JavaScript Number.  By default, `0x0` is used (i.e., `root:root` ownership).
+
+Example:
+
+```javascript
+fs.open('/myfile.txt', function(err, fd) {
+  if(err) throw err;
+
+  fs.fchown(fd, 500, 500, function(err) {
+    if(err) throw err;
+
+    // /myfile.txt is now owned by user with id 500, group 500
+
+    fs.close(fd);
+  });
+});
+```
+
+#### fs.chmod(path, mode, callback)<a name="chmod"></a>
+
+Changes the mode of a file. Asynchronous [chmod(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/chmod.html). Callback gets no additional arguments. The `mode` argument should be a JavaScript Number, which combines file type and permission information.  Here are a list of common values useful for setting the `mode`:
+
+* File type `S_IFREG=0x8000`
+* Dir type `S_IFDIR=0x4000`
+* Link type `S_IFLNK=0xA000`
+
+* Permissions `755=0x1ED`
+* Permissions `644=0x1A4`
+* Permissions `777=0x1FF`
+* Permissions `666=0x1B6`
+
+By default, directories use `(0x4000 | 0x1ED)` and files use `(0x8000 | 0x1A4)`.
+
+Example:
+
+```javascript
+// S_IFREG | 0o777
+var mode = 0x8000 | 0x1FF
+fs.chmod('/myfile.txt', mode, function(err) {
+  if(err) throw err;
+
+  // /myfile.txt is a regular file with permissions 777
+});
+```
+
+#### fs.fchmod(fd, mode, callback)<a name="fchmod"></a>
+
+Changes the mode of a file. Asynchronous [chmod(2)](http://pubs.opengroup.org/onlinepubs/009695399/functions/chmod.html). Callback gets no additional arguments. The `mode` argument should be a JavaScript Number, which combines file type and permission information.  By default, `755` (dir) and `644` (file) are used.
+
+Example:
+
+```javascript
+fs.open('/myfile.txt', function(err, fd) {
+  if(err) throw err;
+
+  // S_IFREG | 0o777
+  var mode = 0x8000 | 0x1FF
+  fs.fchmod(fd, mode, function(err) {
+    if(err) throw err;
+
+    // /myfile.txt is a regular file with permissions 777
+
+    fs.close(fd);
+  });
+});
+```
+
 #### fs.fsync(fd, callback)<a name="fsync"></a>
 
-NOTE: Not yet implemented, see https://github.com/filerjs/filer/issues/87
+Synchronize the data and metadata for the file referred to by `fd` to disk.
+Asynchronous [fsync(2)](http://man7.org/linux/man-pages/man2/fsync.2.html).
+The callback gets `(error)`.
+
+```js
+fs.open('/myfile', 'r', function(error, fd) {
+  if(err) throw err;
+
+  // Use fd, then sync
+
+  fs.fsync(fd, function(error) {
+    if(err) throw err;
+    fs.close(fd, done);
+  });
+});
+```
 
 #### fs.write(fd, buffer, offset, length, position, callback)<a name="write"></a>
 
@@ -763,7 +1079,7 @@ Example:
 
 ```javascript
 // Create a file with the following bytes.
-var buffer = new Filer.Buffer([1, 2, 3, 4, 5, 6, 7, 8]);
+var buffer = Filer.Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 
 fs.open('/myfile', 'w', function(err, fd) {
   if(err) throw error;
@@ -800,22 +1116,22 @@ Example:
 
 ```javascript
 fs.open('/myfile', 'r', function(err, fd) {
-  if(err) throw error;
+  if(err) throw err;
 
   // Determine size of file
   fs.fstat(fd, function(err, stats) {
-    if(err) throw error;
+    if(err) throw err;
 
     // Create a buffer large enough to hold the file's contents
     var nbytes = expected = stats.size;
-    var buffer = new Filer.Buffer(nbytes);
+    var buffer = Filer.Buffer.alloc(nbytes);
     var read = 0;
 
     function readBytes(offset, position, length) {
       length = length || buffer.length - read;
 
       fs.read(fd, buffer, offset, length, position, function(err, nbytes) {
-        if(err) throw error;
+        if(err) throw err;
 
         // nbytes is now the number of bytes read, between 0 and buffer.length.
         // See if we still have more bytes to read.
@@ -866,7 +1182,7 @@ fs.writeFile('/myfile.txt', "...data...", function (err) {
 });
 
 // Write binary file
-var buffer = new Filer.Buffer([1, 2, 3, 4, 5, 6, 7, 8]);
+var buffer = Filer.Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
 fs.writeFile('/myfile', buffer, function (err) {
   if (err) throw err;
 });
@@ -889,15 +1205,15 @@ fs.appendFile('/myfile.txt', "Data...", function (err) {
 // '/myfile.txt' would now read out 'More...Data...'
 
 // Append binary file
-var data = new Filer.Buffer([1, 2, 3, 4]);
-var more = new Filer.Buffer([5, 6, 7, 8]);
+var data = Filer.Buffer.from([1, 2, 3, 4]);
+var more = Filer.Buffer.from([5, 6, 7, 8]);
 
 fs.writeFile('/myfile', data, function (err) {
   if (err) throw err;
 
   fs.appendFile('/myfile', more, function (err) {
     if (err) throw err;
-    
+
     // '/myfile' would now contain [1, 2, 3, 4, 5, 6, 7, 8]
   });
 });
@@ -1088,20 +1404,31 @@ fs.writeFile('/data/subdir/file', 'data');
 ### FileSystemShell<a name="FileSystemShell"></a>
 
 Many common file system shell operations are available by using a `FileSystemShell` object.
-The `FileSystemShell` is obtained from, and used in conjuction with a `FileSystem`,
+The `FileSystemShell` is used in conjunction with a `FileSystem`,
 and provides augmented features. Many separate `FileSystemShell` objects can exist per
 `FileSystem`, but each `FileSystemShell` is bound to a single instance of a `FileSystem`
 for its lifetime.
 
-A `FileSystemShell` is created using the `FileSystem.Shell()` function:
+A `FileSystemShell` is created by instantiating `Filer.FileSystem().Shell`:
 
 ```javascript
 var fs = new Filer.FileSystem();
-var sh = fs.Shell(options);
-var sh2 = fs.Shell(options);
+var sh = new fs.Shell(options);
+var sh2 = new fs.Shell(options);
 // sh and sh2 are two separate shells, each bound to fs
 ```
 
+In addition, the constructor function can be accessed through `Filer`:
+
+```javascript
+var fs = new Filer.FileSystem();
+var sh = new fs.Shell();
+
+Filer.Shell.prototype.newFunction = ...;
+
+sh.newFunction();
+```
+
 The `FileSystemShell` can take an optional `options` object. The `options` object
 can include `env`, which is a set of environment variables. Currently supported variables
 include `TMP` (the path to the temporary directory), and `PATH` (the list of known paths) and
@@ -1109,7 +1436,7 @@ others may be added in the future. You can also add your own, or update existing
 
 ```javascript
 var fs = new Filer.FileSystem();
-var sh = fs.Shell({
+var sh = new fs.Shell({
   env: {
     TMP: '/tempdir',
     PATH: '/one:/two'
@@ -1135,7 +1462,7 @@ Example:
 
 ```javascript
 var fs = new Filer.FileSystem();
-var sh = fs.Shell();
+var sh = new fs.Shell();
 var p = sh.env.get('PATH');
 
 // Store the current location
@@ -1155,11 +1482,12 @@ examples below assume a `FileSystemShell` instance named `sh` has been created l
 
 ```javascript
 var fs = new Filer.FileSystem();
-var sh = fs.Shell();
+var sh = new fs.Shell();
 ```
 
 * [sh.cd(path, callback)](#cd)
 * [sh.pwd()](#pwd)
+* [sh.find(dir, [options], callback)](#find)
 * [sh.ls(dir, [options], callback)](#ls)
 * [sh.exec(path, [args], callback)](#exec)
 * [sh.touch(path, [options], callback)](#touch)
@@ -1188,20 +1516,71 @@ sh.cd('/dir1', function(err) {
 
 Returns the shell's current working directory. See [sh.cd()](#cd).
 
+#### sh.find(dir, [options], callback)<a name="find"></a>
+
+Recursively walk a directory tree, reporting back all paths that were
+found along the way. Asynchronous [find(1)](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/find.html
+)
+If given no options, `find` walks the given dir path
+and the callback gives `function(err, found)`, where `found` is an array of
+all paths discovered during a depth-first walk.
+
+Valid options include a `regex` for pattern matching paths, allowing paths
+to be ignored (e.g., ```regex: /\.bak$/``` to find all `.bak` files). You can
+also use `name` and `path` to provide a [match pattern](https://github.com/isaacs/minimatch) for the basename and
+dirname respectively (e.g., `{name: '*.js'}` to find all JavaScript files or
+`{path: '*-modules'}` to only look in folders named `base-modules`, `foo-modules`, etc.).
+Finally, you can also provide an `exec` function of the form `function(path, next)` where
+`path` is the current path that was found and matches any provided `regex`
+(NOTE: dir paths have an '/' appended), and `next` is a callback to call
+when you are done processing the path.
+
+Example:
+
+```javascript
+function processPath(path, next) {
+  // Process the path somehow, in this case we print it.
+  // Dir paths end with /
+  if(path.endsWith('/')) {
+    console.log('Found dir: ' + path);
+  } else {
+    console.log('Found file: ' + path);
+  }
+
+  // All done, let the process continue by invoking second arg:
+  next();
+}
+
+// Get every path (NOTE: no name or regex provided) below the root, depth first
+sh.find('/', {exec: processPath}, function(err, found) {
+  /* find command is finished, `found` contains the flattened list as an Array */
+});
+
+// Find all files that look like map201.jpg, map202.jpg in the /data dir
+sh.find('/data', {regex: /map20\d\.jpg$/, exec: processPath}, function(err) {
+  /* find command is finished */
+});
+
+// Find and delete all *.bak files under /app/user
+sh.find('/app/user', {
+  name: '*.bak',
+  exec: function(path, next) {
+    sh.rm(path, next);
+  }
+}, function callback(err, found) {
+  if(err) throw err;
+
+  if(found.length) {
+    console.log('Deleted the following ' + found.length + ' files: ', found);
+  }
+});
+```
+
 #### sh.ls(dir, [options], callback)<a name="ls"></a>
 
 Get the listing of a directory, returning an array of directory entries
-in the following form:
-```
-{
-  path: <String> the basename of the directory entry
-  links: <Number> the number of links to the entry
-  size: <Number> the size in bytes of the entry
-  modified: <Number> the last modified date/time
-  type: <String> the type of the entry
-  contents: <Array> an optional array of child entries, if this entry is itself a directory
-}
-```
+in the same form as [fs.stat()](#stat), with the exception that a new Array named
+`contents` is added for directory entries, containing child entries.
 
 By default `sh.ls()` gives a shallow listing. If you want to follow
 directories as they are encountered, use the `recursive=true` option. NOTE:
@@ -1360,9 +1739,9 @@ sh.tempDir(function(err, tmp) {
 
 #### sh.mkdirp(path, callback)<a name="mkdirp"></a>
 
-Recursively creates the directory at the provided path. If the 
+Recursively creates the directory at the provided path. If the
 directory already exists, no error is returned. All parents must
-be valid directories (not files). 
+be valid directories (not files).
 
 Example:
 

bower.json

@@ -1,15 +0,0 @@
-{
-  "name": "filer",
-  "version": "0.0.35",
-  "main": "dist/filer.js",
-  "ignore": [
-    "build",
-    "examples",
-    "package.json",
-    "tests",
-    "gruntfile.js",
-    "node_modules",
-    "src",
-    "tools"
-  ]
-}

config/environment.js

@@ -1,5 +0,0 @@
-module.exports = (function() {
-  var habitat = require('habitat');
-  habitat.load();
-  return new habitat();
-})();

env.sample

@@ -1,14 +1,9 @@
 ###
 # Dev ENVIRONMENT file
 #
-# Copy to .env to use defaults
+# Copy to .env to use defaults when releasing via `npm release`
 ###
 
-# GIT (upstream) url to publish to
-export FILER_UPSTREAM_URI="git@github.com:js-platform/filer.git"
-
-# GIT (upstream) branch to publish to
-export FILER_UPSTREAM_BRANCH="develop"
-
-# Remote name for upstream repo
-export FILER_UPSTREAM_REMOTE_NAME="origin"
+# GitHub Personal Access Token (to push releases)
+# https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/
+GITHUB_TOKEN=

gruntfile.js

@@ -1,231 +0,0 @@
-var semver = require('semver'),
-    fs = require('fs'),
-    currentVersion = JSON.parse(fs.readFileSync('./package.json', 'utf8')).version,
-    env = require('./config/environment');
-
-// Globals
-var PROMPT_CONFIRM_CONFIG = 'confirmation',
-    GIT_BRANCH = env.get('FILER_UPSTREAM_BRANCH'),
-    GIT_REMOTE = env.get('FILER_UPSTREAM_REMOTE_NAME'),
-    GIT_FULL_REMOTE = env.get('FILER_UPSTREAM_URI') + ' ' + GIT_BRANCH;
-
-module.exports = function(grunt) {
-
-  // Project configuration.
-  grunt.initConfig({
-    pkg: grunt.file.readJSON('package.json'),
-
-    clean: ['dist/filer-test.js', 'dist/filer-issue225.js'],
-
-    uglify: {
-      options: {
-        banner: '/*! <%= pkg.name %> <%= pkg.version %> <%= grunt.template.today("yyyy-mm-dd") %> */\n'
-      },
-      develop: {
-        src: 'dist/filer.js',
-        dest: 'dist/filer.min.js'
-      }
-    },
-
-    jshint: {
-      // Don't bother with src/path.js
-      all: [
-        'gruntfile.js',
-        'config/environment.js',
-        'src/constants.js',
-        'src/errors.js',
-        'src/fs.js',
-        'src/index.js',
-        'src/shared.js',
-        'src/shell.js',
-        'src/fswatcher.js',
-        'src/environment.js',
-        'src/providers/**/*.js',
-        'src/adapters/**/*.js',
-        'src/directory-entry.js',
-        'src/open-file-description.js',
-        'src/super-node.js',
-        'src/node.js',
-        'src/stats.js',
-        'src/filesystem/**/*.js'
-      ]
-    },
-
-    browserify: {
-      filerDist: {
-        src: "./src/index.js",
-        dest: "./dist/filer.js",
-        options: {
-          browserifyOptions: {
-            commondir: false
-          },
-          bundleOptions: {
-            standalone: 'Filer'
-          },
-          exclude: ["./node_modules/request/index.js"]
-        }
-      },
-      filerTest: {
-        src: "./tests/index.js",
-        dest: "./dist/filer-test.js"
-      },
-      // See tests/bugs/issue225.js
-      filerIssue225: {
-        src: "./src/index.js",
-        dest: "./dist/filer-issue225.js",
-        options: {
-          browserifyOptions: {
-            commondir: false
-          },
-          bundleOptions: {
-            standalone: 'Filer'
-          }
-        }
-      }
-    },
-
-    shell: {
-      mocha: {
-        // Run all tests (e.g., tests require()'ed in tests/index.js) and also tests/bugs/issue225.js
-        // separately, since it can't be included in a browserify build.
-        command: '"./node_modules/.bin/mocha" --reporter list tests/index.js && "./node_modules/.bin/mocha" --reporter list tests/bugs/issue225.js'
-      }
-    },
-
-    bump: {
-      options: {
-        files: ['package.json', 'bower.json'],
-        commit: true,
-        commitMessage: 'v%VERSION%',
-        commitFiles: ['package.json', 'bower.json', './dist/filer.js', './dist/filer.min.js', './dist/filer-test.js'],
-        createTag: true,
-        tagName: 'v%VERSION%',
-        tagMessage: 'v%VERSION%',
-        push: true,
-        pushTo: GIT_FULL_REMOTE
-      }
-    },
-
-    'npm-checkBranch': {
-      options: {
-        branch: GIT_BRANCH
-      }
-    },
-
-    'npm-publish': {
-      options: {
-        abortIfDirty: false
-      }
-    },
-
-    prompt: {
-      confirm: {
-        options: {
-          questions: [
-            {
-              config: PROMPT_CONFIRM_CONFIG,
-              type: 'confirm',
-              message: 'Bump version from ' + (currentVersion).cyan +
-                          ' to ' + semver.inc(currentVersion, "patch").yellow + '?',
-              default: false
-            }
-          ],
-          then: function(results) {
-            if (!results[PROMPT_CONFIRM_CONFIG]) {
-              return grunt.fatal('User aborted...');
-            }
-          }
-        }
-      }
-    },
-
-    gitcheckout: {
-      publish: {
-        options: {
-          branch: 'gh-pages',
-          overwrite: true
-        }
-      },
-      revert: {
-        options: {
-          branch: GIT_BRANCH
-        }
-      }
-    },
-
-    gitpush: {
-      publish: {
-        options: {
-          remote: GIT_REMOTE,
-          branch: 'gh-pages',
-          force: true
-        },
-      }
-    },
-    connect: {
-      serverForNode: {
-        options: {
-          port: 1234,
-          base: '.'
-        }
-      },
-      serverForBrowser: {
-        options: {
-          port: 1234,
-          base: '.',
-          keepalive: true
-        }
-      }
-    }
-  });
-
-  grunt.loadNpmTasks('grunt-contrib-clean');
-  grunt.loadNpmTasks('grunt-contrib-uglify');
-  grunt.loadNpmTasks('grunt-contrib-jshint');
-  grunt.loadNpmTasks('grunt-contrib-connect');
-  grunt.loadNpmTasks('grunt-bump');
-  grunt.loadNpmTasks('grunt-npm');
-  grunt.loadNpmTasks('grunt-git');
-  grunt.loadNpmTasks('grunt-prompt');
-  grunt.loadNpmTasks('grunt-shell');
-  grunt.loadNpmTasks('grunt-contrib-connect');
-  grunt.loadNpmTasks('grunt-browserify');
-
-  grunt.registerTask('develop', ['clean', 'browserify']);
-  grunt.registerTask('build-tests', ['clean', 'browserify:filerTest']);
-  grunt.registerTask('release', ['test', 'develop', 'uglify']);
-
-  grunt.registerTask('publish', 'Publish filer as a new version to NPM, bower and github.', function(patchLevel) {
-    var allLevels = ['patch', 'minor', 'major'];
-
-    // No level specified defaults to 'patch'
-    patchLevel = (patchLevel || 'patch').toLowerCase();
-
-    // Fail out if the patch level isn't recognized
-    if (allLevels.filter(function(el) { return el == patchLevel; }).length === 0) {
-      return grunt.fatal('Patch level not recognized! "Patch", "minor" or "major" only.');
-    }
-
-    // Set prompt message
-    var promptOpts = grunt.config('prompt.confirm.options');
-    promptOpts.questions[0].message =  'Bump version from ' + (currentVersion).cyan +
-      ' to ' + semver.inc(currentVersion, patchLevel).yellow + '?';
-    grunt.config('prompt.confirm.options', promptOpts);
-
-    grunt.task.run([
-      'prompt:confirm',
-      'checkBranch',
-      'release',
-      'bump:' + patchLevel,
-      'gitcheckout:publish',
-      'gitpush:publish',
-      'gitcheckout:revert',
-      'npm-publish'
-    ]);
-  });
-  grunt.registerTask('test-node', ['jshint', 'browserify:filerIssue225', 'connect:serverForNode', 'shell:mocha']);
-  grunt.registerTask('test-browser', ['jshint', 'build-tests', 'connect:serverForBrowser']);
-  grunt.registerTask('test', ['clean', 'test-node']);
-
-  grunt.registerTask('default', ['test']);
-};

javascripts/main.js

@@ -1 +0,0 @@
-console.log('This would be the main JS file.');

karma.conf.js

@@ -0,0 +1,28 @@
+module.exports = function(config) {
+  config.set({
+    singleRun: true,
+    basePath: '',
+    files: [
+      'node_modules/regenerator-runtime/runtime.js',
+      'tests/dist/index.js'
+    ],
+    frameworks: ['mocha', 'chai'],
+    reporters: ['mocha', 'summary'],
+    client: {
+      captureConsole: true,
+      mocha: {
+        ui: 'bdd',
+        timeout: 5000,
+        slow: 250
+      }
+    },
+    summaryReporter: {
+      // 'failed', 'skipped' or 'all'
+      show: 'failed',
+      // Limit the spec label to this length
+      specLength: 50,
+      // Show an 'all' column as a summary
+      overviewColumn: true
+    }
+  });
+};

lib/nodash.js

@@ -1,97 +0,0 @@
-// Cherry-picked bits of underscore.js, lodash.js
-
-/**
- * Lo-Dash 2.4.0 <http://lodash.com/>
- * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
- * Based on Underscore.js 1.5.2 <http://underscorejs.org/LICENSE>
- * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
- * Available under MIT license <http://lodash.com/license>
- */
-var ArrayProto = Array.prototype;
-var nativeForEach = ArrayProto.forEach;
-var nativeIndexOf = ArrayProto.indexOf;
-var nativeSome = ArrayProto.some;
-
-var ObjProto = Object.prototype;
-var hasOwnProperty = ObjProto.hasOwnProperty;
-var nativeKeys = Object.keys;
-
-var breaker = {};
-
-function has(obj, key) {
-  return hasOwnProperty.call(obj, key);
-}
-
-var keys = nativeKeys || function(obj) {
-  if (obj !== Object(obj)) throw new TypeError('Invalid object');
-  var keys = [];
-  for (var key in obj) if (has(obj, key)) keys.push(key);
-  return keys;
-};
-
-function size(obj) {
-  if (obj == null) return 0;
-  return (obj.length === +obj.length) ? obj.length : keys(obj).length;
-}
-
-function identity(value) {
-  return value;
-}
-
-function each(obj, iterator, context) {
-  var i, length;
-  if (obj == null) return;
-  if (nativeForEach && obj.forEach === nativeForEach) {
-    obj.forEach(iterator, context);
-  } else if (obj.length === +obj.length) {
-    for (i = 0, length = obj.length; i < length; i++) {
-      if (iterator.call(context, obj[i], i, obj) === breaker) return;
-    }
-  } else {
-    var keys = keys(obj);
-    for (i = 0, length = keys.length; i < length; i++) {
-      if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
-    }
-  }
-};
-
-function any(obj, iterator, context) {
-  iterator || (iterator = identity);
-  var result = false;
-  if (obj == null) return result;
-  if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
-  each(obj, function(value, index, list) {
-    if (result || (result = iterator.call(context, value, index, list))) return breaker;
-  });
-  return !!result;
-};
-
-function contains(obj, target) {
-  if (obj == null) return false;
-  if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
-  return any(obj, function(value) {
-    return value === target;
-  });
-};
-
-function Wrapped(value) {
-  this.value = value;
-}
-Wrapped.prototype.has = function(key) {
-  return has(this.value, key);
-};
-Wrapped.prototype.contains = function(target) {
-  return contains(this.value, target);
-};
-Wrapped.prototype.size = function() {
-  return size(this.value);
-};
-
-function nodash(value) {
-  // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor
-  return (value && typeof value == 'object' && !Array.isArray(value) && hasOwnProperty.call(value, '__wrapped__'))
-    ? value
-    : new Wrapped(value);
-}
-
-module.exports = nodash;

package.json

@@ -5,48 +5,91 @@
     "fs",
     "node",
     "file",
-    "system",
+    "filesystem",
     "browser",
     "indexeddb",
-    "idb",
-    "websql"
+    "idb"
   ],
-  "version": "0.0.35",
+  "version": "1.4.1",
   "author": "Alan K <ack@modeswitch.org> (http://blog.modeswitch.org)",
   "homepage": "http://filerjs.github.io/filer",
   "bugs": "https://github.com/filerjs/filer/issues",
-  "license": "BSD",
+  "license": "BSD-2-Clause",
   "scripts": {
-    "test": "grunt test"
+    "eslint": "npm run lint",
+    "eslint:fix": "npm run lint:fix",
+    "lint": "eslint src tests",
+    "lint:fix": "eslint --fix src tests",
+    "test:node": "mocha --timeout 5000 tests",
+    "pretest:node-debug": "echo \"Open Chrome to chrome://inspect to debug tests...\"",
+    "test:node-debug": "mocha --timeout 5000 --inspect-brk tests",
+    "test:manual": "parcel tests/index.html --out-dir tests/dist",
+    "test:migrations": "mocha tests/filesystems/migrations",
+    "pretest": "npm run lint",
+    "test": "npm run karma-mocha",
+    "posttest": "npm run test:migrations",
+    "prebuild": "parcel build --global Filer src/index.js --no-minify --out-file filer.js",
+    "build": "parcel build --global Filer src/index.js --out-file filer.min.js --detailed-report",
+    "build-tests": "parcel build tests/index.js --no-source-maps --out-dir tests/dist",
+    "prekarma-mocha-firefox": "npm run build-tests",
+    "karma-mocha-firefox": "karma start karma.conf.js --browsers FirefoxHeadless",
+    "prekarma-mocha-chrome": "npm run build-tests",
+    "karma-mocha-chrome": "karma start karma.conf.js --browsers ChromeHeadless",
+    "prekarma-mocha": "npm run build-tests",
+    "karma-mocha": "karma start karma.conf.js --browsers ChromeHeadless,FirefoxHeadless",
+    "coverage": "nyc mocha tests/index.js",
+    "release": "run.env release-it"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/filerjs/filer.git"
   },
   "dependencies": {
-    "bower": "~1.3.8",
-    "base64-arraybuffer": "^0.1.2"
+    "es6-promisify": "^7.0.0",
+    "minimatch": "^3.0.4",
+    "schema-utils": "^3.1.1"
   },
   "devDependencies": {
-    "chai": "~1.9.1",
-    "grunt": "~0.4.0",
-    "grunt-browserify": "^2.1.0",
-    "grunt-bump": "0.0.13",
-    "grunt-contrib-clean": "~0.4.0",
-    "grunt-contrib-compress": "~0.4.1",
-    "grunt-contrib-concat": "~0.1.3",
-    "grunt-contrib-connect": "^0.7.1",
-    "grunt-contrib-jshint": "~0.7.1",
-    "grunt-contrib-uglify": "~0.1.2",
-    "grunt-contrib-watch": "~0.3.1",
-    "grunt-git": "0.2.10",
-    "grunt-npm": "git://github.com/sedge/grunt-npm.git#branchcheck",
-    "grunt-prompt": "^1.1.0",
-    "grunt-shell": "~0.7.0",
-    "habitat": "^1.1.0",
-    "mocha": "~1.18.2",
-    "semver": "^2.3.0",
-    "requirejs": "^2.1.14"
+    "regenerator-runtime": "^0.13.9",
+    "chai": "^4.3.4",
+    "chai-datetime": "^1.8.0",
+    "eslint": "^7.32.0",
+    "fake-indexeddb": "^3.1.7",
+    "karma": "^6.3.8",
+    "karma-chai": "^0.1.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-mocha": "^2.0.1",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-summary-reporter": "^3.0.0",
+    "meow": "^10.0.1",
+    "mocha": "^9.1.3",
+    "nyc": "^15.1.0",
+    "parcel-bundler": "^1.12.5",
+    "pretty-bytes": "^5.6.0",
+    "release-it": "^14.11.6",
+    "run.env": "^1.1.0",
+    "unused-filename": "^3.0.1",
+    "walk": "^2.3.15"
   },
-  "main": "./src/index.js"
+  "main": "./src/index.js",
+  "browser": "./dist/filer.min.js",
+  "files": [
+    "src",
+    "lib",
+    "dist",
+    "shims",
+    "webpack"
+  ],
+  "nyc": {
+    "exclude": [
+      "tests/**/*.js",
+      "lib/**/*.js",
+      "src/providers/**/*.js"
+    ],
+    "reporter": [
+      "lcov",
+      "text"
+    ]
+  }
 }

perf/index.js

@@ -1,4 +1,3 @@
-var Filer = require('..');
 var util = require('../tests/lib/test-utils.js');
 
 function setImmediate(cb) {

shims/fs.js

@@ -0,0 +1,65 @@
+const { FileSystem } = require('../src/index');
+
+let Provider;
+try {
+  Provider = require('fsProvider');
+}
+catch (err) {
+  Provider = require('./providers/default');
+}
+
+const provider = new Provider();
+
+let onFsReady;
+let onFsError;
+
+let fsReady = new Promise((resolve, reject) => {
+  onFsReady = resolve;
+  onFsError = reject;
+});
+
+var fsInstance = new FileSystem({ provider }, (err) => {
+  if (err) {
+    onFsError(err);
+  } else {
+    onFsReady(true);
+  }
+});
+
+function proxyHasProp(target, prop) {
+  return prop in target;
+}
+
+const fsPromises = new Proxy(fsInstance.promises, {
+  get(target, prop) {
+    if (!proxyHasProp(target, prop)) {
+      return;
+    }
+
+    return async (...args) => {
+      await fsReady;
+      return await target[prop](...args);
+    };
+  },
+});
+
+const fs = new Proxy(fsInstance, {
+  get(target, prop) {
+    if (!proxyHasProp(target, prop)) {
+      return;
+    }
+
+    if (prop === 'promises') {
+      return fsPromises;
+    }
+
+    return (...args) => {
+      (async () => {
+        await fsReady;
+        target[prop](...args);
+      })();
+    };
+  },
+});
+
+module.exports = fs;

shims/path.js

@@ -0,0 +1,3 @@
+const { path } = require('../src/index');
+
+module.exports = path;

shims/providers/default.js

@@ -0,0 +1,2 @@
+const { Default } = require('../../src/providers/index');
+module.exports = Default;

shims/providers/indexeddb.js

@@ -0,0 +1,2 @@
+const IndexedDB = require('../../src/providers/indexeddb');
+module.exports = IndexedDB;

shims/providers/memory.js

@@ -0,0 +1,2 @@
+const Memory = require('../../src/providers/memory');
+module.exports = Memory;

src/buffer.js

@@ -1,23 +0,0 @@
-function FilerBuffer (subject, encoding, nonZero) {
-
-  // Automatically turn ArrayBuffer into Uint8Array so that underlying
-  // Buffer code doesn't just throw away and ignore ArrayBuffer data.
-  if (subject instanceof ArrayBuffer) {
-    subject = new Uint8Array(subject);
-  }
-
-  return new Buffer(subject, encoding, nonZero);
-};
-
-// Inherit prototype from Buffer
-FilerBuffer.prototype = Object.create(Buffer.prototype);
-FilerBuffer.prototype.constructor = FilerBuffer;
-
-// Also copy static methods onto FilerBuffer ctor
-Object.keys(Buffer).forEach(function (p) {
-  if (Buffer.hasOwnProperty(p)) {
-    FilerBuffer[p] = Buffer[p];
-  }
-});
-
-module.exports = FilerBuffer;

src/constants.js

@@ -15,15 +15,21 @@ module.exports = {
   IDB_RO: 'readonly',
   IDB_RW: 'readwrite',
 
-  WSQL_VERSION: "1",
+  WSQL_VERSION: '1',
   WSQL_SIZE: 5 * 1024 * 1024,
-  WSQL_DESC: "FileSystem Storage",
+  WSQL_DESC: 'FileSystem Storage',
 
-  MODE_FILE: 'FILE',
-  MODE_DIRECTORY: 'DIRECTORY',
-  MODE_SYMBOLIC_LINK: 'SYMLINK',
-  MODE_META: 'META',
+  NODE_TYPE_FILE: 'FILE',
+  NODE_TYPE_DIRECTORY: 'DIRECTORY',
+  NODE_TYPE_SYMBOLIC_LINK: 'SYMLINK',
+  NODE_TYPE_META: 'META',
 
+
+  DEFAULT_DIR_PERMISSIONS: 0x1ED, // 755
+  DEFAULT_FILE_PERMISSIONS: 0x1A4, // 644
+  FULL_READ_WRITE_EXEC_PERMISSIONS: 0x1FF, // 777
+  READ_WRITE_PERMISSIONS: 0x1B6, /// 666
+  
   SYMLOOP_MAX: 10,
 
   BINARY_MIME_TYPE: 'application/octet-stream',
@@ -76,5 +82,49 @@ module.exports = {
   ENVIRONMENT: {
     TMP: '/tmp',
     PATH: ''
+  },
+
+  // Duplicate Node's fs.constants
+  fsConstants: {
+    O_RDONLY: 0,
+    O_WRONLY: 1,
+    O_RDWR: 2,
+    S_IFMT: 61440,
+    S_IFREG: 32768,
+    S_IFDIR: 16384,
+    S_IFCHR: 8192,
+    S_IFBLK: 24576,
+    S_IFIFO: 4096,
+    S_IFLNK: 40960,
+    S_IFSOCK: 49152,
+    O_CREAT: 512,
+    O_EXCL: 2048,
+    O_NOCTTY: 131072,
+    O_TRUNC: 1024,
+    O_APPEND: 8,
+    O_DIRECTORY: 1048576,
+    O_NOFOLLOW: 256,
+    O_SYNC: 128,
+    O_DSYNC: 4194304,
+    O_SYMLINK: 2097152,
+    O_NONBLOCK: 4,
+    S_IRWXU: 448,
+    S_IRUSR: 256,
+    S_IWUSR: 128,
+    S_IXUSR: 64,
+    S_IRWXG: 56,
+    S_IRGRP: 32,
+    S_IWGRP: 16,
+    S_IXGRP: 8,
+    S_IRWXO: 7,
+    S_IROTH: 4,
+    S_IWOTH: 2,
+    S_IXOTH: 1,
+    F_OK: 0,
+    R_OK: 4,
+    W_OK: 2,
+    X_OK: 1,
+    UV_FS_COPYFILE_EXCL: 1,
+    COPYFILE_EXCL: 1
   }
 };

src/directory-entry.js

@@ -1,6 +1,6 @@
-var MODE_FILE = require('./constants.js').MODE_FILE;
+var NODE_TYPE_FILE = require('./constants.js').NODE_TYPE_FILE;
 
 module.exports = function DirectoryEntry(id, type) {
   this.id = id;
-  this.type = type || MODE_FILE;
+  this.type = type || NODE_TYPE_FILE;
 };

src/dirent.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const Stats = require('./stats.js');
+
+function Dirent(path, fileNode, devName) {
+  this.constructor = Dirent;
+  Stats.call(this, path, fileNode, devName);
+}
+
+Dirent.prototype = Stats.prototype;
+
+module.exports = Dirent;

src/encoding.js

@@ -1,13 +0,0 @@
-// Adapt encodings to work with Buffer or Uint8Array, they expect the latter
-function decode(buf) {
-  return buf.toString('utf8');
-}
-
-function encode(string) {
-  return new Buffer(string, 'utf8');
-}
-
-module.exports = {
-  encode: encode,
-  decode: decode
-};

src/errors.js

@@ -7,7 +7,7 @@ var errors = {};
   //'0:OK:success',
   //'1:EOF:end of file',
   //'2:EADDRINFO:getaddrinfo error',
-  //'3:EACCES:permission denied',
+  '3:EACCES:permission denied',
   //'4:EAGAIN:resource temporarily unavailable',
   //'5:EADDRINUSE:address already in use',
   //'6:EADDRNOTAVAIL:address not available',

src/filesystem/interface.js

@@ -1,44 +1,111 @@
-var _ = require('../../lib/nodash.js');
+'use strict';
 
-var isNullPath = require('../path.js').isNull;
-var nop = require('../shared.js').nop;
+const { promisify } = require('es6-promisify');
 
-var Constants = require('../constants.js');
-var FILE_SYSTEM_NAME = Constants.FILE_SYSTEM_NAME;
-var FS_FORMAT = Constants.FS_FORMAT;
-var FS_READY = Constants.FS_READY;
-var FS_PENDING = Constants.FS_PENDING;
-var FS_ERROR = Constants.FS_ERROR;
-var FS_NODUPEIDCHECK = Constants.FS_NODUPEIDCHECK;
+const Path = require('../path.js');
 
-var providers = require('../providers/index.js');
+const providers = require('../providers/index.js');
 
-var Shell = require('../shell/shell.js');
-var Intercom = require('../../lib/intercom.js');
-var FSWatcher = require('../fs-watcher.js');
-var Errors = require('../errors.js');
-var defaultGuidFn = require('../shared.js').guid;
+const Shell = require('../shell/shell.js');
+const Intercom = require('../../lib/intercom.js');
+const FSWatcher = require('../fs-watcher.js');
+const Errors = require('../errors.js');
+const {
+  nop,
+  guid: defaultGuidFn
+} = require('../shared.js');
 
-var STDIN = Constants.STDIN;
-var STDOUT = Constants.STDOUT;
-var STDERR = Constants.STDERR;
-var FIRST_DESCRIPTOR = Constants.FIRST_DESCRIPTOR;
+const {
+  fsConstants,
+  FILE_SYSTEM_NAME,
+  FS_FORMAT,
+  FS_READY,
+  FS_PENDING,
+  FS_ERROR,
+  FS_NODUPEIDCHECK,
+  STDIN,
+  STDOUT,
+  STDERR
+} = require('../constants.js');
 
 // The core fs operations live on impl
-var impl = require('./implementation.js');
+const impl = require('./implementation.js');
 
 // node.js supports a calling pattern that leaves off a callback.
 function maybeCallback(callback) {
-  if(typeof callback === "function") {
+  if (typeof callback === 'function') {
     return callback;
   }
-  return function(err) {
-    if(err) {
+  return function (err) {
+    if (err) {
       throw err;
     }
   };
 }
 
+// Default callback that logs an error if passed in
+function defaultCallback(err) {
+  if (err) {
+    /* eslint no-console: 0 */
+    console.error('Filer error: ', err);
+  }
+}
+// Get a path (String) from a file:// URL. Support URL() like objects
+// https://github.com/nodejs/node/blob/968e901aff38a343b1de4addebf79fd8fa991c59/lib/internal/url.js#L1381
+function toPathIfFileURL(fileURLOrPath) {
+  if (!(fileURLOrPath &&
+    fileURLOrPath.protocol &&
+    fileURLOrPath.pathname)) {
+    return fileURLOrPath;
+  }
+
+  if (fileURLOrPath.protocol !== 'file:') {
+    throw new Errors.EINVAL('only file: URLs are supported for paths', fileURLOrPath);
+  }
+
+  const pathname = fileURLOrPath.pathname;
+  for (let n = 0; n < pathname.length; n++) {
+    if (pathname[n] === '%') {
+      const third = pathname.codePointAt(n + 2) | 0x20;
+      if (pathname[n + 1] === '2' && third === 102) {
+        throw new Errors.EINVAL('file: URLs must not include encoded / characters', fileURLOrPath);
+      }
+    }
+  }
+
+  return decodeURIComponent(pathname);
+}
+
+// Allow Buffers for paths. Assumes we want UTF8.
+function toPathIfBuffer(bufferOrPath) {
+  return Buffer.isBuffer(bufferOrPath) ? bufferOrPath.toString() : bufferOrPath;
+}
+
+function validatePath(path, allowRelative) {
+  if (!path) {
+    return new Errors.EINVAL('Path must be a string', path);
+  } else if (Path.isNull(path)) {
+    return new Errors.EINVAL('Path must be a string without null bytes.', path);
+  } else if (!allowRelative && !Path.isAbsolute(path)) {
+    return new Errors.EINVAL('Path must be absolute.', path);
+  }
+}
+
+function processPathArg(args, idx, allowRelative) {
+  let path = args[idx];
+  path = toPathIfFileURL(path);
+  path = toPathIfBuffer(path);
+
+  // Some methods specifically allow for rel paths (eg symlink with srcPath)
+  let err = validatePath(path, allowRelative);
+  if (err) {
+    throw err;
+  }
+
+  // Overwrite path arg with converted and validated path
+  args[idx] = path;
+}
+
 /**
  * FileSystem
  *
@@ -69,16 +136,16 @@ function maybeCallback(callback) {
  */
 function FileSystem(options, callback) {
   options = options || {};
-  callback = callback || nop;
+  callback = callback || defaultCallback;
 
-  var flags = options.flags;
-  var guid = options.guid ? options.guid : defaultGuidFn;
-  var provider = options.provider || new providers.Default(options.name || FILE_SYSTEM_NAME);
+  const flags = options.flags || [];
+  const guid = options.guid ? options.guid : defaultGuidFn;
+  const provider = options.provider || new providers.Default(options.name || FILE_SYSTEM_NAME);
   // If we're given a provider, match its name unless we get an explicit name
-  var name = options.name || provider.name;
-  var forceFormatting = _(flags).contains(FS_FORMAT);
+  const name = options.name || provider.name;
+  const forceFormatting = flags.includes(FS_FORMAT);
 
-  var fs = this;
+  const fs = this;
   fs.readyState = FS_PENDING;
   fs.name = name;
   fs.error = null;
@@ -87,30 +154,25 @@ function FileSystem(options, callback) {
   fs.stdout = STDOUT;
   fs.stderr = STDERR;
 
-  // Safely expose the list of open files and file
-  // descriptor management functions
-  var openFiles = {};
-  var nextDescriptor = FIRST_DESCRIPTOR;
-  Object.defineProperty(this, "openFiles", {
-    get: function() { return openFiles; }
-  });
-  this.allocDescriptor = function(openFileDescription) {
-    var fd = nextDescriptor ++;
-    openFiles[fd] = openFileDescription;
-    return fd;
-  };
-  this.releaseDescriptor = function(fd) {
-    delete openFiles[fd];
-  };
+  // Expose Node's fs.constants to users
+  fs.constants = fsConstants;
+  // Node also forwards the access mode flags onto fs
+  fs.F_OK = fsConstants.F_OK;
+  fs.R_OK = fsConstants.R_OK;
+  fs.W_OK = fsConstants.W_OK;
+  fs.X_OK = fsConstants.X_OK;
+
+  // Expose Shell constructor
+  this.Shell = Shell.bind(undefined, this);
 
   // Safely expose the operation queue
-  var queue = [];
-  this.queueOrRun = function(operation) {
-    var error;
+  let queue = [];
+  this.queueOrRun = function (operation) {
+    let error;
 
-    if(FS_READY == fs.readyState) {
+    if (FS_READY === fs.readyState) {
       operation.call(fs);
-    } else if(FS_ERROR == fs.readyState) {
+    } else if (FS_ERROR === fs.readyState) {
       error = new Errors.EFILESYSTEMERROR('unknown error');
     } else {
       queue.push(operation);
@@ -119,25 +181,25 @@ function FileSystem(options, callback) {
     return error;
   };
   function runQueued() {
-    queue.forEach(function(operation) {
+    queue.forEach(function (operation) {
       operation.call(this);
     }.bind(fs));
     queue = null;
   }
 
   // We support the optional `options` arg from node, but ignore it
-  this.watch = function(filename, options, listener) {
-    if(isNullPath(filename)) {
+  this.watch = function (filename, options, listener) {
+    if (Path.isNull(filename)) {
       throw new Error('Path must be a string without null bytes.');
     }
-    if(typeof options === 'function') {
+    if (typeof options === 'function') {
       listener = options;
       options = {};
     }
     options = options || {};
     listener = listener || nop;
 
-    var watcher = new FSWatcher();
+    const watcher = new FSWatcher();
     watcher.start(filename, false, options.recursive);
     watcher.on('change', listener);
 
@@ -146,24 +208,24 @@ function FileSystem(options, callback) {
 
   // Deal with various approaches to node ID creation
   function wrappedGuidFn(context) {
-    return function(callback) {
+    return function (callback) {
       // Skip the duplicate ID check if asked to
-      if(_(flags).contains(FS_NODUPEIDCHECK)) {
+      if (flags.includes(FS_NODUPEIDCHECK)) {
         callback(null, guid());
         return;
       }
 
       // Otherwise (default) make sure this id is unused first
       function guidWithCheck(callback) {
-        var id = guid();
-        context.getObject(id, function(err, value) {
-          if(err) {
+        const id = guid();
+        context.getObject(id, function (err, value) {
+          if (err) {
             callback(err);
             return;
           }
 
           // If this id is unused, use it, otherwise find another
-          if(!value) {
+          if (!value) {
             callback(null, id);
           } else {
             guidWithCheck(callback);
@@ -177,27 +239,28 @@ function FileSystem(options, callback) {
   // Let other instances (in this or other windows) know about
   // any changes to this fs instance.
   function broadcastChanges(changes) {
-    if(!changes.length) {
+    if (!changes.length) {
       return;
     }
-    var intercom = Intercom.getInstance();
-    changes.forEach(function(change) {
+    const intercom = Intercom.getInstance();
+    changes.forEach(function (change) {
       intercom.emit(change.event, change.path);
     });
   }
 
   // Open file system storage provider
-  provider.open(function(err) {
+  provider.open(function (err) {
     function complete(error) {
       function wrappedContext(methodName) {
-        var context = provider[methodName]();
+        let context = provider[methodName]();
+        context.name = name;
         context.flags = flags;
         context.changes = [];
         context.guid = wrappedGuidFn(context);
 
         // When the context is finished, let the fs deal with any change events
-        context.close = function() {
-          var changes = context.changes;
+        context.close = function () {
+          let changes = context.changes;
           broadcastChanges(changes);
           changes.length = 0;
         };
@@ -210,15 +273,15 @@ function FileSystem(options, callback) {
       // for paths updated during the lifetime of the context). From this
       // point forward we won't call open again, so it's safe to drop it.
       fs.provider = {
-        openReadWriteContext: function() {
+        openReadWriteContext: function () {
           return wrappedContext('getReadWriteContext');
         },
-        openReadOnlyContext: function() {
+        openReadOnlyContext: function () {
           return wrappedContext('getReadOnlyContext');
         }
       };
 
-      if(error) {
+      if (error) {
         fs.readyState = FS_ERROR;
       } else {
         fs.readyState = FS_READY;
@@ -227,18 +290,18 @@ function FileSystem(options, callback) {
       callback(error, fs);
     }
 
-    if(err) {
+    if (err) {
       return complete(err);
     }
 
-    var context = provider.getReadWriteContext();
+    const context = provider.getReadWriteContext();
     context.guid = wrappedGuidFn(context);
 
     // Mount the filesystem, formatting if necessary
-    if(forceFormatting) {
+    if (forceFormatting) {
       // Wipe the storage provider, then write root block
-      context.clear(function(err) {
-        if(err) {
+      context.clear(function (err) {
+        if (err) {
           return complete(err);
         }
         impl.ensureRootDirectory(context, complete);
@@ -248,94 +311,128 @@ function FileSystem(options, callback) {
       impl.ensureRootDirectory(context, complete);
     }
   });
+  FileSystem.prototype.promises = {};
+
+  /**
+   * Public API for FileSystem. All node.js methods that are exposed on fs.promises
+   * include `promise: true`.  We also include our own extra methods, but skip the
+   * fd versions to match node.js, which puts these on a `FileHandle` object.
+   * Any method that deals with path argument(s) also includes the position of
+   * those args in one of `absPathArgs: [...]` or `relPathArgs: [...]`, so they
+   * can be processed and validated before being passed on to the method.
+   */
+  [
+    { name: 'appendFile', promises: true, absPathArgs: [0] },
+    { name: 'access', promises: true, absPathArgs: [0] },
+    { name: 'chown', promises: true, absPathArgs: [0] },
+    { name: 'chmod', promises: true, absPathArgs: [0] },
+    { name: 'close' },
+    // copyFile - https://github.com/filerjs/filer/issues/436
+    { name: 'exists', absPathArgs: [0] },
+    { name: 'fchown' },
+    { name: 'fchmod' },
+    // fdatasync - https://github.com/filerjs/filer/issues/653
+    { name: 'fgetxattr' },
+    { name: 'fremovexattr' },
+    { name: 'fsetxattr' },
+    { name: 'fstat' },
+    { name: 'fsync' },
+    { name: 'ftruncate' },
+    { name: 'futimes' },
+    { name: 'getxattr', promises: true, absPathArgs: [0] },
+    // lchown - https://github.com/filerjs/filer/issues/620
+    // lchmod - https://github.com/filerjs/filer/issues/619
+    { name: 'link', promises: true, absPathArgs: [0, 1] },
+    { name: 'lseek' },
+    { name: 'lstat', promises: true },
+    { name: 'mkdir', promises: true, absPathArgs: [0] },
+    { name: 'mkdtemp', promises: true },
+    { name: 'mknod', promises: true, absPathArgs: [0] },
+    { name: 'open', promises: true, absPathArgs: [0] },
+    { name: 'readdir', promises: true, absPathArgs: [0] },
+    { name: 'read' },
+    { name: 'readFile', promises: true, absPathArgs: [0] },
+    { name: 'readlink', promises: true, absPathArgs: [0] },
+    // realpath - https://github.com/filerjs/filer/issues/85
+    { name: 'removexattr', promises: true, absPathArgs: [0] },
+    { name: 'rename', promises: true, absPathArgs: [0, 1] },
+    { name: 'rmdir', promises: true, absPathArgs: [0] },
+    { name: 'setxattr', promises: true, absPathArgs: [0] },
+    { name: 'stat', promises: true, absPathArgs: [0] },
+    { name: 'symlink', promises: true, relPathArgs: [0], absPathArgs: [1] },
+    { name: 'truncate', promises: true, absPathArgs: [0] },
+    // unwatchFile - https://github.com/filerjs/filer/pull/553
+    { name: 'unlink', promises: true, absPathArgs: [0] },
+    { name: 'utimes', promises: true, absPathArgs: [0] },
+    // watch - implemented above in `this.watch`
+    // watchFile - https://github.com/filerjs/filer/issues/654
+    { name: 'writeFile', promises: true, absPathArgs: [0] },
+    { name: 'write' }
+  ].forEach(function (method) {
+    const methodName = method.name;
+    const shouldPromisify = method.promises === true;
+
+    FileSystem.prototype[methodName] = function () {
+      const fs = this;
+      const args = Array.prototype.slice.call(arguments, 0);
+      const lastArgIndex = args.length - 1;
+
+      // We may or may not get a callback, and since node.js supports
+      // fire-and-forget style fs operations, we have to dance a bit here.
+      const missingCallback = typeof args[lastArgIndex] !== 'function';
+      const callback = maybeCallback(args[lastArgIndex]);
+
+      // Deal with path arguments, validating and normalizing Buffer and file:// URLs
+      if (method.absPathArgs) {
+        method.absPathArgs.forEach(pathArg => processPathArg(args, pathArg, false));
+      }
+      if (method.relPathArgs) {
+        method.relPathArgs.forEach(pathArg => processPathArg(args, pathArg, true));
+      }
+
+      const error = fs.queueOrRun(function () {
+        const context = fs.provider.openReadWriteContext();
+
+        // Fail early if the filesystem is in an error state (e.g.,
+        // provider failed to open.
+        if (FS_ERROR === fs.readyState) {
+          const err = new Errors.EFILESYSTEMERROR('filesystem unavailable, operation canceled');
+          return callback.call(fs, err);
+        }
+
+        // Wrap the callback so we can explicitly close the context
+        function complete() {
+          context.close();
+          callback.apply(fs, arguments);
+        }
+
+        // Either add or replace the callback with our wrapper complete()
+        if (missingCallback) {
+          args.push(complete);
+        } else {
+          args[lastArgIndex] = complete;
+        }
+
+        // Forward this call to the impl's version, using the following
+        // call signature, with complete() as the callback/last-arg now:
+        // fn(fs, context, arg0, arg1, ... , complete);
+        const fnArgs = [context].concat(args);
+        impl[methodName].apply(null, fnArgs);
+      });
+      if (error) {
+        callback(error);
+      }
+    };
+
+    // Add to fs.promises if appropriate
+    if (shouldPromisify) {
+      FileSystem.prototype.promises[methodName] = promisify(FileSystem.prototype[methodName].bind(fs));
+    }
+  });
+
 }
 
 // Expose storage providers on FileSystem constructor
 FileSystem.providers = providers;
 
-/**
- * Public API for FileSystem
- */
-[
-  'open',
-  'close',
-  'mknod',
-  'mkdir',
-  'rmdir',
-  'stat',
-  'fstat',
-  'link',
-  'unlink',
-  'read',
-  'readFile',
-  'write',
-  'writeFile',
-  'appendFile',
-  'exists',
-  'lseek',
-  'readdir',
-  'rename',
-  'readlink',
-  'symlink',
-  'lstat',
-  'truncate',
-  'ftruncate',
-  'utimes',
-  'futimes',
-  'setxattr',
-  'getxattr',
-  'fsetxattr',
-  'fgetxattr',
-  'removexattr',
-  'fremovexattr'
-].forEach(function(methodName) {
-  FileSystem.prototype[methodName] = function() {
-    var fs = this;
-    var args = Array.prototype.slice.call(arguments, 0);
-    var lastArgIndex = args.length - 1;
-
-    // We may or may not get a callback, and since node.js supports
-    // fire-and-forget style fs operations, we have to dance a bit here.
-    var missingCallback = typeof args[lastArgIndex] !== 'function';
-    var callback = maybeCallback(args[lastArgIndex]);
-
-    var error = fs.queueOrRun(function() {
-      var context = fs.provider.openReadWriteContext();
-
-      // Fail early if the filesystem is in an error state (e.g.,
-      // provider failed to open.
-      if(FS_ERROR === fs.readyState) {
-        var err = new Errors.EFILESYSTEMERROR('filesystem unavailable, operation canceled');
-        return callback.call(fs, err);
-      }
-
-      // Wrap the callback so we can explicitly close the context
-      function complete() {
-        context.close();
-        callback.apply(fs, arguments);
-      }
-
-      // Either add or replace the callback with our wrapper complete()
-      if(missingCallback) {
-        args.push(complete);
-      } else {
-        args[lastArgIndex] = complete;
-      }
-
-      // Forward this call to the impl's version, using the following
-      // call signature, with complete() as the callback/last-arg now:
-      // fn(fs, context, arg0, arg1, ... , complete);
-      var fnArgs = [fs, context].concat(args);
-      impl[methodName].apply(null, fnArgs);
-    });
-    if(error) {
-      callback(error);
-    }
-  };
-});
-
-FileSystem.prototype.Shell = function(options) {
-  return new Shell(this, options);
-};
-
 module.exports = FileSystem;

src/fs-watcher.js

@@ -1,6 +1,8 @@
-var EventEmitter = require('../lib/eventemitter.js');
-var Path = require('./path.js');
-var Intercom = require('../lib/intercom.js');
+'using strict';
+
+const EventEmitter = require('../lib/eventemitter.js');
+const Path = require('./path.js');
+const Intercom = require('../lib/intercom.js');
 
 /**
  * FSWatcher based on node.js' FSWatcher
@@ -8,10 +10,10 @@ var Intercom = require('../lib/intercom.js');
  */
 function FSWatcher() {
   EventEmitter.call(this);
-  var self = this;
-  var recursive = false;
-  var recursivePathPrefix;
-  var filename;
+  const self = this;
+  let recursive = false;
+  let recursivePathPrefix;
+  let filename;
 
   function onchange(path) {
     // Watch for exact filename, or parent path when recursive is true.
@@ -46,12 +48,12 @@ function FSWatcher() {
       recursivePathPrefix = filename === '/' ? '/' : filename + '/';
     }
 
-    var intercom = Intercom.getInstance();
+    const intercom = Intercom.getInstance();
     intercom.on('change', onchange);
   };
 
   self.close = function() {
-    var intercom = Intercom.getInstance();
+    const intercom = Intercom.getInstance();
     intercom.off('change', onchange);
     self.removeAllListeners('change');
   };

src/index.js

@@ -1,6 +1,34 @@
-module.exports = {
+let fs = null;
+let Filer = null;
+
+module.exports = Filer = {
   FileSystem: require('./filesystem/interface.js'),
-  Buffer: require('./buffer.js'),
+  Buffer: Buffer,
+  // We previously called this Path, but node calls it path. Do both
   Path: require('./path.js'),
-  Errors: require('./errors.js')
+  path: require('./path.js'),
+  Errors: require('./errors.js'),
+  Shell: require('./shell/shell.js'),
+  /**
+   * @deprecated Importing filer from your webpack config is not recommended.
+   * 
+   * The filer `FilerWebpackPlugin` class is exposed directly. 
+   * 
+   * ```
+   * const { FilerWebpackPlugin } = require('filer/webpack');
+   * ```
+   */
+  FilerWebpackPlugin: require('./webpack-plugin'),
 };
+
+// Add a getter for the `fs` instance, which returns
+// a Filer FileSystem instance, using the default provider/flags.
+Object.defineProperty(Filer, 'fs', {
+  enumerable: true,
+  get() {
+    if(!fs) {
+      fs = new Filer.FileSystem();
+    }
+    return fs;
+  }
+});

src/node.js

@@ -1,53 +1,135 @@
-var MODE_FILE = require('./constants.js').MODE_FILE;
+const {
+  NODE_TYPE_FILE,
+  NODE_TYPE_DIRECTORY,
+  NODE_TYPE_SYMBOLIC_LINK,
+  DEFAULT_FILE_PERMISSIONS,
+  DEFAULT_DIR_PERMISSIONS
+} = require('./constants');
+const {
+  S_IFREG,
+  S_IFDIR,
+  S_IFLNK
+} = require('./constants').fsConstants;
 
-function Node(options) {
-  var now = Date.now();
-
-  this.id = options.id;
-  this.mode = options.mode || MODE_FILE;  // node type (file, directory, etc)
-  this.size = options.size || 0; // size (bytes for files, entries for directories)
-  this.atime = options.atime || now; // access time (will mirror ctime after creation)
-  this.ctime = options.ctime || now; // creation/change time
-  this.mtime = options.mtime || now; // modified time
-  this.flags = options.flags || []; // file flags
-  this.xattrs = options.xattrs || {}; // extended attributes
-  this.nlinks = options.nlinks || 0; // links count
-  this.version = options.version || 0; // node version
-  this.blksize = undefined; // block size
-  this.nblocks = 1; // blocks count
-  this.data = options.data; // id for data object
-}
-
-// Make sure the options object has an id on property,
-// either from caller or one we generate using supplied guid fn.
+/**
+ * Make sure the options object has an id on property,
+ * either from caller or one we generate using supplied guid fn.
+ */
 function ensureID(options, prop, callback) {
   if(options[prop]) {
-    callback(null);
-  } else {
-    options.guid(function(err, id) {
-      options[prop] = id;
-      callback(err);
-    });
+    return callback();
+  }
+
+  options.guid(function(err, id) {
+    if(err) {
+      return callback(err);
+    }
+    options[prop] = id;
+    callback();
+  });
+}
+
+/**
+ * Generate a POSIX mode (integer) for the node type and permissions.
+ * Use default permissions if we aren't passed any.
+ */
+function generateMode(nodeType, modePermissions) {
+  switch(nodeType) {
+  case NODE_TYPE_DIRECTORY:
+    return (modePermissions || DEFAULT_DIR_PERMISSIONS) | S_IFDIR;
+  case NODE_TYPE_SYMBOLIC_LINK:
+    return (modePermissions || DEFAULT_FILE_PERMISSIONS) | S_IFLNK;
+  case NODE_TYPE_FILE:
+    // falls through
+  default:
+    return (modePermissions || DEFAULT_FILE_PERMISSIONS) | S_IFREG;
   }
 }
 
-Node.create = function(options, callback) {
+/**
+ * Common properties for the layout of a Node
+ */
+class Node {
+  constructor(options) {
+    var now = Date.now();
+
+    this.id = options.id;
+    this.data = options.data; // id for data object
+    this.size = options.size || 0; // size (bytes for files, entries for directories)
+    this.atime = options.atime || now; // access time (will mirror ctime after creation)
+    this.ctime = options.ctime || now; // creation/change time
+    this.mtime = options.mtime || now; // modified time
+    this.flags = options.flags || []; // file flags
+    this.xattrs = options.xattrs || {}; // extended attributes
+    this.nlinks = options.nlinks || 0; // links count
+
+    // Historically, Filer's node layout has referred to the
+    // node type as `mode`, and done so using a String.  In
+    // a POSIX filesystem, the mode is a number that combines
+    // both node type and permission bits. Internal we use `type`,
+    // but store it in the database as `mode` for backward
+    // compatibility.
+    if(typeof options.type === 'string') {
+      this.type = options.type;
+    } else if(typeof options.mode === 'string') {
+      this.type = options.mode;
+    } else {
+      this.type = NODE_TYPE_FILE;
+    }
+
+    // Extra mode permissions and ownership info
+    this.permissions = options.permissions || generateMode(this.type);
+    this.uid = options.uid || 0x0; // owner name
+    this.gid = options.gid || 0x0; // group name
+  }
+
+  /**
+   * Serialize a Node to JSON.  Everything is as expected except
+   * that we use `mode` for `type` to maintain backward compatibility.
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      data: this.data,
+      size: this.size,
+      atime: this.atime,
+      ctime: this.ctime,
+      mtime: this.ctime,
+      flags: this.flags,
+      xattrs: this.xattrs,
+      nlinks: this.nlinks,
+      // Use `mode` for `type` to keep backward compatibility
+      mode: this.type,
+      permissions: this.permissions,
+      uid: this.uid,
+      gid: this.gid
+    };
+  }
+
+  // Return complete POSIX `mode` for node type + permissions. See:
+  // http://man7.org/linux/man-pages/man2/chmod.2.html
+  get mode() {
+    return generateMode(this.type, this.permissions);
+  }
+  // When setting the `mode` we assume permissions bits only (not changing type)
+  set mode(value) {
+    this.permissions = value;
+  }
+}
+
+module.exports.create = function create(options, callback) {
   // We expect both options.id and options.data to be provided/generated.
   ensureID(options, 'id', function(err) {
     if(err) {
-      callback(err);
-      return;
+      return callback(err);
     }
 
     ensureID(options, 'data', function(err) {
       if(err) {
-        callback(err);
-        return;
+        return callback(err);
       }
 
       callback(null, new Node(options));
     });
   });
 };
-
-module.exports = Node;

src/open-file-description.js

@@ -1,4 +1,5 @@
-var Errors = require('./errors.js');
+const Errors = require('./errors.js');
+const Node = require('./node');
 
 function OpenFileDescription(path, id, flags, position) {
   this.path = path;
@@ -22,7 +23,7 @@ OpenFileDescription.prototype.getNode = function(context, callback) {
       return callback(new Errors.EBADF('file descriptor refers to unknown node', path));
     }
 
-    callback(null, node);
+    Node.create(node, callback);
   }
 
   context.getObject(id, check_if_node_exists);

src/open-files.js

@@ -0,0 +1,44 @@
+const { FIRST_DESCRIPTOR } = require('./constants');
+const openFiles = {};
+
+/**
+ * Start at FIRST_DESCRIPTOR and go until we find
+ * an empty file descriptor, then return it.
+ */
+const getEmptyDescriptor = () => {
+  let fd = FIRST_DESCRIPTOR;
+
+  while(getOpenFileDescription(fd)) {
+    fd++;
+  }
+
+  return fd;
+};
+
+/**
+ * Look up the open file description object for a given
+ * file descriptor.
+ */
+const getOpenFileDescription = ofd => openFiles[ofd];
+
+/**
+ * Allocate a new file descriptor for the given
+ * open file description. 
+ */
+const allocDescriptor = openFileDescription => {
+  const ofd = getEmptyDescriptor();
+  openFiles[ofd] = openFileDescription;
+  return ofd;
+};
+
+/**
+ * Release the given existing file descriptor created
+ * with allocDescriptor(). 
+ */
+const releaseDescriptor = ofd => delete openFiles[ofd];
+
+module.exports = {
+  allocDescriptor,
+  releaseDescriptor,
+  getOpenFileDescription
+};

src/path.js

@@ -1,224 +1,49 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+/**
+ * Patch process to add process.cwd(), always giving the root dir.
+ * NOTE: this line needs to happen *before* we require in `path`.
+ */
+process.cwd = () => '/';
 
-// Based on https://github.com/joyent/node/blob/41e53e557992a7d552a8e23de035f9463da25c99/lib/path.js
+/**
+ * https://github.com/browserify/path-browserify via Parcel.
+ * We use is as a base for our own Filer.Path, and patch/add
+ * a few things we need for the browser environment.
+ */
+const nodePath = require('path');
+const filerPath = Object.assign({}, nodePath);
 
-// resolves . and .. elements in a path array with directory names there
-// must be no slashes, empty elements, or device names (c:\) in the array
-// (so also no leading and trailing slashes - it does not distinguish
-// relative and absolute paths)
-function normalizeArray(parts, allowAboveRoot) {
-  // if the path tries to go above the root, `up` ends up > 0
-  var up = 0;
-  for (var i = parts.length - 1; i >= 0; i--) {
-    var last = parts[i];
-    if (last === '.') {
-      parts.splice(i, 1);
-    } else if (last === '..') {
-      parts.splice(i, 1);
-      up++;
-    } else if (up) {
-      parts.splice(i, 1);
-      up--;
-    }
-  }
-
-  // if the path is allowed to go above the root, restore leading ..s
-  if (allowAboveRoot) {
-    for (; up--; up) {
-      parts.unshift('..');
-    }
-  }
-
-  return parts;
-}
-
-// Split a filename into [root, dir, basename, ext], unix version
-// 'root' is just a slash, or nothing.
-var splitPathRe =
-      /^(\/?)([\s\S]+\/(?!$)|\/)?((?:\.{1,2}$|[\s\S]+?)?(\.[^.\/]*)?)$/;
-var splitPath = function(filename) {
-  var result = splitPathRe.exec(filename);
-  return [result[1] || '', result[2] || '', result[3] || '', result[4] || ''];
+/**
+ * Patch path.basename() to return / vs. ''
+ */
+filerPath.basename = (path, ext) => {
+  const basename = nodePath.basename(path, ext);
+  return basename === '' ? '/' : basename;
 };
 
-// path.resolve([from ...], to)
-function resolve() {
-  var resolvedPath = '',
-      resolvedAbsolute = false;
-
-  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    // XXXidbfs: we don't have process.cwd() so we use '/' as a fallback
-    var path = (i >= 0) ? arguments[i] : '/';
-
-    // Skip empty and invalid entries
-    if (typeof path !== 'string' || !path) {
-      continue;
-    }
-
-    resolvedPath = path + '/' + resolvedPath;
-    resolvedAbsolute = path.charAt(0) === '/';
-  }
-
-  // At this point the path should be resolved to a full absolute path, but
-  // handle relative paths to be safe (might happen when process.cwd() fails)
-
-  // Normalize the path
-  resolvedPath = normalizeArray(resolvedPath.split('/').filter(function(p) {
-    return !!p;
-  }), !resolvedAbsolute).join('/');
-
-  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
-}
-
-// path.normalize(path)
-function normalize(path) {
-  var isAbsolute = path.charAt(0) === '/',
-      trailingSlash = path.substr(-1) === '/';
-
-  // Normalize the path
-  path = normalizeArray(path.split('/').filter(function(p) {
-    return !!p;
-  }), !isAbsolute).join('/');
-
-  if (!path && !isAbsolute) {
-    path = '.';
-  }
-  /*
-   if (path && trailingSlash) {
-   path += '/';
-   }
-   */
-
-  return (isAbsolute ? '/' : '') + path;
-}
-
-function join() {
-  var paths = Array.prototype.slice.call(arguments, 0);
-  return normalize(paths.filter(function(p, index) {
-    return p && typeof p === 'string';
-  }).join('/'));
-}
-
-// path.relative(from, to)
-function relative(from, to) {
-  from = exports.resolve(from).substr(1);
-  to = exports.resolve(to).substr(1);
-
-  function trim(arr) {
-    var start = 0;
-    for (; start < arr.length; start++) {
-      if (arr[start] !== '') break;
-    }
-
-    var end = arr.length - 1;
-    for (; end >= 0; end--) {
-      if (arr[end] !== '') break;
-    }
-
-    if (start > end) return [];
-    return arr.slice(start, end - start + 1);
-  }
-
-  var fromParts = trim(from.split('/'));
-  var toParts = trim(to.split('/'));
-
-  var length = Math.min(fromParts.length, toParts.length);
-  var samePartsLength = length;
-  for (var i = 0; i < length; i++) {
-    if (fromParts[i] !== toParts[i]) {
-      samePartsLength = i;
-      break;
-    }
-  }
-
-  var outputParts = [];
-  for (var i = samePartsLength; i < fromParts.length; i++) {
-    outputParts.push('..');
-  }
-
-  outputParts = outputParts.concat(toParts.slice(samePartsLength));
-
-  return outputParts.join('/');
-}
-
-function dirname(path) {
-  var result = splitPath(path),
-      root = result[0],
-      dir = result[1];
-
-  if (!root && !dir) {
-    // No dirname whatsoever
-    return '.';
-  }
-
-  if (dir) {
-    // It has a dirname, strip trailing slash
-    dir = dir.substr(0, dir.length - 1);
-  }
-
-  return root + dir;
-}
-
-function basename(path, ext) {
-  var f = splitPath(path)[2];
-  // TODO: make this comparison case-insensitive on windows?
-  if (ext && f.substr(-1 * ext.length) === ext) {
-    f = f.substr(0, f.length - ext.length);
-  }
-  // XXXidbfs: node.js just does `return f`
-  return f === "" ? "/" : f;
-}
-
-function extname(path) {
-  return splitPath(path)[3];
-}
-
-function isAbsolute(path) {
-  if(path.charAt(0) === '/') {
-    return true;
-  }
-  return false;
-}
-
-function isNull(path) {
-  if (('' + path).indexOf('\u0000') !== -1) {
-    return true;
-  }
-  return false;
-}
-
-// XXXidbfs: we don't support path.exists() or path.existsSync(), which
-// are deprecated, and need a FileSystem instance to work. Use fs.stat().
-
-module.exports = {
-  normalize: normalize,
-  resolve: resolve,
-  join: join,
-  relative: relative,
-  sep: '/',
-  delimiter: ':',
-  dirname: dirname,
-  basename: basename,
-  extname: extname,
-  isAbsolute: isAbsolute,
-  isNull: isNull
+/**
+ * Patch path.normalize() to not add a trailing /
+ */
+filerPath.normalize = (path) => {
+  path = nodePath.normalize(path);
+  return path === '/' ? path : filerPath.removeTrailing(path);
 };
+
+/**
+ * Add new utility method isNull() to path: check for null paths.
+ */
+filerPath.isNull = path => ('' + path).indexOf('\u0000') !== -1;
+
+/**
+ * Add new utility method addTrailing() to add trailing / without doubling to //.
+ */
+filerPath.addTrailing = path => path.replace(/\/*$/, '/');
+
+/**
+ * Add new utility method removeTrailing() to remove trailing /, dealing with multiple
+ */
+filerPath.removeTrailing = path => {
+  path = path.replace(/\/*$/, '');
+  return path === '' ? '/' : path;
+};
+
+module.exports = filerPath;

src/providers/index.js

@@ -1,35 +1,8 @@
-var IndexedDB = require('./indexeddb.js');
-var WebSQL = require('./websql.js');
-var Memory = require('./memory.js');
+const IndexedDB = require('./indexeddb.js');
+const Memory = require('./memory.js');
 
 module.exports = {
   IndexedDB: IndexedDB,
-  WebSQL: WebSQL,
-  Memory: Memory,
-
-  /**
-   * Convenience Provider references
-   */
-
-  // The default provider to use when none is specified
   Default: IndexedDB,
-
-  // The Fallback provider does automatic fallback checks
-  Fallback: (function() {
-    if(IndexedDB.isSupported()) {
-      return IndexedDB;
-    }
-
-    if(WebSQL.isSupported()) {
-      return WebSQL;
-    }
-
-    function NotSupported() {
-      throw "[Filer Error] Your browser doesn't support IndexedDB or WebSQL.";
-    }
-    NotSupported.isSupported = function() {
-      return false;
-    };
-    return NotSupported;
-  }())
+  Memory: Memory
 };

src/providers/indexeddb.js

@@ -2,98 +2,104 @@ var FILE_SYSTEM_NAME = require('../constants.js').FILE_SYSTEM_NAME;
 var FILE_STORE_NAME = require('../constants.js').FILE_STORE_NAME;
 var IDB_RW = require('../constants.js').IDB_RW;
 var IDB_RO = require('../constants.js').IDB_RO;
-var Errors = require('../errors.js');
-var FilerBuffer = require('../buffer.js');
-
-var indexedDB = global.indexedDB       ||
-                global.mozIndexedDB    ||
-                global.webkitIndexedDB ||
-                global.msIndexedDB;
 
 function IndexedDBContext(db, mode) {
-  var transaction = db.transaction(FILE_STORE_NAME, mode);
-  this.objectStore = transaction.objectStore(FILE_STORE_NAME);
+  this.db = db;
+  this.mode = mode;
 }
 
+IndexedDBContext.prototype._getObjectStore = function() {
+  if(this.objectStore) {
+    return this.objectStore;
+  }
+
+  var transaction = this.db.transaction(FILE_STORE_NAME, this.mode);
+  this.objectStore = transaction.objectStore(FILE_STORE_NAME);
+  return this.objectStore;
+};
+
 IndexedDBContext.prototype.clear = function(callback) {
   try {
-    var request = this.objectStore.clear();
-    request.onsuccess = function(event) {
+    var objectStore = this._getObjectStore();
+    var request = objectStore.clear();
+    request.onsuccess = function() {
       callback();
     };
-    request.onerror = function(error) {
-      callback(error);
+    request.onerror = function(event) {
+      event.preventDefault();
+      callback(event.error);
     };
-  } catch(e) {
-    callback(e);
+  } catch(err) {
+    callback(err);
   }
 };
 
-function _get(objectStore, key, callback) {
+IndexedDBContext.prototype._get = function(key, callback) {
   try {
+    var objectStore = this._getObjectStore();
     var request = objectStore.get(key);
     request.onsuccess = function onsuccess(event) {
       var result = event.target.result;
       callback(null, result);
     };
-    request.onerror = function onerror(error) {
-      callback(error);
+    request.onerror = function(event) {
+      event.preventDefault();
+      callback(event.error);
     };
-  } catch(e) {
-    callback(e);
+  } catch(err) {
+    callback(err);
   }
-}
+};
 IndexedDBContext.prototype.getObject = function(key, callback) {
-  _get(this.objectStore, key, callback);
+  this._get(key, callback);
 };
 IndexedDBContext.prototype.getBuffer = function(key, callback) {
-  _get(this.objectStore, key, function(err, arrayBuffer) {
+  this._get(key, function(err, arrayBuffer) {
     if(err) {
       return callback(err);
     }
-    callback(null, new FilerBuffer(arrayBuffer));
+    callback(null, Buffer.from(arrayBuffer));
   });
 };
 
-function _put(objectStore, key, value, callback) {
+IndexedDBContext.prototype._put = function(key, value, callback) {
   try {
+    var objectStore = this._getObjectStore();
     var request = objectStore.put(value, key);
     request.onsuccess = function onsuccess(event) {
       var result = event.target.result;
       callback(null, result);
     };
-    request.onerror = function onerror(error) {
-      callback(error);
+    request.onerror = function(event) {
+      event.preventDefault();
+      callback(event.error);
     };
-  } catch(e) {
-    callback(e);
+  } catch(err) {
+    callback(err);
   }
-}
+};
 IndexedDBContext.prototype.putObject = function(key, value, callback) {
-  _put(this.objectStore, key, value, callback);
+  this._put(key, value, callback);
 };
 IndexedDBContext.prototype.putBuffer = function(key, uint8BackedBuffer, callback) {
-  var buf;
-  if(!Buffer._useTypedArrays) { // workaround for fxos 1.3
-    buf = uint8BackedBuffer.toArrayBuffer();
-  } else {
-    buf = uint8BackedBuffer.buffer;
-  }
-  _put(this.objectStore, key, buf, callback);
+  var buf = uint8BackedBuffer.buffer;
+  this._put(key, buf, callback);
 };
 
 IndexedDBContext.prototype.delete = function(key, callback) {
   try {
-    var request = this.objectStore.delete(key);
+    var objectStore = this._getObjectStore();
+    var request = objectStore.delete(key);
     request.onsuccess = function onsuccess(event) {
       var result = event.target.result;
       callback(null, result);
     };
-    request.onerror = function(error) {
-      callback(error);
+    request.onerror = function(event) {
+      event.preventDefault();
+      callback(event.error);
     };
-  } catch(e) {
-    callback(e);
+  } catch(err) {
+    callback(err);
   }
 };
 
@@ -103,6 +109,10 @@ function IndexedDB(name) {
   this.db = null;
 }
 IndexedDB.isSupported = function() {
+  var indexedDB = global.indexedDB       ||
+                  global.mozIndexedDB    ||
+                  global.webkitIndexedDB ||
+                  global.msIndexedDB;
   return !!indexedDB;
 };
 
@@ -114,32 +124,40 @@ IndexedDB.prototype.open = function(callback) {
     return callback();
   }
 
-  // NOTE: we're not using versioned databases.
-  var openRequest = indexedDB.open(that.name);
+  try {
+    var indexedDB = global.indexedDB       ||
+                    global.mozIndexedDB    ||
+                    global.webkitIndexedDB ||
+                    global.msIndexedDB;
 
-  // If the db doesn't exist, we'll create it
-  openRequest.onupgradeneeded = function onupgradeneeded(event) {
-    var db = event.target.result;
+    // NOTE: we're not using versioned databases.
+    var openRequest = indexedDB.open(that.name);
 
-    if(db.objectStoreNames.contains(FILE_STORE_NAME)) {
-      db.deleteObjectStore(FILE_STORE_NAME);
-    }
-    db.createObjectStore(FILE_STORE_NAME);
-  };
+    // If the db doesn't exist, we'll create it
+    openRequest.onupgradeneeded = function onupgradeneeded(event) {
+      var db = event.target.result;
 
-  openRequest.onsuccess = function onsuccess(event) {
-    that.db = event.target.result;
-    callback();
-  };
-  openRequest.onerror = function onerror(error) {
-    callback(new Errors.EINVAL('IndexedDB cannot be accessed. If private browsing is enabled, disable it.'));
-  };
+      if(db.objectStoreNames.contains(FILE_STORE_NAME)) {
+        db.deleteObjectStore(FILE_STORE_NAME);
+      }
+      db.createObjectStore(FILE_STORE_NAME);
+    };
+
+    openRequest.onsuccess = function onsuccess(event) {
+      that.db = event.target.result;
+      callback();
+    };
+    openRequest.onerror = function onerror(event) {
+      event.preventDefault();
+      callback(event.error);
+    };
+  } catch(err) {
+    callback(err);
+  }
 };
+
 IndexedDB.prototype.getReadOnlyContext = function() {
-  // Due to timing issues in Chrome with readwrite vs. readonly indexeddb transactions
-  // always use readwrite so we can make sure pending commits finish before callbacks.
-  // See https://github.com/js-platform/filer/issues/128
-  return new IndexedDBContext(this.db, IDB_RW);
+  return new IndexedDBContext(this.db, IDB_RO);
 };
 IndexedDB.prototype.getReadWriteContext = function() {
   return new IndexedDBContext(this.db, IDB_RW);

src/providers/memory.js

@@ -9,7 +9,7 @@ var asyncCallback = require('../../lib/async.js').setImmediate;
 var createDB = (function() {
   var pool = {};
   return function getOrCreate(name) {
-    if(!pool.hasOwnProperty(name)) {
+    if(!Object.prototype.hasOwnProperty.call(pool, name)) {
       pool[name] = {};
     }
     return pool[name];
@@ -24,7 +24,7 @@ function MemoryContext(db, readOnly) {
 MemoryContext.prototype.clear = function(callback) {
   if(this.readOnly) {
     asyncCallback(function() {
-      callback("[MemoryContext] Error: write operation on read only context");
+      callback('[MemoryContext] Error: write operation on read only context');
     });
     return;
   }
@@ -49,7 +49,7 @@ MemoryContext.prototype.putBuffer =
 function(key, value, callback) {
   if(this.readOnly) {
     asyncCallback(function() {
-      callback("[MemoryContext] Error: write operation on read only context");
+      callback('[MemoryContext] Error: write operation on read only context');
     });
     return;
   }
@@ -60,7 +60,7 @@ function(key, value, callback) {
 MemoryContext.prototype.delete = function(key, callback) {
   if(this.readOnly) {
     asyncCallback(function() {
-      callback("[MemoryContext] Error: write operation on read only context");
+      callback('[MemoryContext] Error: write operation on read only context');
     });
     return;
   }

src/providers/websql.js

@@ -1,171 +0,0 @@
-var FILE_SYSTEM_NAME = require('../constants.js').FILE_SYSTEM_NAME;
-var FILE_STORE_NAME = require('../constants.js').FILE_STORE_NAME;
-var WSQL_VERSION = require('../constants.js').WSQL_VERSION;
-var WSQL_SIZE = require('../constants.js').WSQL_SIZE;
-var WSQL_DESC = require('../constants.js').WSQL_DESC;
-var Errors = require('../errors.js');
-var FilerBuffer = require('../buffer.js');
-var base64ArrayBuffer = require('base64-arraybuffer');
-
-function WebSQLContext(db, isReadOnly) {
-  var that = this;
-  this.getTransaction = function(callback) {
-    if(that.transaction) {
-      callback(that.transaction);
-      return;
-    }
-    // Either do readTransaction() (read-only) or transaction() (read/write)
-    db[isReadOnly ? 'readTransaction' : 'transaction'](function(transaction) {
-      that.transaction = transaction;
-      callback(transaction);
-    });
-  };
-}
-
-WebSQLContext.prototype.clear = function(callback) {
-  function onError(transaction, error) {
-    callback(error);
-  }
-  function onSuccess(transaction, result) {
-    callback(null);
-  }
-  this.getTransaction(function(transaction) {
-    transaction.executeSql("DELETE FROM " + FILE_STORE_NAME + ";",
-                           [], onSuccess, onError);
-  });
-};
-
-function _get(getTransaction, key, callback) {
-  function onSuccess(transaction, result) {
-    // If the key isn't found, return null
-    var value = result.rows.length === 0 ? null : result.rows.item(0).data;
-    callback(null, value);
-  }
-  function onError(transaction, error) {
-    callback(error);
-  }
-  getTransaction(function(transaction) {
-    transaction.executeSql("SELECT data FROM " + FILE_STORE_NAME + " WHERE id = ? LIMIT 1;",
-                           [key], onSuccess, onError);
-  });
-}
-WebSQLContext.prototype.getObject = function(key, callback) {
-  _get(this.getTransaction, key, function(err, result) {
-    if(err) {
-      return callback(err);
-    }
-
-    try {
-      if(result) {
-        result = JSON.parse(result);
-      }
-    } catch(e) {
-      return callback(e);
-    }
-
-    callback(null, result);
-  });
-};
-WebSQLContext.prototype.getBuffer = function(key, callback) {
-  _get(this.getTransaction, key, function(err, result) {
-    if(err) {
-      return callback(err);
-    }
-
-    // Deal with zero-length ArrayBuffers, which will be encoded as ''
-    if(result || result === '') {
-      var arrayBuffer = base64ArrayBuffer.decode(result);
-      result = new FilerBuffer(arrayBuffer);
-    }
-
-    callback(null, result);
-  });
-};
-
-function _put(getTransaction, key, value, callback) {
-  function onSuccess(transaction, result) {
-    callback(null);
-  }
-  function onError(transaction, error) {
-    callback(error);
-  }
-  getTransaction(function(transaction) {
-    transaction.executeSql("INSERT OR REPLACE INTO " + FILE_STORE_NAME + " (id, data) VALUES (?, ?);",
-                           [key, value], onSuccess, onError);
-  });
-}
-WebSQLContext.prototype.putObject = function(key, value, callback) {
-  var json = JSON.stringify(value);
-  _put(this.getTransaction, key, json, callback);
-};
-WebSQLContext.prototype.putBuffer = function(key, uint8BackedBuffer, callback) {
-  var base64 = base64ArrayBuffer.encode(uint8BackedBuffer.buffer);
-  _put(this.getTransaction, key, base64, callback);
-};
-
-WebSQLContext.prototype.delete = function(key, callback) {
-  function onSuccess(transaction, result) {
-    callback(null);
-  }
-  function onError(transaction, error) {
-    callback(error);
-  }
-  this.getTransaction(function(transaction) {
-    transaction.executeSql("DELETE FROM " + FILE_STORE_NAME + " WHERE id = ?;",
-                           [key], onSuccess, onError);
-  });
-};
-
-
-function WebSQL(name) {
-  this.name = name || FILE_SYSTEM_NAME;
-  this.db = null;
-}
-WebSQL.isSupported = function() {
-  return !!global.openDatabase;
-};
-
-WebSQL.prototype.open = function(callback) {
-  var that = this;
-
-  // Bail if we already have a db open
-  if(that.db) {
-    return callback();
-  }
-
-  var db = global.openDatabase(that.name, WSQL_VERSION, WSQL_DESC, WSQL_SIZE);
-  if(!db) {
-    callback("[WebSQL] Unable to open database.");
-    return;
-  }
-
-  function onError(transaction, error) {
-    if (error.code === 5) {
-      callback(new Errors.EINVAL('WebSQL cannot be accessed. If private browsing is enabled, disable it.'));
-    }
-    callback(error);
-  }
-  function onSuccess(transaction, result) {
-    that.db = db;
-    callback();
-  }
-
-  // Create the table and index we'll need to store the fs data.
-  db.transaction(function(transaction) {
-    function createIndex(transaction) {
-      transaction.executeSql("CREATE INDEX IF NOT EXISTS idx_" + FILE_STORE_NAME + "_id" +
-                             " on " + FILE_STORE_NAME + " (id);",
-                             [], onSuccess, onError);
-    }
-    transaction.executeSql("CREATE TABLE IF NOT EXISTS " + FILE_STORE_NAME + " (id unique, data TEXT);",
-                           [], createIndex, onError);
-  });
-};
-WebSQL.prototype.getReadOnlyContext = function() {
-  return new WebSQLContext(this.db, true);
-};
-WebSQL.prototype.getReadWriteContext = function() {
-  return new WebSQLContext(this.db, false);
-};
-
-module.exports = WebSQL;

src/shared.js

@@ -1,26 +1,27 @@
-function guid() {
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
-    var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
+function generateRandom(template) {
+  return template.replace(/[xy]/g, function(c) {
+    var r = Math.random()*16|0, v = c === 'x' ? r : (r&0x3|0x8);
     return v.toString(16);
-  }).toUpperCase();
+  });
+}
+
+function guid() {
+  return generateRandom('xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx').toUpperCase();
+}
+
+/**
+ * Generate a string of n random characters.  Defaults to n=6.
+ */ 
+function randomChars(n) {
+  n = n || 6;
+  var template = 'x'.repeat(n);
+  return generateRandom(template);
 }
 
 function nop() {}
 
-/**
- * Convert a Uint8Array to a regular array
- */
-function u8toArray(u8) {
-  var array = [];
-  var len = u8.length;
-  for(var i = 0; i < len; i++) {
-    array[i] = u8[i];
-  }
-  return array;
-}
-
 module.exports = {
   guid: guid,
-  u8toArray: u8toArray,
-  nop: nop
+  nop: nop,
+  randomChars: randomChars
 };

src/shell/environment.js

@@ -1,4 +1,5 @@
-var defaults = require('../constants.js').ENVIRONMENT;
+'use strict'; 
+const defaults = require('../constants.js').ENVIRONMENT;
 
 module.exports = function Environment(env) {
   env = env || {};

src/shell/shell.js

@@ -1,8 +1,9 @@
+var {promisify} = require('es6-promisify');
 var Path = require('../path.js');
 var Errors = require('../errors.js');
 var Environment = require('./environment.js');
 var async = require('../../lib/async.js');
-var Encoding = require('../encoding.js');
+var minimatch = require('minimatch');
 
 function Shell(fs, options) {
   options = options || {};
@@ -56,6 +57,24 @@ function Shell(fs, options) {
   this.pwd = function() {
     return cwd;
   };
+
+  this.promises = {};
+  /**
+  * Public API for Shell converted to Promise based
+  */
+  [
+    'cd',
+    'exec',
+    'touch',
+    'cat',
+    'ls',
+    'rm',
+    'tempDir',
+    'mkdirp',
+    'find'
+  ].forEach((methodName)=>{
+    this.promises[methodName] = promisify(this[methodName].bind(this));
+  });
 }
 
 /**
@@ -86,7 +105,7 @@ Shell.prototype.exec = function(path, args, callback) {
   callback = callback || function(){};
   path = Path.resolve(sh.pwd(), path);
 
-  fs.readFile(path, "utf8", function(error, data) {
+  fs.readFile(path, 'utf8', function(error, data) {
     if(error) {
       callback(error);
       return;
@@ -130,7 +149,7 @@ Shell.prototype.touch = function(path, options, callback) {
     fs.utimes(path, atime, mtime, callback);
   }
 
-  fs.stat(path, function(error, stats) {
+  fs.stat(path, function(error) {
     if(error) {
       if(options.updateOnly === true) {
         callback();
@@ -232,16 +251,10 @@ Shell.prototype.ls = function(dir, options, callback) {
             callback(error);
             return;
           }
-          var entry = {
-            path: Path.basename(name),
-            links: stats.nlinks,
-            size: stats.size,
-            modified: stats.mtime,
-            type: stats.type
-          };
+          var entry = stats;
 
           if(options.recursive && stats.type === 'DIRECTORY') {
-            list(Path.join(pathname, entry.path), function(error, items) {
+            list(Path.join(pathname, entry.name), function(error, items) {
               if(error) {
                 callback(error);
                 return;
@@ -353,7 +366,7 @@ Shell.prototype.tempDir = function(callback) {
 
   // Try and create it, and it will either work or fail
   // but either way it's now there.
-  fs.mkdir(tmp, function(err) {
+  fs.mkdir(tmp, function() {
     callback(null, tmp);
   });
 };
@@ -374,7 +387,8 @@ Shell.prototype.mkdirp = function(path, callback) {
     callback(new Errors.EINVAL('Missing path argument'));
     return;
   }
-  else if (path === '/') {
+  path = Path.resolve(sh.pwd(), path);
+  if (path === '/') {
     callback();
     return;
   }
@@ -398,7 +412,7 @@ Shell.prototype.mkdirp = function(path, callback) {
         var parent = Path.dirname(path);
         if(parent === '/') {
           fs.mkdir(path, function (err) {
-            if (err && err.code != 'EEXIST') {
+            if (err && err.code !== 'EEXIST') {
               callback(err);
               return;
             }
@@ -410,7 +424,7 @@ Shell.prototype.mkdirp = function(path, callback) {
           _mkdirp(parent, function (err) {
             if (err) return callback(err);
             fs.mkdir(path, function (err) {
-              if (err && err.code != 'EEXIST') {
+              if (err && err.code !== 'EEXIST') {
                 callback(err);
                 return;
               }
@@ -426,4 +440,120 @@ Shell.prototype.mkdirp = function(path, callback) {
   _mkdirp(path, callback);
 };
 
+/**
+ * Recursively walk a directory tree, reporting back all paths
+ * that were found along the way. The `path` must be a dir.
+ * Valid options include a `regex` for pattern matching paths
+ * and an `exec` function of the form `function(path, next)` where
+ * `path` is the current path that was found (dir paths have an '/'
+ * appended) and `next` is a callback to call when done processing
+ * the current path, passing any error object back as the first argument.
+ * `find` returns a flat array of absolute paths for all matching/found
+ * paths as the final argument to the callback.
+ */
+Shell.prototype.find = function(path, options, callback) {
+  var sh = this;
+  var fs = sh.fs;
+  if(typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  options = options || {};
+  callback = callback || function(){};
+
+  var exec = options.exec || function(path, next) { next(); };
+  var found = [];
+
+  if(!path) {
+    callback(new Errors.EINVAL('Missing path argument'));
+    return;
+  }
+
+  function processPath(path, callback) {
+    exec(path, function(err) {
+      if(err) {
+        callback(err);
+        return;
+      }
+
+      found.push(path);
+      callback();
+    });
+  }
+
+  function maybeProcessPath(path, callback) {
+    // Test the path against the user's regex, name, path primaries (if any)
+    // and remove any trailing slashes added previously.
+    var rawPath = Path.removeTrailing(path);
+
+    // Check entire path against provided regex, if any
+    if(options.regex && !options.regex.test(rawPath)) {
+      callback();
+      return;
+    }
+
+    // Check basename for matches against name primary, if any
+    if(options.name && !minimatch(Path.basename(rawPath), options.name)) {
+      callback();
+      return;
+    }
+
+    // Check dirname for matches against path primary, if any
+    if(options.path && !minimatch(Path.dirname(rawPath), options.path)) {
+      callback();
+      return;
+    }
+
+    processPath(path, callback);
+  }
+
+  function walk(path, callback) {
+    path = Path.resolve(sh.pwd(), path);
+
+    // The path is either a file or dir, and instead of doing
+    // a stat() to determine it first, we just try to readdir()
+    // and it will either work or not, and we handle the non-dir error.
+    fs.readdir(path, function(err, entries) {
+      if(err) {
+        if(err.code === 'ENOTDIR' /* file case, ignore error */) {
+          maybeProcessPath(path, callback);
+        } else {
+          callback(err);
+        }
+        return;
+      }
+
+      // Path is really a dir, add a trailing / and report it found
+      maybeProcessPath(Path.addTrailing(path), function(err) {
+        if(err) {
+          callback(err);
+          return;
+        }
+
+        entries = entries.map(function(entry) {
+          return Path.join(path, entry);
+        });
+
+        async.eachSeries(entries, walk, function(err) {
+          callback(err, found);
+        });
+      });
+    });
+  }
+
+  // Make sure we are starting with a dir path
+  fs.stat(path, function(err, stats) {
+    if(err) {
+      callback(err);
+      return;
+    }
+    if(!stats.isDirectory()) {
+      callback(new Errors.ENOTDIR(null, path));
+      return;
+    }
+
+    walk(path, callback);
+  });
+};
+
 module.exports = Shell;

src/stats.js

@@ -1,26 +1,43 @@
-var Constants = require('./constants.js');
+'use strict';
 
-function Stats(fileNode, devName) {
-  this.node = fileNode.id;
+const Constants = require('./constants.js');
+const Path = require('./path.js');
+
+function dateFromMs(ms) {
+  return new Date(Number(ms));
+}
+
+function Stats(path, fileNode, devName) {
   this.dev = devName;
+  this.node = fileNode.id;
+  this.type = fileNode.type;
   this.size = fileNode.size;
   this.nlinks = fileNode.nlinks;
-  this.atime = fileNode.atime;
-  this.mtime = fileNode.mtime;
-  this.ctime = fileNode.ctime;
-  this.type = fileNode.mode;
+  // Date objects
+  this.atime = dateFromMs(fileNode.atime);
+  this.mtime = dateFromMs(fileNode.mtime);
+  this.ctime = dateFromMs(fileNode.ctime);
+  // Unix timestamp MS Numbers
+  this.atimeMs = fileNode.atime;
+  this.mtimeMs = fileNode.mtime;
+  this.ctimeMs = fileNode.ctime;
+  this.version = fileNode.version;
+  this.mode = fileNode.mode;
+  this.uid = fileNode.uid;
+  this.gid = fileNode.gid;
+  this.name = Path.basename(path);
 }
 
 Stats.prototype.isFile = function() {
-  return this.type === Constants.MODE_FILE;
+  return this.type === Constants.NODE_TYPE_FILE;
 };
 
 Stats.prototype.isDirectory = function() {
-  return this.type === Constants.MODE_DIRECTORY;
+  return this.type === Constants.NODE_TYPE_DIRECTORY;
 };
 
 Stats.prototype.isSymbolicLink = function() {
-  return this.type === Constants.MODE_SYMBOLIC_LINK;
+  return this.type === Constants.NODE_TYPE_SYMBOLIC_LINK;
 };
 
 // These will always be false in Filer.

src/super-node.js

@@ -4,7 +4,7 @@ function SuperNode(options) {
   var now = Date.now();
 
   this.id = Constants.SUPER_NODE_ID;
-  this.mode = Constants.MODE_META;
+  this.type = Constants.NODE_TYPE_META;
   this.atime = options.atime || now;
   this.ctime = options.ctime || now;
   this.mtime = options.mtime || now;

src/webpack-plugin/index.js

@@ -0,0 +1,81 @@
+var path = require('path');
+var utils = require('./utils');
+
+const PLUGIN_NAME = 'filer-webpack-plugin';
+
+const OPTIONS_SCHEMA = require('./schema');
+const OPTIONS_PROCESSORS = require('./processors');
+
+module.exports = class FilerWebpackPlugin {
+
+  constructor(options = {}) {
+    utils.validateOptions(options, OPTIONS_SCHEMA);
+    this.options = utils.processOptions(options, OPTIONS_PROCESSORS);
+  }
+
+  apply(compiler) {
+    compiler.hooks.normalModuleFactory.tap(
+      PLUGIN_NAME,
+      (factory) => {
+        factory.hooks.resolve.tap(
+          PLUGIN_NAME,
+          (resolveData) => {
+            // Resolve fsProvider if required
+            if (
+              resolveData.request === 'fsProvider'
+              && resolveData.context === this.options.shimsDir
+            ) {
+              return this.resolveFsProvider(resolveData);
+            }
+
+            // Ignore filer files (these should resolve modules normally)
+            if (resolveData.context.startsWith(this.options.filerDir)) return;
+
+            // Apply fs, path and buffer shims if required
+            switch (resolveData.request) {
+            case 'fs':
+              if (!this.options.shimFs) return;
+              return this.applyFsShim(resolveData);
+            case 'path':
+              if (!this.options.shimPath) return;
+              return this.applyPathShim(resolveData);
+            default:
+              return;
+            }
+          }
+        );
+      },
+    );
+  }
+
+  resolveFsProvider(resolveData) {
+    switch (this.options.fsProvider) {
+    case 'default':
+      resolveData.request = path.join(this.options.fsProviderDir, 'default.js');
+      break;
+    case 'indexeddb':
+      resolveData.request = path.join(this.options.fsProviderDir, 'indexeddb.js');
+      break;
+    case 'memory':
+      resolveData.request = path.join(this.options.fsProviderDir, 'memory.js');
+      break;
+    case 'custom':
+      resolveData.request = path.join(this.options.fsProviderDir, 'custom.js');
+      break;
+    default:
+      throw new Error([
+        'Invalid option for fsProvider.',
+        'fsProvider must be one of \'default\', \'indexeddb\', \'memory\' or \'custom\'.',
+        'If using a custom fsProvider, you must also provide the fsProviderDir option.'
+      ].join(' '));
+    }
+  }
+
+  applyFsShim(resolveData) {
+    resolveData.request = path.join(this.options.shimsDir, 'fs.js');
+  }
+    
+  applyPathShim(resolveData) {
+    resolveData.request = path.join(this.options.shimsDir, 'path.js');
+  }
+};

src/webpack-plugin/processors.js

@@ -0,0 +1,34 @@
+var path = require('path');
+
+const ROOT_DIR_TAG = '<rootDir>';
+const CWD = process.cwd();
+
+module.exports = {
+  filerDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    },
+  },
+  shimsDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer', 'shims');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    }
+  },
+  fsProviderDir: {
+    process: function(value) {
+      if (!value) {
+        return path.join(CWD, 'node_modules', 'filer', 'shims', 'providers');
+      }
+      return path.resolve(value.replace(ROOT_DIR_TAG, CWD));
+    },
+  },
+  shimFs: { default: true },
+  shimPath: { default: true},
+  fsProvider: { default: 'default'},
+};

src/webpack-plugin/schema.js

@@ -0,0 +1,23 @@
+module.exports = {
+  type: 'object',
+  properties: {
+    filerDir: {
+      type: 'string',
+    },
+    shimsDir: {
+      type: 'string',
+    },
+    shimFs: {
+      type: 'boolean',
+    },
+    shimPath: {
+      type: 'boolean',
+    },
+    fsProvider: {
+      type: 'string',
+    },
+    fsProviderDir: {
+      type: 'string',
+    },
+  }
+};

src/webpack-plugin/utils.js

@@ -0,0 +1,26 @@
+var { validate } = require('schema-utils');
+
+function validateOptions(options, schema) {
+  validate(schema, options);
+}
+
+function processOptions(options, processors) {
+  const processedOptions = {};
+    
+  for (const [property, processor] of Object.entries(processors)) {
+    processedOptions[property] = options[property];
+    if (processedOptions[property] === undefined) {
+      processedOptions[property] = processor.default;
+    }
+    if (processor.process) {
+      processedOptions[property] = processor.process(processedOptions[property]);
+    }
+  }
+
+  return processedOptions;
+}
+
+module.exports = {
+  validateOptions,
+  processOptions,
+};

stylesheets/pygment_trac.css

@@ -1,70 +0,0 @@
-.highlight .hll { background-color: #ffffcc }
-.highlight  { background: #f0f3f3; }
-.highlight .c { color: #0099FF; font-style: italic } /* Comment */
-.highlight .err { color: #AA0000; background-color: #FFAAAA } /* Error */
-.highlight .k { color: #006699; font-weight: bold } /* Keyword */
-.highlight .o { color: #555555 } /* Operator */
-.highlight .cm { color: #0099FF; font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: #009999 } /* Comment.Preproc */
-.highlight .c1 { color: #0099FF; font-style: italic } /* Comment.Single */
-.highlight .cs { color: #0099FF; font-weight: bold; font-style: italic } /* Comment.Special */
-.highlight .gd { background-color: #FFCCCC; border: 1px solid #CC0000 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gr { color: #FF0000 } /* Generic.Error */
-.highlight .gh { color: #003300; font-weight: bold } /* Generic.Heading */
-.highlight .gi { background-color: #CCFFCC; border: 1px solid #00CC00 } /* Generic.Inserted */
-.highlight .go { color: #AAAAAA } /* Generic.Output */
-.highlight .gp { color: #000099; font-weight: bold } /* Generic.Prompt */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #003300; font-weight: bold } /* Generic.Subheading */
-.highlight .gt { color: #99CC66 } /* Generic.Traceback */
-.highlight .kc { color: #006699; font-weight: bold } /* Keyword.Constant */
-.highlight .kd { color: #006699; font-weight: bold } /* Keyword.Declaration */
-.highlight .kn { color: #006699; font-weight: bold } /* Keyword.Namespace */
-.highlight .kp { color: #006699 } /* Keyword.Pseudo */
-.highlight .kr { color: #006699; font-weight: bold } /* Keyword.Reserved */
-.highlight .kt { color: #007788; font-weight: bold } /* Keyword.Type */
-.highlight .m { color: #FF6600 } /* Literal.Number */
-.highlight .s { color: #CC3300 } /* Literal.String */
-.highlight .na { color: #330099 } /* Name.Attribute */
-.highlight .nb { color: #336666 } /* Name.Builtin */
-.highlight .nc { color: #00AA88; font-weight: bold } /* Name.Class */
-.highlight .no { color: #336600 } /* Name.Constant */
-.highlight .nd { color: #9999FF } /* Name.Decorator */
-.highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */
-.highlight .ne { color: #CC0000; font-weight: bold } /* Name.Exception */
-.highlight .nf { color: #CC00FF } /* Name.Function */
-.highlight .nl { color: #9999FF } /* Name.Label */
-.highlight .nn { color: #00CCFF; font-weight: bold } /* Name.Namespace */
-.highlight .nt { color: #330099; font-weight: bold } /* Name.Tag */
-.highlight .nv { color: #003333 } /* Name.Variable */
-.highlight .ow { color: #000000; font-weight: bold } /* Operator.Word */
-.highlight .w { color: #bbbbbb } /* Text.Whitespace */
-.highlight .mf { color: #FF6600 } /* Literal.Number.Float */
-.highlight .mh { color: #FF6600 } /* Literal.Number.Hex */
-.highlight .mi { color: #FF6600 } /* Literal.Number.Integer */
-.highlight .mo { color: #FF6600 } /* Literal.Number.Oct */
-.highlight .sb { color: #CC3300 } /* Literal.String.Backtick */
-.highlight .sc { color: #CC3300 } /* Literal.String.Char */
-.highlight .sd { color: #CC3300; font-style: italic } /* Literal.String.Doc */
-.highlight .s2 { color: #CC3300 } /* Literal.String.Double */
-.highlight .se { color: #CC3300; font-weight: bold } /* Literal.String.Escape */
-.highlight .sh { color: #CC3300 } /* Literal.String.Heredoc */
-.highlight .si { color: #AA0000 } /* Literal.String.Interpol */
-.highlight .sx { color: #CC3300 } /* Literal.String.Other */
-.highlight .sr { color: #33AAAA } /* Literal.String.Regex */
-.highlight .s1 { color: #CC3300 } /* Literal.String.Single */
-.highlight .ss { color: #FFCC33 } /* Literal.String.Symbol */
-.highlight .bp { color: #336666 } /* Name.Builtin.Pseudo */
-.highlight .vc { color: #003333 } /* Name.Variable.Class */
-.highlight .vg { color: #003333 } /* Name.Variable.Global */
-.highlight .vi { color: #003333 } /* Name.Variable.Instance */
-.highlight .il { color: #FF6600 } /* Literal.Number.Integer.Long */
-
-.type-csharp .highlight .k { color: #0000FF }
-.type-csharp .highlight .kt { color: #0000FF }
-.type-csharp .highlight .nf { color: #000000; font-weight: normal }
-.type-csharp .highlight .nc { color: #2B91AF }
-.type-csharp .highlight .nn { color: #000000 }
-.type-csharp .highlight .s { color: #A31515 }
-.type-csharp .highlight .sc { color: #A31515 }

stylesheets/stylesheet.css

@@ -1,425 +0,0 @@
-/*******************************************************************************
-Slate Theme for GitHub Pages
-by Jason Costello, @jsncostello
-*******************************************************************************/
-
-@import url(pygment_trac.css);
-
-/*******************************************************************************
-MeyerWeb Reset
-*******************************************************************************/
-
-html, body, div, span, applet, object, iframe,
-h1, h2, h3, h4, h5, h6, p, blockquote, pre,
-a, abbr, acronym, address, big, cite, code,
-del, dfn, em, img, ins, kbd, q, s, samp,
-small, strike, strong, sub, sup, tt, var,
-b, u, i, center,
-dl, dt, dd, ol, ul, li,
-fieldset, form, label, legend,
-table, caption, tbody, tfoot, thead, tr, th, td,
-article, aside, canvas, details, embed,
-figure, figcaption, footer, header, hgroup,
-menu, nav, output, ruby, section, summary,
-time, mark, audio, video {
-  margin: 0;
-  padding: 0;
-  border: 0;
-  font: inherit;
-  vertical-align: baseline;
-}
-
-/* HTML5 display-role reset for older browsers */
-article, aside, details, figcaption, figure,
-footer, header, hgroup, menu, nav, section {
-  display: block;
-}
-
-ol, ul {
-  list-style: none;
-}
-
-table {
-  border-collapse: collapse;
-  border-spacing: 0;
-}
-
-/*******************************************************************************
-Theme Styles
-*******************************************************************************/
-
-body {
-  box-sizing: border-box;
-  color:#373737;
-  background: #212121;
-  font-size: 16px;
-  font-family: 'Myriad Pro', Calibri, Helvetica, Arial, sans-serif;
-  line-height: 1.5;
-  -webkit-font-smoothing: antialiased;
-}
-
-h1, h2, h3, h4, h5, h6 {
-  margin: 10px 0;
-  font-weight: 700;
-  color:#222222;
-  font-family: 'Lucida Grande', 'Calibri', Helvetica, Arial, sans-serif;
-  letter-spacing: -1px;
-}
-
-h1 {
-  font-size: 36px;
-  font-weight: 700;
-}
-
-h2 {
-  padding-bottom: 10px;
-  font-size: 32px;
-  background: url('../images/bg_hr.png') repeat-x bottom;
-}
-
-h3 {
-  font-size: 24px;
-}
-
-h4 {
-  font-size: 21px;
-}
-
-h5 {
-  font-size: 18px;
-}
-
-h6 {
-  font-size: 16px;
-}
-
-p {
-  margin: 10px 0 15px 0;
-}
-
-footer p {
-  color: #f2f2f2;
-}
-
-a {
-  text-decoration: none;
-  color: #007edf;
-  text-shadow: none;
-
-  transition: color 0.5s ease;
-  transition: text-shadow 0.5s ease;
-  -webkit-transition: color 0.5s ease;
-  -webkit-transition: text-shadow 0.5s ease;
-  -moz-transition: color 0.5s ease;
-  -moz-transition: text-shadow 0.5s ease;
-  -o-transition: color 0.5s ease;
-  -o-transition: text-shadow 0.5s ease;
-  -ms-transition: color 0.5s ease;
-  -ms-transition: text-shadow 0.5s ease;
-}
-
-a:hover, a:focus {text-decoration: underline;}
-
-footer a {
-  color: #F2F2F2;
-  text-decoration: underline;
-}
-
-em {
-  font-style: italic;
-}
-
-strong {
-  font-weight: bold;
-}
-
-img {
-  position: relative;
-  margin: 0 auto;
-  max-width: 739px;
-  padding: 5px;
-  margin: 10px 0 10px 0;
-  border: 1px solid #ebebeb;
-
-  box-shadow: 0 0 5px #ebebeb;
-  -webkit-box-shadow: 0 0 5px #ebebeb;
-  -moz-box-shadow: 0 0 5px #ebebeb;
-  -o-box-shadow: 0 0 5px #ebebeb;
-  -ms-box-shadow: 0 0 5px #ebebeb;
-}
-
-p img {
-  display: inline;
-  margin: 0;
-  padding: 0;
-  vertical-align: middle;
-  text-align: center;
-  border: none;
-}
-
-pre, code {
-  width: 100%;
-  color: #222;
-  background-color: #fff;
-
-  font-family: Monaco, "Bitstream Vera Sans Mono", "Lucida Console", Terminal, monospace;
-  font-size: 14px;
-
-  border-radius: 2px;
-  -moz-border-radius: 2px;
-  -webkit-border-radius: 2px;
-}
-
-pre {
-  width: 100%;
-  padding: 10px;
-  box-shadow: 0 0 10px rgba(0,0,0,.1);
-  overflow: auto;
-}
-
-code {
-  padding: 3px;
-  margin: 0 3px;
-  box-shadow: 0 0 10px rgba(0,0,0,.1);
-}
-
-pre code {
-  display: block;
-  box-shadow: none;
-}
-
-blockquote {
-  color: #666;
-  margin-bottom: 20px;
-  padding: 0 0 0 20px;
-  border-left: 3px solid #bbb;
-}
-
-
-ul, ol, dl {
-  margin-bottom: 15px
-}
-
-ul {
-  list-style-position: inside;
-  list-style: disc;
-  padding-left: 20px;
-}
-
-ol {
-  list-style-position: inside;
-  list-style: decimal;
-  padding-left: 20px;
-}
-
-dl dt {
-  font-weight: bold;
-}
-
-dl dd {
-  padding-left: 20px;
-  font-style: italic;
-}
-
-dl p {
-  padding-left: 20px;
-  font-style: italic;
-}
-
-hr {
-  height: 1px;
-  margin-bottom: 5px;
-  border: none;
-  background: url('../images/bg_hr.png') repeat-x center;
-}
-
-table {
-  border: 1px solid #373737;
-  margin-bottom: 20px;
-  text-align: left;
- }
-
-th {
-  font-family: 'Lucida Grande', 'Helvetica Neue', Helvetica, Arial, sans-serif;
-  padding: 10px;
-  background: #373737;
-  color: #fff;
- }
-
-td {
-  padding: 10px;
-  border: 1px solid #373737;
- }
-
-form {
-  background: #f2f2f2;
-  padding: 20px;
-}
-
-/*******************************************************************************
-Full-Width Styles
-*******************************************************************************/
-
-.outer {
-  width: 100%;
-}
-
-.inner {
-  position: relative;
-  max-width: 640px;
-  padding: 20px 10px;
-  margin: 0 auto;
-}
-
-#forkme_banner {
-  display: block;
-  position: absolute;
-  top:0;
-  right: 10px;
-  z-index: 10;
-  padding: 10px 50px 10px 10px;
-  color: #fff;
-  background: url('../images/blacktocat.png') #0090ff no-repeat 95% 50%;
-  font-weight: 700;
-  box-shadow: 0 0 10px rgba(0,0,0,.5);
-  border-bottom-left-radius: 2px;
-  border-bottom-right-radius: 2px;
-}
-
-#header_wrap {
-  background: #212121;
-  background: -moz-linear-gradient(top, #373737, #212121);
-  background: -webkit-linear-gradient(top, #373737, #212121);
-  background: -ms-linear-gradient(top, #373737, #212121);
-  background: -o-linear-gradient(top, #373737, #212121);
-  background: linear-gradient(top, #373737, #212121);
-}
-
-#header_wrap .inner {
-  padding: 50px 10px 30px 10px;
-}
-
-#project_title {
-  margin: 0;
-  color: #fff;
-  font-size: 42px;
-  font-weight: 700;
-  text-shadow: #111 0px 0px 10px;
-}
-
-#project_tagline {
-  color: #fff;
-  font-size: 24px;
-  font-weight: 300;
-  background: none;
-  text-shadow: #111 0px 0px 10px;
-}
-
-#downloads {
-  position: absolute;
-  width: 210px;
-  z-index: 10;
-  bottom: -40px;
-  right: 0;
-  height: 70px;
-  background: url('../images/icon_download.png') no-repeat 0% 90%;
-}
-
-.zip_download_link {
-  display: block;
-  float: right;
-  width: 90px;
-  height:70px;
-  text-indent: -5000px;
-  overflow: hidden;
-  background: url(../images/sprite_download.png) no-repeat bottom left;
-}
-
-.tar_download_link {
-  display: block;
-  float: right;
-  width: 90px;
-  height:70px;
-  text-indent: -5000px;
-  overflow: hidden;
-  background: url(../images/sprite_download.png) no-repeat bottom right;
-  margin-left: 10px;
-}
-
-.zip_download_link:hover {
-  background: url(../images/sprite_download.png) no-repeat top left;
-}
-
-.tar_download_link:hover {
-  background: url(../images/sprite_download.png) no-repeat top right;
-}
-
-#main_content_wrap {
-  background: #f2f2f2;
-  border-top: 1px solid #111;
-  border-bottom: 1px solid #111;
-}
-
-#main_content {
-  padding-top: 40px;
-}
-
-#footer_wrap {
-  background: #212121;
-}
-
-
-
-/*******************************************************************************
-Small Device Styles
-*******************************************************************************/
-
-@media screen and (max-width: 480px) {
-  body {
-    font-size:14px;
-  }
-
-  #downloads {
-    display: none;
-  }
-
-  .inner {
-    min-width: 320px;
-    max-width: 480px;
-  }
-
-  #project_title {
-  font-size: 32px;
-  }
-
-  h1 {
-    font-size: 28px;
-  }
-
-  h2 {
-    font-size: 24px;
-  }
-
-  h3 {
-    font-size: 21px;
-  }
-
-  h4 {
-    font-size: 18px;
-  }
-
-  h5 {
-    font-size: 14px;
-  }
-
-  h6 {
-    font-size: 12px;
-  }
-
-  code, pre {
-    min-width: 320px;
-    max-width: 480px;
-    font-size: 11px;
-  }
-
-}

tests/bugs/issue105.js

@@ -1,4 +1,3 @@
-var Filer = require('../..');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 

tests/bugs/issue106.js

@@ -1,4 +1,3 @@
-var Filer = require('../..');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 

tests/bugs/issue225.js

@@ -1,44 +0,0 @@
-/**
- * https://github.com/js-platform/filer/pull/225
- *
- * NOTE: this test has to be run outside the browserify step,
- * since combinining require for node.js/browserify builds with
- * r.js doesn't work.
- */
-
-var requirejs = require('requirejs');
-var expect = require('chai').expect;
-
-// browser-request assumes access to XHR
-GLOBAL.XMLHttpRequest = {};
-
-describe('require.js should be able to use built Filer, issue 225', function() {
-
-  it('should properly load Filer as an AMD module, with Buffer included', function(done) {
-    requirejs.config({
-      baseUrl: __dirname,
-      paths: {
-        "filer": "../../dist/filer-issue225"
-      },
-      nodeRequire: require
-    });
-
-    requirejs(["filer"], function(Filer) {
-      expect(Filer).to.exist;
-      expect(Filer.Buffer).to.exist;
-
-      var fs = new Filer.FileSystem({provider: new Filer.FileSystem.providers.Memory()});
-
-      var buf = new Filer.Buffer([1, 2, 3]);
-      fs.writeFile('/file', buf, function(err) {
-        expect(err).not.to.exist;
-
-        fs.readFile('/file', function(err, data) {
-          expect(err).not.to.exist;
-          expect(data).to.deep.equal(buf);
-          done();
-        });
-      });
-    });
-  });
-});

tests/bugs/issue239.js

@@ -1,4 +1,3 @@
-var Filer = require('../..');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 

tests/bugs/issue247.js

@@ -1,4 +1,3 @@
-var Filer = require('../..');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 

tests/bugs/issue249.js

@@ -1,4 +1,4 @@
-var Filer = require('../..');
+var Filer = require('../../src');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 
@@ -7,7 +7,7 @@ describe('Filer.Buffer should accept initialized ArrayBuffers, issue 249', funct
   afterEach(util.cleanup);
 
   it('should accept an ArrayBuffer with a specified size', function(done) {
-    var buffer = new Filer.Buffer(new ArrayBuffer(5));
+    var buffer = Buffer.from(new ArrayBuffer(5));
     expect(buffer.length).to.equal(5);
     done();
   });
@@ -18,7 +18,7 @@ describe('Filer.Buffer static methods are in tact, issue 249', function() {
   afterEach(util.cleanup);
 
   it('should proxy Buffer.isBuffer', function(done) {
-    expect(Filer.Buffer.isBuffer(new Filer.Buffer([]))).to.equal(true);
+    expect(Filer.Buffer.isBuffer(Buffer.from([]))).to.equal(true);
     expect(Filer.Buffer.isBuffer('')).to.equal(false);
     done();
   });
@@ -35,7 +35,7 @@ describe('Filer.Buffer static methods are in tact, issue 249', function() {
   });
 
   it('should proxy Buffer.concat', function(done) {
-    expect(Filer.Buffer.concat([new Filer.Buffer(1), new Filer.Buffer(2)]).length).to.equal(3);
+    expect(Filer.Buffer.concat([Buffer.alloc(1), Buffer.alloc(2)]).length).to.equal(3);
     done();
   });
 });

tests/bugs/issue254.js

@@ -1,4 +1,3 @@
-var Filer = require('../..');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 

tests/bugs/issue258.js

@@ -1,5 +1,4 @@
-var Filer = require('../..');
-var util = require('../lib/test-utils.js');
+var Filer = require('../../src');
 var expect = require('chai').expect;
 var setImmediate = require('../../lib/async.js').setImmediate;
 
@@ -53,7 +52,9 @@ describe('Queued operations should error when fs is in error state, issue 258',
 
   it('should get EFILESYSTEMERROR errors on callbacks to queued operations on provider error', function(done) {
     var errCount = 0;
-    var fs = new Filer.FileSystem({provider: provider});
+    var fs = new Filer.FileSystem({provider: provider}, function() {
+      // Do nothing
+    });
 
     function maybeDone(err) {
       expect(err).to.exist;

tests/bugs/issue267.js

@@ -1,4 +1,3 @@
-var Filer = require('../..');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 
@@ -15,6 +14,7 @@ describe('fs.readdir on non-dir paths, issue 267', function() {
       fs.readdir('/myfile.txt', function(err, contents) {
         expect(err).to.exist;
         expect(err.code).to.equal('ENOTDIR');
+        expect(contents).not.to.exist;
         done();
       });
     });

tests/bugs/issue270.js

@@ -1,4 +1,3 @@
-var Filer = require('../..');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 
@@ -6,23 +5,15 @@ describe('undefined and relative paths, issue270', function() {
   beforeEach(util.setup);
   afterEach(util.cleanup);
 
-  it('should fail with EINVAL when called on an undefined path', function(done) {
+  it('should fail with EINVAL when called on an undefined path', function() {
     var fs = util.fs();
-
-    fs.writeFile(undefined, 'data', function(err) {
-      expect(err).to.exist;
-      expect(err.code).to.equal('EINVAL');
-      done();
-    });
+    var fn = () => fs.writeFile(undefined, 'data');
+    expect(fn).to.throw();
   });
 
-  it('should fail with EINVAL when called on a relative path', function(done) {
+  it('should fail with EINVAL when called on a relative path', function() {
     var fs = util.fs();
-
-    fs.writeFile('relpath/file.txt', 'data', function(err) {
-      expect(err).to.exist;
-      expect(err.code).to.equal('EINVAL');
-      done();
-    });
+    var fn = () => fs.writeFile('relpath/file.txt', 'data');
+    expect(fn).to.throw();
   });
 });

tests/bugs/issue357.js

@@ -0,0 +1,17 @@
+var Path = require('../../src').Path;
+var expect = require('chai').expect;
+
+describe('Path.resolve does not work, issue357', function() {
+  it('Path.relative() should not crash', function() {
+    expect(Path.relative('/mydir', '/mydir/file')).to.equal('file');
+
+    // https://nodejs.org/api/path.html#path_path_relative_from_to
+    expect(Path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb')).to.equal('../../impl/bbb');
+  });
+
+  it('Path.resolve() should work as expectedh', function() {
+    // https://nodejs.org/api/path.html#path_path_resolve_from_to
+    expect(Path.resolve('/foo/bar', './baz')).to.equal('/foo/bar/baz');
+    expect(Path.resolve('/foo/bar', '/tmp/file/')).to.equal('/tmp/file');
+  });
+});

tests/bugs/issue773.js

@@ -0,0 +1,12 @@
+'use strict';
+const util = require('../lib/test-utils.js');
+
+describe('unexpected failures when calling fs functions (e.g. writeFile) with empty options object, issue 773', function() {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  it('should call fs.writeFile with an empty options object', function(done) {
+    const fs = util.fs();
+    fs.writeFile('/a', 'trololol', {}, done);
+  });
+});

tests/bugs/issue775.js

@@ -0,0 +1,115 @@
+'use strict';
+var util = require('../lib/test-utils.js');
+var expect = require('chai').expect;
+
+describe('fs.readdir fails when passing options, issue775', function () {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  function setup(fs, dir, cb) {
+    fs.mkdir(dir, undefined, (err) => {
+      if (err) {
+        cb(err);
+      }
+      else {
+        fs.writeFile(dir + '/file', '', (err) => {
+          if (err) {
+            cb(err);
+          }
+          else {
+            fs.mkdir(dir + '/folder', (err) => {
+              if (err) {
+                cb(err);
+              }
+              else {
+                fs.symlink(dir + '/file', dir + '/symlink', (err) => {
+                  if (err) {
+                    cb(err);
+                  }
+                  else {
+                    cb();
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+
+  it('should create a directory, add a file, folder and symbolic link then call fs.readdir with buffer encoding', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      fs.readdir('/test_dir', 'buffer', (err, data) => {
+        if (err) {
+          done(err);
+        }
+        else {
+          expect(data).to.have.length(3);
+
+          expect(data[0].toString()).to.equal('file');
+          expect(data[1].toString()).to.equal('folder');
+          expect(data[2].toString()).to.equal('symlink');
+
+          done();
+        }
+      });
+    });
+  });
+
+  it('should create a directory, add a file, folder and symbolic link then call fs.readdir with withFileTypes and encoding options', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      fs.readdir('/test_dir', { encoding: 'base64', withFileTypes: true }, (err, data) => {
+        if (err) {
+          done(err);
+        }
+        else {
+          expect(data).to.have.length(3);
+
+          expect(Buffer.from(data[0].name, 'base64').toString()).to.equal('file');
+          expect(Buffer.from(data[1].name, 'base64').toString()).to.equal('folder');
+          expect(Buffer.from(data[2].name, 'base64').toString()).to.equal('symlink');
+
+          expect(data[0].isFile()).to.be.true;
+          expect(data[1].isDirectory()).to.be.true;
+          expect(data[2].isSymbolicLink()).to.be.true;
+
+          done();
+        }
+      });
+    });
+  });
+
+  it('should create a directory then call fs.readdir without options', function (done) {
+    var fs = util.fs();
+    setup(fs, '/test_dir', (err) => {
+      if (err) {
+        done(err);
+      }
+      else {
+        fs.readdir('/test_dir', (err, data) => {
+          if (err) {
+            done(err);
+          }
+          else {
+            expect(data).to.have.length(3);
+
+            expect(data[0]).to.equal('file');
+            expect(data[1]).to.equal('folder');
+            expect(data[2]).to.equal('symlink');
+
+            done();
+          }
+        });
+      }
+    });
+  });
+});

tests/bugs/issue776.js

@@ -0,0 +1,12 @@
+'use strict';
+const util = require('../lib/test-utils.js');
+
+describe('fs.mkdir does not recursively create parent directories when called with { recursive: true }, issue776', function() {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  it.skip('should not throw when calling fs.mkdir with recursive flag set', function(done) {
+    const fs = util.fs();
+    fs.mkdir('/test_dir/a/b', { recursive: true }, done);
+  });
+});

tests/bugs/ls-depth-bug.js

@@ -1,4 +1,4 @@
-var Filer = require('../..');
+var Filer = require('../../src');
 var util = require('../lib/test-utils.js');
 var expect = require('chai').expect;
 var async = require('../../lib/async.js');
@@ -25,7 +25,7 @@ describe('sh.ls and deep directory trees', function() {
         done();
       });
     });
-  });
+  }).timeout(15000);
 
   it('should not crash when calling sh.ls() on wide directory layouts', function(done) {
     var fs = util.fs();
@@ -46,7 +46,7 @@ describe('sh.ls and deep directory trees', function() {
       }
 
       async.eachSeries(paths, writeFile, function(err) {
-        if(err) { console.log('error', err);  throw err; }
+        if(err) throw err;
 
         sh.ls('/', {recursive: true}, function(err, listing) {
           expect(err).not.to.exist;
@@ -55,5 +55,5 @@ describe('sh.ls and deep directory trees', function() {
         });
       });
     });
-  });
+  }).timeout(15000);
 });

tests/bugs/rename-dir-trailing-slash.js

@@ -0,0 +1,27 @@
+var util = require('../lib/test-utils.js');
+var expect = require('chai').expect;
+
+describe('trailing slashes in path names to work when renaming a dir', function() {
+  beforeEach(util.setup);
+  afterEach(util.cleanup);
+
+  it('should deal with trailing slashes in rename, dir == dir/', function(done) {
+    var fs = util.fs();
+
+    fs.mkdir('/tmp', function(err) {
+      if(err) throw err;
+
+      fs.rename('/tmp/', '/new-tmp/', function(err) {
+        if(err) throw err;
+
+        fs.stat('/new-tmp', function(err, stats) {
+          if(err) throw err;
+          expect(stats).to.exist;
+          expect(stats.isDirectory()).to.be.true;
+
+          done();
+        });
+      });
+    });
+  });
+});

tests/filesystems/images/README.md

@@ -0,0 +1,9 @@
+The following images are JSON filesystem images created with
+`tools/fs-image.js`, and named with the filesystem dir used
+as the source of the image, and the version of Filer used to
+generate them:
+
+1. `tiny-fs.0.43.json` was created from `tests/filesystem/tiny-fs/` with https://github.com/filerjs/filer/blob/d66114e20c7f0235698d9933dbd90217ba86fa4e/dist/filer.min.js
+
+If you need to create a new image, use `tools/get-filer-version.js` to
+get a specific version of Filer, then `tools/fs-image.js` to generate an image.

tests/filesystems/images/tiny-fs.0.43.json

@@ -0,0 +1 @@
+{"00000000-0000-0000-0000-000000000000":{"id":"00000000-0000-0000-0000-000000000000","mode":"META","atime":1545098425757,"ctime":1545098425757,"mtime":1545098425757,"rnode":"A63180BA-9BCE-4245-86E8-8613726587CA"},"A63180BA-9BCE-4245-86E8-8613726587CA":{"id":"A63180BA-9BCE-4245-86E8-8613726587CA","mode":"DIRECTORY","size":0,"atime":1545098425770,"ctime":1545098425770,"mtime":1545098425770,"flags":[],"xattrs":{},"nlinks":1,"version":0,"nblocks":1,"data":"3A41160B-1F39-4162-85BD-473F16ABF35F"},"3A41160B-1F39-4162-85BD-473F16ABF35F":{"dir":{"id":"E1634C88-337D-4D1E-9155-81B099BC7E7C","type":"DIRECTORY"},"file.txt":{"id":"DD338D5C-34FF-4AF7-AFBB-C01E8214125F","type":"FILE"}},"E1634C88-337D-4D1E-9155-81B099BC7E7C":{"id":"E1634C88-337D-4D1E-9155-81B099BC7E7C","mode":"DIRECTORY","size":0,"atime":1545098425778,"ctime":1545098425778,"mtime":1545098425778,"flags":[],"xattrs":{},"nlinks":1,"version":0,"nblocks":1,"data":"C8BB5894-9B0C-4CDC-B014-3944FB40DA77"},"C8BB5894-9B0C-4CDC-B014-3944FB40DA77":{"file2.txt":{"id":"EEB56FEC-DABE-48BF-88A5-B9F37723A0BC","type":"FILE"}},"DD338D5C-34FF-4AF7-AFBB-C01E8214125F":{"id":"DD338D5C-34FF-4AF7-AFBB-C01E8214125F","mode":"FILE","size":16,"atime":1545098327877.7542,"ctime":1545098313562.6824,"mtime":1545098313562.6824,"flags":[],"xattrs":{},"nlinks":1,"version":1,"nblocks":1,"data":"BDEE2339-6992-4D8F-AFAA-81813C30592C"},"BDEE2339-6992-4D8F-AFAA-81813C30592C":{"type":"Buffer","data":[84,104,105,115,32,105,115,32,97,32,102,105,108,101,46,10]},"EEB56FEC-DABE-48BF-88A5-B9F37723A0BC":{"id":"EEB56FEC-DABE-48BF-88A5-B9F37723A0BC","mode":"FILE","size":23,"atime":1545098327877.7542,"ctime":1545098313562.6824,"mtime":1545098313562.6824,"flags":[],"xattrs":{},"nlinks":1,"version":1,"nblocks":1,"data":"62262B53-32BC-43F6-983B-4127302C2483"},"62262B53-32BC-43F6-983B-4127302C2483":{"type":"Buffer","data":[84,104,105,115,32,105,115,32,97,32,115,101,99,111,110,100,32,102,105,108,101,46,10]}}

tests/filesystems/migrations/from-0.43.test.js

@@ -0,0 +1,91 @@
+const expect = require('chai').expect;
+const Filer = require('../../../src');
+const SerializableMemoryProvider = require('../../lib/serializable-memory-provider');
+const nodeFs = require('fs');
+const nodePath = require('path');
+
+describe('Migration tests from Filer 0.43 to current', () => {
+
+  let filerFs;
+
+  before(done => {
+    // Let the provider parse the JSON
+    const imagePath = nodePath.resolve(__dirname, '../images/tiny-fs.0.43.json');
+    nodeFs.readFile(imagePath, 'utf8', (err, data) => {
+      if(err) throw err;
+
+      new Filer.FileSystem({
+        provider: new SerializableMemoryProvider('0.43', data)
+      }, (err, fs) => {
+        if(err) throw err;
+
+        filerFs = fs;
+        done();
+      });
+    });
+  });
+
+  it('should have a root directory', done => {
+    filerFs.stat('/', (err, stats) => {
+      if(err) throw err;
+
+      expect(stats).to.be.an('object');
+      expect(stats.isDirectory()).to.be.true;
+      done();
+    });
+  });
+
+  it('should have expected entries in root dir', done => {
+    filerFs.readdir('/', (err, entries) => {
+      if(err) throw err;
+
+      expect(entries).to.be.an('array');
+      expect(entries.length).to.equal(2);
+      expect(entries).to.contain('file.txt');
+      expect(entries).to.contain('dir');
+      done();
+    });
+  });
+
+  it('should have correct contents for /file.txt (read as String)', done => {
+    const fileTxtPath = nodePath.resolve(__dirname, '../tiny-fs/file.txt');
+
+    nodeFs.readFile(fileTxtPath, 'utf8', (err, nodeData) => {
+      if(err) throw err;
+
+      filerFs.readFile('/file.txt', 'utf8', (err, filerData) => {
+        if(err) throw err;
+  
+        expect(nodeData).to.equal(filerData);
+        done();
+      });  
+    });
+  });
+
+  it('should have expected entries in /dir', done => {
+    filerFs.readdir('/dir', (err, entries) => {
+      if(err) throw err;
+
+      expect(entries).to.be.an('array');
+      expect(entries.length).to.equal(1);
+      expect(entries).to.contain('file2.txt');
+      done();
+    });
+  });
+
+  it('should have correct contents for /dir/file2.txt (read as Buffer)', done => {
+    const file2TxtPath = nodePath.resolve(__dirname, '../tiny-fs/dir/file2.txt');
+
+    nodeFs.readFile(file2TxtPath, null, (err, nodeData) => {
+      if(err) throw err;
+
+      filerFs.readFile('/dir/file2.txt', null, (err, filerData) => {
+        if(err) throw err;
+  
+        expect(nodeData).to.deep.equal(filerData);
+        done();
+      });  
+    });
+  });
+
+});

tests/filesystems/tiny-fs/dir/file2.txt

@@ -0,0 +1 @@
+This is a second file.

tests/filesystems/tiny-fs/file.txt

@@ -0,0 +1 @@
+This is a file.

tests/index.html

@@ -1,24 +1,26 @@
+
+<!DOCTYPE html>
 <html>
 <head>
   <meta charset="utf-8">
-  <title>Mocha Tests</title>
+  <title>Filer Tests</title>
   <link rel="stylesheet" href="../node_modules/mocha/mocha.css" />
-  <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/mocha/1.21.4/mocha.css" />
-  <script src="//cdnjs.cloudflare.com/ajax/libs/mocha/1.21.4/mocha.js"></script>
-  <script>window.mocha || document.write('<script src="../node_modules/mocha/mocha.js"><\/script>')</script>
-  <script src="//cdnjs.cloudflare.com/ajax/libs/chai/1.9.2/chai.min.js"></script>
-  <script>window.chai || document.write('<script src="../node_modules/chai/chai.js"><\/script>')</script>
+ </head>
+<body>
+  <div id="mocha"></div>
+  <script src="../node_modules/chai/chai.js"></script>
+  <script src="../node_modules/mocha/mocha.js"></script>
+
   <script>
-    mocha.setup('bdd').timeout(5000).slow(250);;
+    mocha.setup('bdd').timeout(10000).slow(250);
 
     window.onload = function() {
       mocha.checkLeaks();
       mocha.run();
     };
   </script>
-  <script src="../dist/filer-test.js"></script>
- </head>
-<body>
-  <div id="mocha"></div>
+
+  <!-- Add any new tests to `tests/index.js` -->
+  <script src="./index.js"></script>
 </body>
 </html>

tests/index.js

@@ -3,75 +3,97 @@
  * get them running by default.
  */
 
+// Shims
+require('./spec/shims/fs.spec');
+require('./spec/shims/path.spec');
+
+// Webpack Plugin
+require('./spec/webpack-plugin/webpack-plugin.spec');
+
 // Filer
-require("./spec/filer.spec");
+require('./spec/filer.spec');
+require('./spec/filer.buffer.spec.js');
 
 // Filer.FileSystem.*
-require("./spec/filer.filesystem.spec");
-require("./spec/fs.spec");
-require("./spec/fs.stat.spec");
-require("./spec/fs.lstat.spec");
-require("./spec/fs.exists.spec");
-require("./spec/fs.mknod.spec");
-require("./spec/fs.mkdir.spec");
-require("./spec/fs.readdir.spec");
-require("./spec/fs.rmdir.spec");
-require("./spec/fs.open.spec");
-require("./spec/fs.write.spec");
-require("./spec/fs.writeFile-readFile.spec");
-require("./spec/fs.appendFile.spec");
-require("./spec/fs.read.spec");
-require("./spec/fs.close.spec");
-require("./spec/fs.link.spec");
-require("./spec/fs.unlink.spec");
-require("./spec/fs.rename.spec");
-require("./spec/fs.lseek.spec");
-require("./spec/fs.symlink.spec");
-require("./spec/fs.readlink.spec");
-require("./spec/fs.truncate.spec");
-require("./spec/fs.utimes.spec");
-require("./spec/fs.xattr.spec");
-require("./spec/fs.stats.spec");
-require("./spec/path-resolution.spec");
-require("./spec/trailing-slashes.spec");
-require("./spec/times.spec");
-require("./spec/time-flags.spec");
-require("./spec/fs.watch.spec");
-require("./spec/errors.spec");
-require("./spec/fs.shell.spec");
+require('./spec/filer.filesystem.spec');
+require('./spec/fs.spec');
+require('./spec/fs.access.spec');
+require('./spec/fs.stat.spec');
+require('./spec/fs.lstat.spec');
+require('./spec/fs.exists.spec');
+require('./spec/fs.mknod.spec');
+require('./spec/fs.mkdir.spec');
+require('./spec/fs.mkdtemp.spec');
+require('./spec/fs.readdir.spec');
+require('./spec/fs.rmdir.spec');
+require('./spec/fs.open.spec');
+require('./spec/fs.write.spec');
+require('./spec/fs.writeFile-readFile.spec');
+require('./spec/fs.appendFile.spec');
+require('./spec/fs.read.spec');
+require('./spec/fs.close.spec');
+require('./spec/fs.fsync.spec');
+require('./spec/fs.link.spec');
+require('./spec/fs.unlink.spec');
+require('./spec/fs.rename.spec');
+require('./spec/fs.lseek.spec');
+require('./spec/fs.symlink.spec');
+require('./spec/fs.readlink.spec');
+require('./spec/fs.truncate.spec');
+require('./spec/fs.ftruncate.spec');
+require('./spec/fs.utimes.spec');
+require('./spec/fs.xattr.spec');
+require('./spec/path-resolution.spec');
+require('./spec/trailing-slashes.spec');
+require('./spec/times.spec');
+require('./spec/time-flags.spec');
+require('./spec/fs.watch.spec');
+require('./spec/fs.unwatchFile.spec');
+require('./spec/errors.spec');
+require('./spec/fs.shell.spec');
+require('./spec/fs.chmod.spec');
+require('./spec/fs.chown.spec');
+require('./spec/fs.copyFile.spec');
 
 // Filer.FileSystem.providers.*
-require("./spec/providers/providers.spec");
-require("./spec/providers/providers.indexeddb.spec");
-require("./spec/providers/providers.websql.spec");
-require("./spec/providers/providers.memory.spec");
+require('./spec/providers/providers.spec');
+require('./spec/providers/providers.indexeddb.spec');
+require('./spec/providers/providers.memory.spec');
+require('./spec/providers/serializable-memory-provider.spec');
 
 // Filer.FileSystemShell.*
-require("./spec/shell/cd.spec");
-require("./spec/shell/touch.spec");
-require("./spec/shell/exec.spec");
-require("./spec/shell/cat.spec");
-require("./spec/shell/ls.spec");
-require("./spec/shell/rm.spec");
-require("./spec/shell/env.spec");
-require("./spec/shell/mkdirp.spec");
-require("./spec/shell/find.spec");
+require('./spec/shell/cd.spec');
+require('./spec/shell/touch.spec');
+require('./spec/shell/exec.spec');
+require('./spec/shell/cat.spec');
+require('./spec/shell/ls.spec');
+require('./spec/shell/rm.spec');
+require('./spec/shell/env.spec');
+require('./spec/shell/mkdirp.spec');
+require('./spec/shell/find.spec');
 
 // Ported node.js tests (filenames match names in https://github.com/joyent/node/tree/master/test)
-require("./spec/node-js/simple/test-fs-mkdir");
-require("./spec/node-js/simple/test-fs-null-bytes");
-require("./spec/node-js/simple/test-fs-watch");
-require("./spec/node-js/simple/test-fs-watch-recursive");
+require('./spec/node-js/simple/test-fs-mkdir');
+require('./spec/node-js/simple/test-fs-null-bytes');
+require('./spec/node-js/simple/test-fs-watch');
+require('./spec/node-js/simple/test-fs-watch-recursive');
 
 // Regressions, Bugs
-// NOTE: bugs/issue225.js has to be run outside this step, see gruntfile.js
-require("./bugs/issue105");
-require("./bugs/issue106");
-require("./bugs/issue239");
-require("./bugs/issue249");
-require("./bugs/ls-depth-bug");
-require("./bugs/issue247.js");
-require("./bugs/issue254.js");
-require("./bugs/issue258.js");
-require("./bugs/issue267.js");
-require("./bugs/issue270.js");
+require('./bugs/issue105');
+require('./bugs/issue106');
+require('./bugs/issue239');
+require('./bugs/issue249');
+require('./bugs/ls-depth-bug');
+require('./bugs/issue247.js');
+require('./bugs/issue254.js');
+require('./bugs/issue258.js');
+require('./bugs/issue267.js');
+require('./bugs/issue270.js');
+require('./bugs/rename-dir-trailing-slash.js');
+require('./bugs/issue357.js');
+require('./bugs/issue773.js');
+require('./bugs/issue775.js');
+require('./bugs/issue776.js');
+
+// Sample code from README
+require('./spec/readme.example.spec');

tests/lib/indexeddb.js

@@ -1,11 +1,8 @@
-var Filer = require("../..");
+'use strict';
 
-var indexedDB = global.indexedDB       ||
-                global.mozIndexedDB    ||
-                global.webkitIndexedDB ||
-                global.msIndexedDB;
+const Filer = require('../../src');
 
-var needsCleanup = [];
+let needsCleanup = [];
 if(global.addEventListener) {
   global.addEventListener('beforeunload', function() {
     needsCleanup.forEach(function(f) { f(); });
@@ -13,8 +10,8 @@ if(global.addEventListener) {
 }
 
 function IndexedDBTestProvider(name) {
-  var _done = false;
-  var that = this;
+  let _done = false;
+  let that = this;
 
   function cleanup(callback) {
     callback = callback || function(){};
@@ -23,20 +20,32 @@ function IndexedDBTestProvider(name) {
       return callback();
     }
 
-    // We have to force any other connections to close
-    // before we can delete a db.
-    if(that.provider.db) {
-      that.provider.db.close();
-    }
-
-    var request = indexedDB.deleteDatabase(name);
     function finished() {
       that.provider = null;
       _done = true;
       callback();
     }
-    request.onsuccess = finished;
-    request.onerror = finished;
+
+    try {
+      // We have to force any other connections to close
+      // before we can delete a db.
+      if(that.provider.db) {
+        that.provider.db.close();
+      }
+
+      const indexedDB = global.indexedDB       ||
+                      global.mozIndexedDB    ||
+                      global.webkitIndexedDB ||
+                      global.msIndexedDB;
+
+      let request = indexedDB.deleteDatabase(name);
+      request.onsuccess = finished;
+      request.onerror = finished;
+    } catch(e) {
+      /* eslint no-console:0 */
+      console.log('Failed to delete test database', e);
+      finished();
+    }
   }
 
   function init() {

tests/lib/memory.js

@@ -1,4 +1,4 @@
-var Filer = require('../..');
+var Filer = require('../../src');
 
 function MemoryTestProvider(name) {
   var that = this;

tests/lib/serializable-memory-provider.js

@@ -0,0 +1,42 @@
+const MemoryProvider = require('../../src/providers/memory');
+const { parseBJSON } = require('../lib/test-utils');
+
+class SerializableMemoryProvider extends MemoryProvider {
+
+  constructor(name, jsonImage) {
+    super(name);
+    this.unparsedJSONImage = jsonImage;
+  }
+
+  /**
+   * In addition to the usual setup of a Memory provider,
+   * also parse and overwrite the internal database.
+   */
+  open(callback) {
+    super.open(err => {
+      if(err) {
+        return callback(err);
+      }
+
+      // If we don't have an image to import, leave db as is
+      if(!this.unparsedJSONImage) {
+        return callback();
+      }
+
+      // Try to import the fs image from JSON
+      try {
+        this.db = parseBJSON(this.unparsedJSONImage);
+        this.unparsedJSONImage = null;
+        callback();
+      } catch(e) {
+        callback(new Error(`unable to parse JSON filesystem image: ${e.message}`));
+      }
+    });
+  }
+
+  export() {
+    return JSON.stringify(this.db);
+  }
+}
+
+module.exports = SerializableMemoryProvider;

tests/lib/test-utils.js

@@ -1,135 +1,195 @@
-(function(global) {
+var Filer = require('../../src');
+var IndexedDBTestProvider = require('./indexeddb.js');
+var MemoryTestProvider = require('./memory.js');
+var Url = require('url');
 
-  var Filer = require('../..');
-  var IndexedDBTestProvider = require('./indexeddb.js');
-  var WebSQLTestProvider = require('./websql.js');
-  var MemoryTestProvider = require('./memory.js');
+var _provider;
+var _fs;
 
-  var _provider;
-  var _fs;
+function uniqueName() {
+  if(!uniqueName.seed) {
+    uniqueName.seed = Date.now();
+  }
+  return 'filer-testdb-' + uniqueName.seed++;
+}
 
-  function uniqueName() {
-    if(!uniqueName.seed) {
-      uniqueName.seed = Date.now();
-    }
-    return 'filer-testdb-' + uniqueName.seed++;
+function findBestProvider() {
+  var providers = Filer.FileSystem.providers;
+  return providers.IndexedDB.isSupported() ?
+    IndexedDBTestProvider : MemoryTestProvider;
+}
+
+function getUrlParams() {
+  // Check if we are running in node
+  if(!global.location) {
+    return null;
   }
 
-  function findBestProvider() {
-    var providers = Filer.FileSystem.providers;
-    if(providers.IndexedDB.isSupported()) {
-      return IndexedDBTestProvider;
-    }
-    if(providers.WebSQL.isSupported()) {
-      return WebSQLTestProvider;
-    }
-    return MemoryTestProvider;
+  var url = Url.parse(global.location.href, true);
+
+  return url.query;
+}
+
+function getProviderType() {
+  var defaultProvider = 'default';
+  var queryString = getUrlParams();
+
+  // If the environment is node or the query string is empty,
+  // the memory provider will be used.
+  if(!queryString) {
+    return defaultProvider;
   }
 
-  function setup(callback) {
-    // In browser we support specifying the provider via the query string
-    // (e.g., ?filer-provider=IndexedDB). If not specified, we use
-    // the Memory provider by default.  See test/require-config.js
-    // for definition of window.filerArgs.
-    var providerType = global.filerArgs && global.filerArgs.provider ?
-      global.filerArgs.provider : 'Memory';
+  return queryString['filer-provider'] || defaultProvider;
+}
 
-    var name = uniqueName();
+// Run fn() in an environment with indexedDB available
+// either as-is, or shimmed, removing when done.
+function shimIndexedDB(fn) {
+  var addShim = !Filer.FileSystem.providers.IndexedDB.isSupported();
 
-    switch(providerType.toLowerCase()) {
-      case 'indexeddb':
-        _provider = new IndexedDBTestProvider(name);
-        break;
-      case 'websql':
-        _provider = new WebSQLTestProvider(name);
-        break;
-      case 'memory':
-      /* falls through */
-      default:
-        var BestProvider = findBestProvider();
-        _provider = new BestProvider(name);
-        break;
-    }
-
-    // Allow passing FS flags on query string
-    var flags = global.filerArgs && global.filerArgs.flags ?
-      global.filerArgs.flags : 'FORMAT';
-
-    // Create a file system and wait for it to get setup
-    _provider.init();
-
-    function complete(err, fs) {
-      if(err) throw err;
-      _fs = fs;
-      callback();
-    }
-    return new Filer.FileSystem({
-      name: name,
-      provider: _provider.provider,
-      flags: flags
-    }, complete);
+  if(addShim) {
+    global.indexedDB = require('fake-indexeddb');
   }
 
-  function fs() {
-    if(!_fs) {
-      throw "TestUtil: call setup() before fs()";
-    }
-    return _fs;
+  var result = fn();
+
+  if(addShim) {
+    delete global.indexedDB;
   }
 
-  function provider() {
-    if(!_provider) {
-      throw "TestUtil: call setup() before provider()";
-    }
-    return _provider;
+  return result;
+}
+
+function setup(callback) {
+  // In browser we support specifying the provider via the query string
+  // (e.g., ?filer-provider=IndexedDB). If not specified, we use
+  // the Memory provider by default.
+  var providerType = getProviderType();
+
+  var name = uniqueName();
+
+  switch(providerType.toLowerCase()) {
+  case 'indexeddb':
+    _provider = new IndexedDBTestProvider(name);
+    break;
+  case 'memory':
+    _provider = new MemoryTestProvider(name);
+    break;
+  case 'default':
+  default:
+    var BestProvider = findBestProvider();
+    _provider = new BestProvider(name);
+    break;
   }
 
-  function shell(options) {
-    var _fs = fs();
-    return new _fs.Shell(options);
+  // Allow passing FS flags on query string
+  var flags = global.filerArgs && global.filerArgs.flags ?
+    global.filerArgs.flags : 'FORMAT';
+
+  // Create a file system and wait for it to get setup
+  _provider.init();
+
+  function complete(err, fs) {
+    if(err) throw err;
+    _fs = fs;
+    callback();
+  }
+  return new Filer.FileSystem({
+    name: name,
+    provider: _provider.provider,
+    flags: flags
+  }, complete);
+}
+
+function fs() {
+  if(!_fs) {
+    throw new Error('TestUtil: call setup() before fs()');
+  }
+  return _fs;
+}
+
+function provider() {
+  if(!_provider) {
+    throw new Error('TestUtil: call setup() before provider()');
+  }
+  return _provider;
+}
+
+function shell(options) {
+  var _fs = fs();
+  return new _fs.Shell(options);
+}
+
+function cleanup(callback) {
+  if(!_provider) {
+    return;
+  }
+  _provider.cleanup(function() {
+    _provider = null;
+    _fs = null;
+    callback();
+  });
+}
+
+function typedArrayEqual(a, b) {
+  if(!(a && b)) {
+    return false;
+  }
+  if(a.length !== b.length) {
+    return false;
   }
 
-  function cleanup(callback) {
-    if(!_provider) {
-      return;
+  for(var i = 0; i < a.length; ++ i) {
+    if(a[i] !== b[i]) {
+      return false;
     }
-    _provider.cleanup(function() {
-      _provider = null;
-      _fs = null;
-      callback();
+  }
+
+  return true;
+}
+
+/**
+ * Parse JSON with serialized Buffers
+ */
+const parseBJSON = json =>
+  JSON.parse(json, (key, value) =>
+    value && value.type === 'Buffer' ?
+      Buffer.from(value.data) :
+      value
+  );
+
+function createMockFn(implementation = undefined) {
+  const calls = [];
+  const mockFn = function(...args) {
+    calls.push({
+      args,
     });
-  }
-
-  function typedArrayEqual(a, b) {
-    if(!(a && b)) {
-      return false;
+    if (typeof implementation === 'function') {
+      return implementation(...args);
     }
-    if(a.length !== b.length) {
-      return false;
-    }
-
-    for(var i = 0; i < a.length; ++ i) {
-      if(a[i] !== b[i]) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  module.exports = {
-    uniqueName: uniqueName,
-    setup: setup,
-    fs: fs,
-    shell: shell,
-    provider: provider,
-    providers: {
-      IndexedDB: IndexedDBTestProvider,
-      WebSQL: WebSQLTestProvider,
-      Memory: MemoryTestProvider
-    },
-    cleanup: cleanup,
-    typedArrayEqual: typedArrayEqual
   };
+  Object.defineProperty(mockFn, 'calls', {
+    get() {
+      return calls;
+    }
+  });
+  return mockFn;
+}
 
-}(this));
+module.exports = {
+  uniqueName: uniqueName,
+  setup: setup,
+  fs: fs,
+  shell: shell,
+  provider: provider,
+  providers: {
+    IndexedDB: IndexedDBTestProvider,
+    Memory: MemoryTestProvider
+  },
+  cleanup: cleanup,
+  typedArrayEqual: typedArrayEqual,
+  parseBJSON,
+  shimIndexedDB,
+  createMockFn
+};

tests/lib/websql.js

@@ -1,49 +0,0 @@
-var Filer = require('../..');
-
-var needsCleanup = [];
-if(global.addEventListener) {
-  global.addEventListener('beforeunload', function() {
-    needsCleanup.forEach(function(f) { f(); });
-  });
-}
-
-function WebSQLTestProvider(name) {
-  var _done = false;
-  var that = this;
-
-  function cleanup(callback) {
-    callback = callback || function(){};
-
-    if(!that.provider || _done) {
-      return callback();
-    }
-
-    // Provider is there, but db was never touched
-    if(!that.provider.db) {
-      return callback();
-    }
-
-    var context = that.provider.getReadWriteContext();
-    context.clear(function() {
-      that.provider = null;
-      _done = true;
-      callback();
-    });
-  }
-
-  function init() {
-    if(that.provider) {
-      return;
-    }
-    that.provider = new Filer.FileSystem.providers.WebSQL(name);
-    needsCleanup.push(cleanup);
-  }
-
-  this.init = init;
-  this.cleanup = cleanup;
-}
-WebSQLTestProvider.isSupported = function() {
-  return Filer.FileSystem.providers.WebSQL.isSupported();
-};
-
-module.exports = WebSQLTestProvider;

tests/spec/errors.spec.js

@@ -1,8 +1,10 @@
-var Filer = require('../..');
-var expect = require('chai').expect;
+'use strict';
 
-describe("Filer.Errors", function() {
-  it("has expected errors", function() {
+const Filer = require('../../src');
+const expect = require('chai').expect;
+
+describe('Filer.Errors', function() {
+  it('has expected errors', function() {
     expect(Filer.Errors).to.exist;
 
     // By ctor -- if you add some to src/errors.js, also add here
@@ -135,7 +137,7 @@ describe("Filer.Errors", function() {
   });
 
   it('should include all expected properties by default', function() {
-    var err = new Filer.Errors.ENOENT();
+    const err = new Filer.Errors.ENOENT();
     expect(err.name).to.equal('ENOENT');
     expect(err.code).to.equal('ENOENT');
     expect(err.errno).to.equal(34);
@@ -143,7 +145,7 @@ describe("Filer.Errors", function() {
   });
 
   it('should include extra properties when provided', function() {
-    var err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
+    const err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
     expect(err.name).to.equal('ENOENT');
     expect(err.code).to.equal('ENOENT');
     expect(err.errno).to.equal(34);
@@ -152,29 +154,29 @@ describe("Filer.Errors", function() {
   });
 
   it('should include default message and path info when provided', function() {
-    var err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
+    const err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
     expect(err.message).to.equal('no such file or directory');
     expect(err.path).to.equal('/this/is/the/path');
   });
 
   it('should include just the message when no path provided', function() {
-    var err = new Filer.Errors.ENOENT();
+    const err = new Filer.Errors.ENOENT();
     expect(err.message).to.equal('no such file or directory');
     expect(err.path).not.to.exist;
   });
 
   it('should not include path in toString() when not provided', function() {
-    var err = new Filer.Errors.ENOENT('This is the message');
-    expect(err.toString()).to.equal("ENOENT: This is the message");
+    const err = new Filer.Errors.ENOENT('This is the message');
+    expect(err.toString()).to.equal('ENOENT: This is the message');
   });
 
   it('should include path in toString() when provided', function() {
-    var err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
-    expect(err.toString()).to.equal("ENOENT: no such file or directory, '/this/is/the/path'");
+    const err = new Filer.Errors.ENOENT(null, '/this/is/the/path');
+    expect(err.toString()).to.equal('ENOENT: no such file or directory, \'/this/is/the/path\'');
   });
 
   it('should include message and path info when provided', function() {
-    var err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
+    const err = new Filer.Errors.ENOENT('This is the message', '/this/is/the/path');
     expect(err.message).to.equal('This is the message');
     expect(err.path).to.equal('/this/is/the/path');
   });