Merge branch `minify-test` into `redux`.
Remove completed TODO.
Make `unmark` return a parent/refernece pair.

The `unmark` function would return nothing. Now it returns an object
containing the parent node of the marker and the next sibling. The
`mark` function expects an object containing these properties and will
insert a directive marker comment before the next sibling of the marker
that was removed by `unmark`. Alternatively, the `mark` function can
still accept a DOM node and it will insert a directive comment marker
before the given DOM node.

The parent node and reference pair returned by `unmark`  allows us to
remove a marker before inserting replacement nodes. This added
flexibility may be useful when implementing more complicated directives.

In particular, I'd like to remove contents of an else directive if I'm
going to replace it with the contents of an if directive. I'm not
certain if there won't be a flicker where the user will see the new
block added before the old block is deleted. If the user can perceive
the DOM manipulation I want her to see the old block disappear before
the new block appears.
Merge branch `if` into `redux`.
No longer storing instance data in array.

Instance data will be stored in a tree. Each member of a collection will
have a key based on an id derived from the collection object or else the
index of the object in the collection. The array was an early notion of
how to represent multiple instances of a directive.
Store marker in instance object.

Now storing the marker in the instance object instead of in a parallel
map of id paths to markers.
Store instances in tree.

Now storing instance data -- element counts, character counts and
markers -- in a tree. This is so that when we implement conditionals we
can free instance data by unlinking an instance from an tree and letting
it fall out of scope. All of the instance data of the child directives
will be only be referenced through the instance data of their parent
directives, so the unlinked instance data is garbage collected all of
the instance data of descendant directives will also be garbage
collected.
Implemented `if`.

Implemented an `if` with a test for when if is true.

Compilation now unfolds directives, moving thier contents out into the
document as next siblings, and then replacing the directive with a
marker. This makes the document consistent for the `rewrite` function.

The handlers for the directives now accept the current descent object so
that an if directive can clear the copy of the child directives when is
the condition is false so that the child directives are not evaluated.
Merge branch `if` into `redux`.
Implement false `if` directive.

Correctly reconstituting a Stencil document that contains an `if`
directive.

Implemented `if` false.

Noticing now that I do want to nest directives underneath an `if`
statement in a directive path, even though each directive underneath an
`if` statement is unique. The new path key is an array that navigates a
tree of instance data, so long keys don't bother me as much, since each
part of the path exists only once in the tree.

Yes, long hash keys bothered me, even though as long as they may get,
they'd never reach a maximum key length. I thought it would be ugly if
it ever got displayed or used in debugging.

Now the instance data is a tree, so we could free instance data with the
directives underneath an `if` directive, if the instance tree was
parallel to the directive tree. The shortened paths do not create a
parallel instance tree.
Implement rewrite of true `if` that was false.

When an `if` directive is false, the DOM elements underneath the `if`
directive are removed from the DOM. When we update the DOM and the `if`
directive is true, then we need to re-insert the elements from the
template.

I've begun to call the serialized document paired with the instance tree
a page.

I am now converting a template to a page, then reconstituting it to get
a DOM with a parallel instance tree that can be used to scavenge
directive descendants that have been removed.

In the next commit, a template will contain two documents; the template
document and the template document converted to a page, a scrap page.
Scavenging will be a function against the page where a particular
directive is unmarked, removing it from the tree but gathering it into a
document fragment. The document fragment is imported into a new
document, creating a clone that can be inserted in the new document.
Then the fragment is linked back into the scrap page.

The cloned and imported fragment is linked into the rewrite page. The
'comments` function that is used by `reconstitute` to build the parallel
instance tree is run against the descendants added to the rewrite page.

In this commit, I've updated `unmark` to optionally gather up the
unlinked nodes in a document fragment. If the last argument to unlink is
a document fragment, the fragment will be populated with the unlinked
nodes, sans the marker itself.

The `instantiate` function has been broken out of the generate function.
It is now synchronous. It descends the tree unraveling the directives
into their flattened commented form. It will get wrapped up into a
template compilation function that creates the scrap page.

The `comments` function can now be told to descend a single unraveled
directive by specifying a start node that is a marker comment. It will
stop iterating the parent node's list of children when it reaches the
end of the unravelled children of the directive.

The object returned from Stencil is now the page object itself. The user
must dereference only the document property and leave the rest alone.
Merge branch `if` into `redux`.
Renamed `abracadabra` to `rewrite`.

Closes #67.
Implement scrap page.

Implemented the scrap page mentioned in the previous commit message.
Using the scrap page to replenish a page on rewrite when a condition
requires the restoration of a document fragment that was deleted by the
previous rewrite.

Closes #58.
Merge branch `if` into `redux`.
Merge branch `redux` into `master`.