A Blob object represents a file-like object of immutable, raw
Blobs represent data that isn't necessarily in a JavaScript-native
The `web.files.File` interface is based on Blob, inheriting blob
and expanding it to support files on the user's system.

The BlobBuilder interface provides an easy way to construct `web.files.Blob`
Just create a BlobBuilder and append chunks of data to it by
the append() method. When you're done building your blob, call
to retrieve a `web.files.Blob` containing the data you sent into
blob builder.

web.files interfaces.

The DirectoryEntrySync interface of the File System API represents
directory in a file system. It includes methods for creating,
looking up, and recursively removing files in a directory.

The File interface provides information about files and allows
in a web page to access their content.

An object of this type is returned by the files property of the
`<input>` element; this lets you access the list of files selected
the <input type=\"file\"> element. It's also used for a list
files dropped into web content when using the drag and drop API;
the `web.drag.DataTransfer` object for details on this usage.

The FileReader object lets web applications asynchronously read
contents of files (or raw data buffers) stored on the user's
using `web.files.File` or `web.files.Blob` objects to specify
file or data to read.

FileReader Events.

The FileRequest interface extends the `DOMRequest` interface
provide some extra properties necessary for the `web.files.LockedFile`

FileRequest Events.

The File and Directory Entries API interface FileSystem is used
represent a file system. These objects can be obtained from the
property on any file system entry. Some browsers offer additional
to create and manage file systems, such as Chrome's `requestFileSystem()`

The FileSystemDirectoryEntry interface of the File and Directory
API represents a directory in a file system. It provides methods
make it possible to access and manipulate the files in a directory,
well as to access the entries within the directory.

The FileSystemDirectoryReader interface of the File and Directory
API lets you access the `FileEntry`-based objects (generally
or `web.files.FileSystemDirectoryEntry`) representing each entry
a directory.

The FileSystemEntry interface of the File and Directory Entries
represents a single in a file system. The entry can be a file
a directory (directories are represented by the `DirectoryEntry`
It includes methods for working with files—including copying,
removing, and reading files—as well as information about a file
points to—including the file name and its path from the root
the entry.

The FileSystemEntrySync interface of the File and Directory Entries
represents an entry in a file system; it can be either a `web.files.FileEntrySync`
`DirectoryEntry`.

The FileSystemFileEntry interface of the File System API represents
file in a file system. It offers properties describing the file's
as well as the `file()` method, which creates a `web.files.File`
that can be used to read the file.

The FileSystemFlags dictionary defines a set of values which
used when specifying option flags when calling certain methods
the File and Directory Entries API. Methods which accept an options
of this type may specify zero or more of these flags as fields
an object, like this:

The IDBMutableFile interface provides access in read or write
to a file, dealing with all the necessary locks.

IDBMutableFile Events.

The LocalFileSystemSync interface of the File System API gives
access to a sandboxed file system. It is intended to be used
WebWorkers. The methods are implemented by worker objects.

The LockedFile interface provides tools to deal with a given
with all the necessary locks.

LockedFile Events.

The Metadata interface is used by the File and Directory Entries
to contain information about a file system entry. This metadata
the file's size and modification date and time.

The ReadableStream interface of the Streams API represents a
stream of byte data. The Fetch API offers a concrete instance
a ReadableStream through the `body` property of a `web.fetch.Response`