First draft implementation (committed for reference) for GIF decoder.
Support for for LZW compression (although intentionally bad performance),
and bliting frames (although currently hardcoded for BGRA buffers).
Performance is very slow, the implementation is meant as a reference point
before applying optimizations.
GIF decoder, improve performance by more than 100x.

This is the simplest and biggest optimization, before even getting into more
details of the algorithm and the table, we can simple be a bit better about how
we manage writing out the index stream.  Preallocate the entire index buffer,
which is known because it should match the expected number of pixels.
This removes the incremental building of the index buffer (via concat()s).  This
was causing the runtime to spend 90% of the time in memmove() via ArrayConcat.

Performance of a test frame went from 800ms to around 6ms.
GIF reader, support comment blocks.
Don't capture the comment data for now, just parse through the block.
Try to parse all application blocks, not just Netscape blocks.
We don't actually understand non-Netscape blocks, but we will at least hopefully
be able to make it past them.
Inline try_read_another_byte to the only caller.
Good for performance, removes the ugly name, and simplifies the logic a bit.
Implement chasing scheme code decoder code table.
This avoids arrays of arrays and array concats all together.
Doesn't make much of a big difference on benchmarks but opens the possibility
for some more optimizations that will make a big difference.  Plus it is a much
more elegant approach overall.
Reorganize backwards rewriting a bit.
Avoids an extra lookup if you don't need it, and makes it a bit closer to the
style of the length chase.
When writing backwards, we might as well do the extra k in order also.
I guess this could help on some very small level with the cache.
Try to follow the spec more closely when during a full table.
According to the spec there doesn't need to be a following clear, the decoder
can continue to run on a full table but just stop creating new entries.
Additionally tuck the code growth code inside since it could only happen
when a new entry was created.
Move code_table to a TypedArray.
Switch to a Int32Array (maybe better than Uint32?).  Since we shouldn't
actually ever look up a bare byte (we always check it against clear_code), we
don't actually need to initialize the table.  And the same holds for when the
table should be cleared, we don't actually need to touch the table, we will
just overwrite the old entries.
Move the index stream to a TypedArray (Uint8Array).
This is about an additional 6x performance gain.  I am considering removing the
index stream all together (and blitting directly during LZW decode), but I am
not sure the benefit would be worth the additional complexity.  Additionally
it would be nice to have an interface that can return the indices (w/o blit).
Have two versions for BGRA and RGBA blitting.
I tried a generic version (taking the pixel offsets and strides), but it took
a huge performance hit (almost 2x).  For now copy and paste.
Some support towards blitting non-full frames.
Export width and height properties (for the whole image, not individual frames).
Calculate the proper buffer starting pointer, scanline lengths, and strides.
Additionally expose the frame delay value.
Add back in output buffer length check.
Add some comments about the chase code.
Add a simple animated gif player in Plask.
Still a few unfinished pieces (like disposal).