diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..8ad4835
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+*.min.js
+*.min.css
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..a652f7b
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2015 Chris Morgan <me@chrismorgan.info>
+
+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.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..c2753f1
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,16 @@
+# … and why not?
+
+.PHONY: all clean
+
+all: tty-player.min.js tty-player.min.css
+
+clean:
+	rm -f tty-player.min.js
+
+tty-player.min.js: tty-player.js
+	@echo Minifying tty-player.js...
+	@curl http://www.closure-compiler.appspot.com/compile --compressed -H 'Content-Type: application/x-www-form-urlencoded;charset=utf-8' --data compilation_level=ADVANCED_OPTIMIZATIONS --data output_format=text --data output_info=compiled_code --data-urlencode js_code@tty-player.js --data-urlencode js_externs@term.js/src/term.js > tty-player.min.js
+
+tty-player.min.css: tty-player.css
+	@echo Minifying tty-player.css...
+	@uglifycss tty-player.css > tty-player.min.css
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d561f7e
--- /dev/null
+++ b/README.md
@@ -0,0 +1,311 @@
+`<tty-player>`: `<video>`, but for ttyrec scripts
+=================================================
+
+- [Examples](#user-content-examples)
+- [Using tty-player](#user-content-using-tty-player)
+- [Browser compatibility](#user-content-browser-compatibility)
+- [Miscellaneous notes](#user-content-miscellaneous-notes)
+- [`<tty-player>` as a drop-in replacement for `<video>`](#user-content-tty-player-as-a-drop-in-replacement-for-video)
+- [Comparison of similar products](#user-content-comparison-of-similar-products)
+- [Author](#user-content-author)
+- [License](#user-content-license)
+
+Introduction
+------------
+
+Suppose you have a short screencast of doing something in a terminal. You might make a full recording of it and include it in your web page like this:
+
+```html
+<video autoplay controls loop src=tty-screencast.webm></video>
+```
+
+There are plenty of problems with doing it this way, though:
+
+- Video codecs are a pain. (Would you like to provide it in MP4, H.264, WebM, Ogg Theora, *&c.*? Do you even know what they all *mean* and which entries in that list aren’t actually codecs? Do you know what you need for decent browser compatibility?)
+- Video represents text as low-resolution images makes it harder to read;
+- You can’t select text;
+- Bandwidth requirements are ridiculously high for such a simple thing.
+
+OK, so you use something like `ttyrec` plus `ttygif` to record it and produce an animated GIF. But still:
+
+- You can’t select text;
+- The text size is fixed;
+- Anything beyond linear, looping playback is out;
+- Seriously, who uses GIFs for anything but cat videos anyway? (Don’t answer, I’m not sure I’d want to know.)
+
+This library offers the *real* solution: a player for your ttyrec scripts, implementing basically the same interface as `<video>` so that it’s almost a drop-in replacement.
+
+So here is this library: it provides a `<tty-player>` element, just like `<video>` except taking a ttyrec file as its source. (And this particular little example is only 34KB, 8KB gzipped! Take that, traditional video formats! Even this screenshot of *one frame* of that thing only scrunches to 34KB with <code>optipng -o7</code>, 31KB gzipped.) 
+
+```html
+<tty-player autoplay controls loop src=tty-screencast.ttyrec></tty-player>
+```
+
+[![A screenshot of <tty-player> in action](https://raw.githubusercontent.com/chris-morgan/tty-player/master/tty-screencast.snapshot.png)](http://tty-player.chrismorgan.info/#tty-screencast)
+
+Examples
+--------
+
+- [General examples](http://tty-player.chrismorgan.info/examples.html): a bit of everything with notes on many aspects
+- [Popcorn.js](http://tty-player.chrismorgan.info/popcorn.html): interaction with Popcorn.js (drop a <code class=prettyprint><span class=tag>&lt;tty-player&gt;</span></code> where it expects a <code class=prettyprint><span class=tag>&lt;video&gt;</span></code> and it Just Works™!)
+- [Star Wars ASCIImation](http://tty-player.chrismorgan.info/star-wars.html): large scripts, trivial styling, preloading and the <code class=prettyprint><span class=atn>poster</span></code> attribute.
+
+Using tty-player
+----------------
+
+1. Install a tool that can record your terminal appropriately.
+
+   I recommend **[termrec][]**, because it records the terminal dimensions in the file (and this library knows what to do with it).
+
+   You could also use **[ttyrec][]**, but dimensions won’t be stored. Or anything else that supports the ttyrec format.
+
+   You cannot use plain old `script` because even if it supports timing (Mac OS X’s doesn’t) it uses a different format.
+
+2. Record your terminal! I recommend using the `.ttyrec` extension, for no particularly good reason.
+
+3. Add the requirements to your web page:
+
+   - A Web Components polyfill (optional; Chrome and Opera don’t need it, nor does Firefox with `dom.webcomponents.enabled` set to true).
+
+     Polymer’s webcomponents.js, lite edition is plenty; it’s around 11KB minified and gzipped:
+     https://cdnjs.cloudflare.com/ajax/libs/webcomponentsjs/0.7.5/webcomponents-lite.min.js.
+     Remember that due to its nature it should be the first script.
+
+     (Actually this library only uses [Custom Elements](http://caniuse.com/#feat=custom-elements) and [Mutation Observer](http://caniuse.com/#feat=mutationobserver) at present, so you could be more picky if you wanted.)
+
+   - [term.js][] (sorry, I don’t know of any CDNs with it). For termrec’s size hints to work, my fork is currently needed (pending: https://github.com/chjj/term.js/pull/75)
+
+   - `tty-player.css`
+
+   - `tty-player.js` (run `make` to minify these last two; `uglifycss` required)
+
+4. Start using the `<tty-player>` element just like you’d use a `<video>` element! Make sure you use the `src` attribute; you can’t use `<source>` elements.
+
+5. Spruce the styles up, if you like. What’s there at present by way of window chrome is borrowed from my own i3 arrangement.
+
+[ttyrec]: http://0xcc.net/ttyrec/
+[termrec]: http://angband.pl/termrec.html
+[term.js]: https://github.com/chjj/term.js
+
+Browser compatibility
+---------------------
+
+Tested in current Firefox and Chromium on Linux and IE 11 on Windows.
+Should work across the board in modern browsers.
+I haven’t yet gone to the trouble of testing in a broader variety of browser,
+nor is there any semblence of a test suite.
+Ain’t the web great—if this were Real Life I’d actually feel obliged to write tests!
+
+- **tty-player.js**:
+  - General functionality: untested, but probably IE 9+
+  - Controls: uses `<input type=range>`, so IE 10+
+- **webcomponents.js**: down to at least IE10, not sure about older.
+- **term.js**: uncertain, presumed broad.
+
+Miscellaneous notes
+-------------------
+
+I like the word miscellany.
+
+Intended future feature: put an `<audio>` inside the `<tty-player>` and playback will be synchronised between them. Text tracks might be implemented as a part of this; I haven’t decided at all. In the mean time, try mixing tty-player with [Popcorn.js](http://popcornjs.org/)!
+
+`<tty-player>` as a drop-in replacement for `<video>`
+-----------------------------------------------------
+
+`<tty-player>` implements an interface which I will call `HTMLTTYPlayerElement`. Here’s its definition:
+
+```idl
+interface HTMLTTYPlayerElement : HTMLMediaElement {
+           attribute DOMString defaultTitle;
+           attribute DOMString title;
+
+  readonly attribute unsigned long cols;
+  readonly attribute unsigned long rows;
+  void resize(unsigned long cols, unsigned long rows);
+
+           attribute EventHandler ontitlechange;
+
+  // This one is straight from HTMLVideoElement.
+           attribute DOMString poster;
+
+  // s/void/avoid/
+  void pretendToBeAVideo();
+}
+```
+
+As implemented, `HTMLTTYPlayerElement` does not extend `HTMLMediaElement`, so while `document.createElement("video") instanceof HTMLMediaElement`, `!(document.createElement("tty-player") instanceof HTMLMediaElement`. For the most part it would work fine, because all the standard properties of `HTMLMediaElement.prototype` are overridden in `HTMLTTYPlayerElement.prototype`, but any that are left will be liable to blow up as soon as you touch them—accessing an unknown property would in Firefox yield a `TypeError`, for example, because it does not acknowledge my type as implementing the interface `HTMLMediaElement`. Therefore I think it is safer overall to be content with `HTMLElement`.
+
+Anyhow: because `HTMLTTYPlayerElement` implements the same interface in contents, if not in name, as `HTMLVideoElement`, it’s normally a drop-in replacement. Many things will actually work with it straight off. For those things that don’t, there’s a technique that gets even closer: `HTMLTTYPlayerElement.pretendToBeAVideo()`. This makes an `HTMLTTYPlayerElement` patch itself to implement the interface of `HTMLVideoElement` (`width`, `height`, `videoWidth` and `videoHeight`; it already has `poster`). And, for good (?) measure, to override the `tagName` property so that `this.tagName == "VIDEO"`.
+
+[**MediaElement.js**](http://mediaelementjs.com/) works pretty well with `<tty-player>`s masquerading as `<video>`s, though the handling of the poster is not perfect (you end up with two play button overlays; text posters will probably need to be rasterised with the assistance of a canvas, too).
+
+[**Popcorn.js**](http://popcornjs.org/) doesn’t need the masquerade—give it a `<tty-player>` instead of a `<video>` and it’s perfectly happy. (Some plugins might potentially need the masquerade. I haven’t tried everything.)
+
+Comparison of similar products
+------------------------------
+
+**Terminology:**
+
+- **`script -t`:** the `script` program from linux-utils, which supports `-t` (timing).
+  Linux machines will normally have it, but no one else is likely to.
+  Mac OS X has an older version of `script` without timing support.
+
+- **Poster:** what is shown in the player before you start playing a video. Typically an image that is supposed to show what the video is about.
+
+**Features not assessed:**
+
+- How do they handle Unicode? (tty-player assumes UTF-8 unless the appropriate termrec marker indicating that it is *not* UTF-8 is there, I suspect some of the others won’t handle UTF-8 properly.)
+
+### [asciinema](https://asciinema.org/)
+
+This is the only one I’ve found that doesn’t use term.js.
+
+**Format:**
+- [asciicast file format version 1](https://github.com/asciinema/asciinema/blob/master/doc/asciicast-v1.md): ah! they *specified* it! I wish more people would. JSON format very much like `script -t` with the two files merged, with a bit more information. Tweaking timing is thus easy.
+- … but the player doesn’t speak that; it speaks a proprietary format not based directly on the ANSI codes. Much of a muchness in the end, though I wouldn’t care to edit that format.
+
+**Audio:** no.
+
+**Recording:**
+- **Code:** https://github.com/asciinema/asciinema
+- **Usage:** `asciinema` with subcommands: `rec [filename]`, `play <filename>`, `upload <filename>`, `auth`. Configuration file for specifying command to execute when recording. Ability to cap wait duration between frames. Nice stuff.
+- **Dependencies:** Linux/Mac OS X. (Written in Go, distributed as binaries for various platforms.)
+
+**Hosting:** asciinema.org
+- **Code:** https://github.com/asciinema/asciinema.org
+- **Primary deployment:** https://asciinema.org/
+- **Fanciness:** quite high; also has oEmbed/Open Graph/Twitter Card support so social sharing is pretty.
+
+**Player:**
+- **Code:** https://github.com/asciinema/asciinema-player
+- **Complexity:** moderate.
+- **API:** uncertain.
+- **Dependencies:** React, JSXTransformer, jQuery—but *not* term.js.
+- **Attitude to the document:** no thinking outside the box permitted!
+- **Embedding:** [rather good](https://asciinema.org/docs/embedding); `<script>`-based, with knobs like autoplay and loop, makes an `<iframe>`; asciinema.org also produces images of the poster for including in other places (impressive!).
+- **Compatibility:** uncertain.
+- **Prettiness/usability:** quite good; even has support for three themes. However its time progress bar usability is poor.
+- **Poster:** yes, embedded into the metadata block.
+- **Window title:** no.
+- **Experience:** I found some bugs with it; for example, the one on the front page of asciinema.org didn’t work for me first time, and the script finishes with its progress bar still some 20px short of 100%, and if you click in the gap it jumps to there and “plays” indefinitely, without having updated the screen to the right place, either. Not encouraging, frankly.
+
+### [showterm](http://showterm.io/)
+
+**Format:** `script -t` plus initial screen dimensions.
+
+**Audio:** no.
+
+**Recording:**
+- **Code:** https://github.com/ConradIrwin/showterm
+- **Usage:** `showterm` records and uploads to server; using the `script -t` format, it also allows basic timing editing before uploading.
+- **Dependencies:** Ruby, `showterm` gem (it bundles `ttyrec`).
+
+**Hosting platform:**
+- **Code:** https://github.com/ConradIrwin/showterm.io
+- **Primary deployment:** http://showterm.io/, https://showterm.io/
+- **Fanciness:** none.
+
+**Player:**
+- **Code:** https://github.com/ConradIrwin/showterm.io/tree/master/app/assets
+- **Demo:** https://showterm.io/
+- **Complexity:** low.
+- **API:** nothing much.
+- **Dependencies:** jQuery, jQuery UI, term.js.
+- **Attitude to the document:** all your document are belong to us.
+- **Embedding:** `<iframe>` (problematic for getting dimensions right).
+- **Compatibility:** untested but presumed high (at least IE8+, jQuery UI holding it back).
+- **Prettiness/usability:** not *terrible*, but not magnificent either.
+- **Poster:** no.
+- **Window title:** no.
+
+### [TermRecord](https://github.com/theonewolf/TermRecord)
+
+A tool for producing self-contained HTML.
+
+**Format:** proprietary but simple (`[[text, total milliseconds]]`)
+
+**Audio:** no.
+
+**Recording:**
+- **Code:** https://github.com/theonewolf/TermRecord
+- **Usage:** `TermRecord -o filename.html`.
+- **Dependencies:** Python, jinja2, `script -t` or `ttyrec`.
+
+**Hosting:** n/a (it produces standalone HTML files)
+
+**Web client:**
+- **Code:** https://github.com/theonewolf/TermRecord/tree/master/termrecord/templates
+- **Demo:** http://theonewolf.github.io/TermRecord/demo-static.html
+- **Complexity:** low.
+- **API:** nothing worth speaking of; proprietary.
+- **Dependencies:** term.js.
+- **Attitude to the document:** I *am* the document!
+- **Embedding:** why would you bother? (`<iframe>` will work, I guess.)
+- **Compatibility:** untested but presumed very high (probably IE6+), though it’ll be uglier where `<input type=range>` isn’t supported.
+- **Prettiness/usability:** uhh… I think they went for the “functional” æsthetic. But its usability is tolerable.
+- **Poster:** no.
+- **Window title:** no.
+
+### [shelr](https://github.com/antono/shelr)
+
+Apparently abandoned.
+
+**Format:** `script -t` plus initial screen dimensions.
+
+**Audio:** no.
+
+**Recording:**
+- **Code:** https://github.com/antono/shelr
+- **Usage:** ?
+- **Dependencies:** Ruby, `shelr` gem, `ttyrec` or `script -t`.
+
+**Hosting:**
+- **Code:** https://github.com/shelr/shelr.tv
+- **Primary deployment:** was shelr.tv, but now dead.
+- **Fanciness:** high; voting, comments, *&c.*
+
+**Player:**
+- **Code:** https://github.com/shelr/shelr.tv/tree/master/app/assets/javascripts/player
+- **Complexity:** moderate.
+- **API:** moderately capable; proprietary.
+- **Dependencies:** uncertain, term.js.
+- **Attitude to the document:** tell me where to go and I’ll stay inside the lines.
+- **Embedding:** uncertain, but I imagine there’s something?
+- **Compatibility:** uncertain.
+- **Prettiness/usability:** quite good, from the screenshots.
+- **Poster:** no.
+- **Window title:** no.
+
+### tty-player
+
+(This library.)
+
+**Format:** `ttyrec` (with support for the *slightly* non-standard `termrec` UTF-8 and screen dimension indicators).
+
+**Audio:** no (but planned, having used the `HTMLMediaElement` base will make it easier).
+
+**Recording:** `termrec` (or `ttyrec`). Not good for editing, unless someone’s made a tool to do that that I haven’t noticed? I would like to make one at some point, anyway.
+
+**Hosting:** n/a (it’d be a separate project)
+
+**Player:**
+- **Code:** https://github.com/chris-morgan/tty-player
+- **Complexity:** moderate; high in some parts due to following the `HTMLMediaElement` spec.
+- **API:** `HTMLMediaElement` (standard) plus a little bit more. Can imitate `HTMLVideoElement` fairly completely if instructed to, too.
+- **Dependencies:** term.js; webcomponents-lite.js (Web Components polyfill) recommended for better browser compatibility.
+- **Attitude to the document:** thus far shall you come, and no farther. (Just like any other HTML element.)
+- **Embedding:** that’s all it *is*! `<tty-player src=foo.ttyrec></tty-player>`.
+- **Compatibility:** modern browsers plus probably IE10, maybe mostly IE9 (unverified).
+- **Prettiness/usability:** Dazzlingly marvelous! Perfect! Flawless! Staggering!
+- **Poster:** yes, <code>poster=npt:*time*</code> and it is taken from the source file at that time, or <code>poster=data:text/plain,*text with control sequences*</code>.
+- **Window title:** yes (initial value through the `window-title` attribute, can be set through ANSI codes too).
+
+Author
+------
+
+[Chris Morgan](http://chrismorgan.info/) ([chris-morgan](https://github.com/chris-morgan)) is the primary author and maintainer of tty-player.
+
+License
+-------
+
+This library is distributed under the terms of the MIT license. See LICENSE for details.
diff --git a/tty-player.css b/tty-player.css
new file mode 100644
index 0000000..0f4e0b7
--- /dev/null
+++ b/tty-player.css
@@ -0,0 +1,218 @@
+.terminal {
+	font-family: monospace, monospace;
+	cursor: text;
+	line-height: initial;
+}
+
+tty-player {
+	border: 2px solid #285577;
+	border-top: 1px solid #4c7899;
+}
+
+tty-player .title {
+	background: #285577;
+	border-bottom: 1px solid #4c7899;
+	color: #fff;
+	font-family: sans-serif;
+	font-weight: bold;
+	padding: 0.2em;
+	line-height: 1;
+	height: 1em;
+	cursor: default;
+}
+
+tty-player menu {
+	display: none;
+}
+
+tty-player {
+	display: inline-block;
+	position: relative;
+}
+
+tty-player:not([controls]) tty-player-controls {
+	display: none;
+}
+
+tty-player-poster {
+	/* XXX: <video> has an overlay with play button if [controls] over the poster *image*, but here we have an overlay with play button regardless. Perhaps specifying a poster currentTime or script might work? */
+	background: rgba(53, 47, 47, 0.5);
+	opacity: 0.5;
+	transition: opacity 0.2s linear;
+	background-repeat: no-repeat;
+	background-position: center;
+	background-image: url("data:image/svg+xml,%3C?xml%20version='1.0'%20encoding='UTF-8'%20standalone='no'?%3E%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='66'%20height='66'%3E%3Cfilter%20id='f'%3E%3CfeColorMatrix%20type='matrix'%20values='0%200%200%200%200%200%200%200%200%200%200%200%200%200%200%200%200%200%20.5%200'/%3E%3CfeGaussianBlur%20result='r'%20stdDeviation='2'/%3E%3CfeComposite%20in='SourceGraphic'%20in2='r'/%3E%3C/filter%3E%3Cpath%20fill='%23ddd'%20stroke='%23ccc'%20stroke-width='1'%20d='M33,5.5A27.5,27.5%200%200%200%205.5,33%2027.5,27.5%200%200%200%2033,60.5%2027.5,27.5%200%200%200%2060.5,33%2027.5,27.5%200%200%200%2033,5.5Zm-9.5,13%2025,14.5-25,14.5%200,-29z'%20filter='url(%23f)'/%3E%3C/svg%3E");
+	position: absolute;
+	top: 0;
+	left: 0;
+	right: 0;
+	bottom: 0;
+}
+
+tty-player[controls] tty-player-poster {
+	bottom: 28px;
+}
+
+tty-player:hover tty-player-poster {
+	opacity: 1;
+}
+
+tty-player-controls {
+	position: absolute;
+	left: 0;
+	right: 0;
+	bottom: 0;
+	background: rgba(53, 47, 47, 0.5);
+	opacity: 0;
+	display: flex;
+	flex-direction: row;
+	transition: opacity 0.2s linear;
+	cursor: default;
+}
+
+/* Browsers tend to show the controls when a <video> ends, too; I, however, am not doing this for now at least as the controls will overlap with what is often the most important part of the terminal (the bottom). For this reason, I haven’t hooked up any support for that either, only showing controls persistently when the poster is up. */
+tty-player-controls.poster,
+tty-player:hover tty-player-controls {
+	opacity: 1;
+}
+
+tty-player-controls input[type=range], tty-player-controls button {
+	margin: 0;
+	padding: 0;
+	border: none;
+	background: none;
+	font: inherit;
+	line-height: inherit;
+	-moz-appearance: none;
+	-webkit-appearance: none;
+}
+
+tty-player-controls button {
+	padding: 0;
+	background: none;
+	opacity: 0.75;
+	flex: 0 1 auto;
+	line-height: 1;
+	width: 28px;
+	height: 28px;
+}
+
+tty-player-controls button:hover {
+	color: #777;
+	opacity: 1;
+}
+
+tty-player-controls input[type=range] {
+	flex: 1;
+	height: 8px;
+	margin: 10px 5px;
+}
+
+tty-player-controls button {
+	background-repeat: no-repeat;
+	background-position: center;
+}
+
+tty-player-controls button.play {
+	background-image: url("data:image/svg+xml,%3C?xml%20version='1.0'%20encoding='UTF-8'%20standalone='no'?%3E%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='14'%20height='16'%3E%3Cpath%20fill='%23ccc'%20d='M0,0%200,16%2014,8Z'/%3E%3C/svg%3E");
+}
+
+tty-player-controls button.pause {
+	background-image: url("data:image/svg+xml,%3C?xml%20version='1.0'%20encoding='UTF-8'%20standalone='no'?%3E%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20width='14'%20height='16'%3E%3Cpath%20fill='%23ccc'%20d='M1,0L1,16L5,16L5,0L0,0zM9,0L9,16L13,16L13,0L9,0z'/%3E%3C/svg%3E");
+}
+
+tty-player-controls input[type=range]:focus {
+	box-shadow: none;
+	outline: none;
+}
+
+tty-player-controls input[type=range]::-moz-range-track,
+tty-player-controls input[type=range]::-moz-range-thumb,
+tty-player-controls input[type=range]::-moz-range-progress {
+	border-radius: 4px;
+	height: 8px;
+}
+
+tty-player-controls input[type=range]::-moz-range-track {
+	background: rgba(255, 255, 255, 0.5);
+}
+
+tty-player-controls input[type=range]::-moz-range-thumb {
+	-moz-appearance: none;
+	width: 0;
+	background: transparent;
+	border: 0;
+	border-radius: 0;
+	box-shadow: 0;
+	position: relative;
+}
+
+tty-player-controls input[type=range]::-moz-range-progress {
+	background: #fff;
+}
+
+input[type=range] {
+	overflow: hidden;
+}
+
+tty-player-controls input[type=range]::-webkit-slider-runnable-track {
+	-webkit-appearance: none;
+	height: 8px;
+	background: rgba(255, 255, 255, 0.5);
+	//border-radius: 4px;
+}
+
+tty-player-controls input[type=range]::-webkit-slider-thumb:before {
+	position: absolute;
+	top: 0;
+	right: 50%;
+	left: -9999px;
+	background: #fff;
+	content: '';
+	height: 8px;
+	pointer-events: none;
+}
+
+tty-player-controls input[type=range]::-webkit-slider-thumb {
+	-webkit-appearance: none;
+	width: 0;
+	height: 0;
+	position: relative;
+}
+
+/* I have not altered IE’s styles because I feel them already satisfactory */
+
+tty-player-controls .current-time {
+	position: absolute;
+	color: #ddd;
+	background: #888;
+	font-family: sans-serif;
+	font-size: 12px;
+	display: block;
+	box-shadow: 0 1px rgba(0, 0, 0, 0.5), 0 1px 2px rgba(0, 0, 0, 0.5), inset 0 1px rgba(255, 255, 255, 0.2);
+	padding: 0 5px;
+	line-height: 16px;
+	border-radius: 4px;
+	top: -7px;
+}
+
+tty-player-controls .current-time::after {
+	content: "";
+	position: absolute;
+	width: 8px;
+	height: 8px;
+	background: linear-gradient(-45deg, #888 50%, transparent 50%);
+	box-shadow: 1px 1px rgba(0, 0, 0, 0.5), 1px 1px 1px rgba(0, 0, 0, 0.5);
+	bottom: -3px;
+	left: 50%;
+	margin-left: -5px;
+	transform: rotate(45deg);
+}
+
+tty-player-controls .duration {
+	font-family: sans-serif;
+	font-size: 12px;
+	color: #999;
+	line-height: 18px;
+	padding: 5px;
+}
diff --git a/tty-player.js b/tty-player.js
new file mode 100644
index 0000000..d84f063
--- /dev/null
+++ b/tty-player.js
@@ -0,0 +1,1716 @@
+// W069 is “['x'] is better written in dot notation”, but Closure Compiler wants ['x'].
+// jshint -W069
+// jshint bitwise: false
+// ==ClosureCompiler==
+// @output_file_name tty-player.min.js
+// @compilation_level ADVANCED_OPTIMIZATIONS
+// ==/ClosureCompiler==
+/* global MediaError, TimeRanges, Terminal, HTMLElement */
+;(function() {
+"use strict";
+
+var textDecoder = "TextDecoder" in window ? new TextDecoder() : null;
+/// @param {Array<number>|Uint8Array} array
+function decodeUTF8(array) {
+	if (array instanceof Array || !textDecoder) {
+		return decodeURIComponent(Array.prototype.map.call(array, function(ord) {
+			return "%" + ("0" + ord.toString(16)).substr(-2);
+		}).join(""));
+	} else {
+		return textDecoder.decode(array);
+	}
+}
+
+/// parseDataURI("data:foo/bar;base64,MTIzNA==#foo") === "1234"
+/// @param {string} uri
+function parseDataURI(uri) {
+	// [whole uri, "base64" or undefined, data]
+	var chunks = /^data:([^,]*),([^#]+)/.exec(uri);
+	if (chunks === null) {
+		return null;
+	}
+	var data = decodeURIComponent(chunks[2]);
+	var mime = chunks[1].replace(/;base64$/, "");
+	return [mime, mime === chunks[1] ? data : atob(data)];
+}
+
+/// @param {Array<number>|Uint8Array} array
+function byteArrayToString(array) {
+	// String.fromCharCode.apply can for too large values overflow the call stack.
+	// Hence this, though I doubt we actually use large enough strings to worry.
+	// http://stackoverflow.com/a/12713326
+	var CHUNK_SIZE = 0x8000;
+	var c = [];
+	for (var i = 0; i < array.length; i += CHUNK_SIZE) {
+		c.push(String.fromCharCode.apply(null, array["subarray" in array ? "subarray" : "slice"](i, i + CHUNK_SIZE)));
+	}
+	return c.join("");
+}
+
+function parseNPT(npt) {
+	// Format: [npt:]([h:]mm:ss|seconds)[.subsecond]
+	// I’ve decided to be lazy and allow "1:2:3.4" as well as "1:02:03.4"
+	// This makes it [npt:][[h:]m:]s[.subsecond]
+	var match = /^(?:npt:)?(?:(?:(\d+):)?(\d+):)?(\d+(?:\.\d+)?)$/i.exec(npt);
+	return match ? (match[1] || 0) * 3600 + (match[2] || 0) * 60 + match[3] : null;
+}
+
+function classifyPosterURL(url) {
+	if (!url) {
+		// There is no poster.
+		return {type: null};
+	}
+	switch (/^(?:(.*):)?/.exec(url)[1]) {
+		case "npt":
+			var time = parseNPT(url);
+			return time ? {type: "npt", time: time} : {type: null};
+		case "data":
+			var data = parseDataURI(url);
+			if (/^text\/plain$/i.test(data[0])) {
+				return {type: "text", data: data[1]};
+			}
+	}
+	// TODO: treat all the other possibilities as images.
+	return {type: null};
+}
+
+/// @param {ArrayBuffer|Array<number>} source
+function parseTTYRec(source) {
+	var isArray = source instanceof Array;
+	var utf8 = true;
+	var dimensions = null;
+	var data = [];
+	var byteOffset = 0;
+	var timeOffset = 0;
+	var sourceLength = isArray ? source.length : source.byteLength;
+	while (byteOffset < sourceLength) {
+		var sec, usec, len;
+		if (!isArray) {
+			var header = new DataView(source, byteOffset);
+			sec = header.getUint32(0, true);
+			usec = header.getUint32(4, true);
+			len = header.getUint32(8, true);
+		} else {
+			sec = source[byteOffset] +
+				  (source[byteOffset + 1] << 8) +
+				  (source[byteOffset + 2] << 16) +
+				  (source[byteOffset + 3] << 24);
+			usec = source[byteOffset + 4] +
+				  (source[byteOffset + 5] << 8) +
+				  (source[byteOffset + 6] << 16) +
+				  (source[byteOffset + 7] << 24);
+			len = source[byteOffset + 8] +
+				  (source[byteOffset + 9] << 8) +
+				  (source[byteOffset + 10] << 16) +
+				  (source[byteOffset + 11] << 24);
+		}
+		var time = sec + (usec / 1000000);
+		byteOffset += 12;
+		var payload = isArray ? source.slice(byteOffset, byteOffset + len)
+							  : new Uint8Array(source, byteOffset, len);
+		payload = utf8 ? decodeUTF8(payload) : byteArrayToString(payload);
+		if (byteOffset === 12) {
+			// First chunk might be metadata; this is how termrec does it, for example.
+			timeOffset = time;
+			var metadata = /^\x1b%(G|@)\x1b\[8;([0-9]+);([0-9]+)t$/.exec(payload);
+			if (metadata) {
+				utf8 = metadata[1] === "G";
+				dimensions = {
+					rows: +metadata[2],
+					cols: +metadata[3]
+				};
+			}
+		}
+		time -= timeOffset;
+		byteOffset += len;
+		data.push([payload, time]);
+	}
+	return {
+		// Heuristic: if the time offset is large enough, it’s probably a timestamp.
+		startDate: timeOffset >= 1e8 ? new Date(timeOffset * 1000) : null,
+		dimensions: dimensions,
+		data: data
+	};
+}
+
+function formatTime(time) {
+	var seconds = time | 0;
+	var minutes = seconds / 60 | 0;
+	seconds = ("0" + (seconds % 60)).substr(-2);
+	if (minutes >= 60) {
+		var hours = minutes / 60 | 0;
+		minutes = ("0" + (minutes % 60)).substr(-2);
+		return hours + ":" + minutes + ":" + seconds;
+	} else {
+		return minutes + ":" + seconds;
+	}
+}
+
+function blankableAttributeProperty(name) {
+	return {
+		get: function() {
+			var value = this.getAttribute(name);
+			return value === null ? "" : value.trim();
+		},
+		set: function(value) {
+			this.setAttribute(name, value);
+		}
+	};
+}
+
+function attributeBooleanProperty(name) {
+	return {
+		get: function() {
+			return this.hasAttribute(name);
+		},
+		set: function(bool) {
+			if (bool) {
+				this.setAttribute(name, "");
+			} else {
+				this.removeAttribute(name);
+			}
+		}
+	};
+}
+
+function invalidStateError() {
+	document.createElement("video").currentTime = 1;
+}
+
+/** @const */ var NETWORK_EMPTY = 0;
+/** @const */ var NETWORK_IDLE = 1;
+/** @const */ var NETWORK_LOADING = 2;
+/** @const */ var NETWORK_NO_SOURCE = 3;
+
+/** @const */ var HAVE_NOTHING = 0;
+/** @const */ var HAVE_METADATA = 1;
+/** @const */ var HAVE_CURRENT_DATA = 2;
+/** @const */ var HAVE_FUTURE_DATA = 3;
+/** @const */ var HAVE_ENOUGH_DATA = 4;
+
+// Annoyingly, with things like MediaError, one apparently can’t construct them in any way.
+// I might need to do something like this.
+var My = {};
+// Note that the constants on MediaError are *not* on My.MediaError, though they are on instances.
+My.MediaError = /** @constructor */ function(code) {
+	Object.defineProperty(this, "code", {value: code});
+};
+My.MediaError.prototype = Object.create(MediaError.prototype);
+
+/** @const */ var EMPTY_TIME_RANGES = document.createElement("video").played;
+
+My.TimeRanges = /** @constructor */ function(ranges) {
+	Object.defineProperty(this, "length", {value: ranges.length});
+	this["_"] = ranges;
+};
+My.TimeRanges.prototype = Object.create(TimeRanges.prototype);
+
+My.TimeRanges.prototype["start"] = function(i) {
+	if (i < this["length"]) {
+		return this["_"][i][0];
+	} else {
+		return EMPTY_TIME_RANGES["end"](0);  // Throws IndexSizeError
+	}
+};
+
+My.TimeRanges.prototype["end"] = function(i) {
+	if (i < this["length"]) {
+		return this["_"][i][1];
+	} else {
+		return EMPTY_TIME_RANGES["end"](0);  // Throws IndexSizeError
+	}
+};
+
+/** @const */ var MEDIA_ERR_ABORTED = 1;
+/** @const */ var MEDIA_ERR_NETWORK = 2;
+/** @const */ var MEDIA_ERR_DECODE = 3;
+/** @const */ var MEDIA_ERR_SRC_NOT_SUPPORTED = 4;
+
+/** @const */ var ERROR_DETAILS = {
+	1: ["MEDIA_ERR_ABORTED", "The fetching process for the media resource was aborted by the user agent at the user's request."],
+	2: ["MEDIA_ERR_NETWORK", "A network error of some description caused the user agent to stop fetching the media resource, after the resource was established to be usable."],
+	3: ["MEDIA_ERR_DECODE", "An error of some description occurred while decoding the media resource, after the resource was established to be usable."],
+	4: ["MEDIA_ERR_SRC_NOT_SUPPORTED", "The media resource indicated by the \x1b[4msrc\x1b[24m attribute was not suitable."]
+};
+
+/** @const */ var FANCY_TECHNICAL_ERROR_EXPLANATIONS = true;
+
+var menuIdSequence = 0;
+
+function makeMenu(ttyPlayer) {
+	// Make a context menu with these items:
+	// - Play/Pause
+	// - Show/Hide Controls
+	//
+	// Firefox also has the following ones deemed unnecessary:
+	//
+	// - Mute/Unmute
+	// - Play Speed >
+	//   - Slow Motion (0.5×)
+	//   - Normal Speed (1×)
+	//   - High Speed (1.5×)
+	//   - Ludicrous Speed (2×)
+	// - Show Statistics
+	// - Full Screen
+	//
+	// Chrome has Show controls (lowercase c) as a toggle and adds a Loop item.
+	var menu = document.createElement("menu");
+	if (!("type" in menu)) {
+		return null;
+	}
+
+	try {
+		menu.type = "context";
+	} catch (e) {
+		// IE 11, "Invalid argument."
+	}
+	if (menu.type !== "context") {
+		return null;
+	}
+	menu.id = "treplay-contextmenu-" + menuIdSequence++;
+
+	var playPause = document.createElement("menuitem");
+	playPause.onclick = function() {
+		if (ttyPlayer["paused"]) {
+			ttyPlayer["play"]();
+		} else {
+			ttyPlayer["pause"]();
+		}
+	};
+	function setPlayPauseDetails(label, path) {
+		playPause.label = label;
+		playPause.icon = "data:image/svg+xml,%3C?xml version='1.0' encoding='UTF-8' standalone='no'?%3E%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16'%3E%3Cpath stroke='%23999' stroke-width='1' fill='%23eee' d='" + path + "'/%3E%3C/svg%3E";
+	}
+	function onPlay() {
+		setPlayPauseDetails("Pause", "m2.5,1.5 0,13 4,0 0,-13zm7,0 0,13 4,0 0,-13z");
+	}
+	function onPause() {
+		setPlayPauseDetails("Play", "m2.5,2 0,12 11,-6z");
+	}
+	onPause();
+	ttyPlayer.addEventListener("play", onPlay);
+	ttyPlayer.addEventListener("pause", onPause);
+
+	var controls = document.createElement("menuitem");
+	menu.onControlsShownOrHidden = function() {
+		if (ttyPlayer["controls"]) {
+			controls.label = "Hide Controls";
+		} else {
+			controls.label = "Show Controls";
+		}
+	};
+	menu.onControlsShownOrHidden();
+	controls.onclick = function() {
+		ttyPlayer["controls"] = !ttyPlayer["controls"];
+	};
+
+	menu.appendChild(playPause);
+	menu.appendChild(controls);
+	return menu;
+}
+
+// TODO: reset() hides the cursor; patch term.js so if useFocus === false it is shown by default?
+var stockReset = Terminal.prototype["reset"];
+Terminal.prototype["reset"] = function() {
+	stockReset.call(this);
+	if ("useFocus" in this["options"] && !this["options"]["useFocus"]) {
+		this["showCursor"]();
+	}
+};
+
+// IDL for this code:
+//
+//     interface HTMLTTYPlayerElement : HTMLMediaElement {
+//                attribute DOMString defaultTitle;
+//                attribute DOMString title;
+//
+//       readonly attribute unsigned long cols;
+//       readonly attribute unsigned long rows;
+//       void resize(unsigned long cols, unsigned long rows);
+//
+//                attribute EventHandler ontitlechange;
+//
+//       // This one is straight from HTMLVideoElement.
+//                attribute DOMString poster;
+//
+//       // s/void/avoid/
+//       void pretendToBeAVideo();
+//     }
+//
+// IDL taken from HTML 5 spec:
+//
+//     enum CanPlayTypeEnum { "" /* empty string */, "maybe", "probably" };
+//     interface HTMLMediaElement : HTMLElement {
+//     
+//       // error state
+//       readonly attribute MediaError? error;
+//     
+//       // network state
+//                attribute DOMString src;
+//       readonly attribute DOMString currentSrc;
+//                attribute DOMString crossOrigin;
+//       const unsigned short NETWORK_EMPTY = 0;
+//       const unsigned short NETWORK_IDLE = 1;
+//       const unsigned short NETWORK_LOADING = 2;
+//       const unsigned short NETWORK_NO_SOURCE = 3;
+//       readonly attribute unsigned short networkState;
+//                attribute DOMString preload;
+//       readonly attribute TimeRanges buffered;
+//       void load();
+//       CanPlayTypeEnum canPlayType(DOMString type);
+//     
+//       // ready state
+//       const unsigned short HAVE_NOTHING = 0;
+//       const unsigned short HAVE_METADATA = 1;
+//       const unsigned short HAVE_CURRENT_DATA = 2;
+//       const unsigned short HAVE_FUTURE_DATA = 3;
+//       const unsigned short HAVE_ENOUGH_DATA = 4;
+//       readonly attribute unsigned short readyState;
+//       readonly attribute boolean seeking;
+//     
+//       // playback state
+//                attribute double currentTime;
+//       readonly attribute unrestricted double duration;
+//       Date getStartDate();
+//       readonly attribute boolean paused;
+//                attribute double defaultPlaybackRate;
+//                attribute double playbackRate;
+//       readonly attribute TimeRanges played;
+//       readonly attribute TimeRanges seekable;
+//       readonly attribute boolean ended;
+//                attribute boolean autoplay;
+//                attribute boolean loop;
+//       void play();
+//       void pause();
+//     
+//       // media controller
+//                attribute DOMString mediaGroup;
+//                attribute MediaController? controller;
+//     
+//       // controls
+//                attribute boolean controls;
+//                attribute double volume;
+//                attribute boolean muted;
+//                attribute boolean defaultMuted;
+//     
+//       // tracks
+//       readonly attribute AudioTrackList audioTracks;
+//       readonly attribute VideoTrackList videoTracks;
+//       readonly attribute TextTrackList textTracks;
+//       TextTrack addTextTrack(TextTrackKind kind, optional DOMString label = "", optional DOMString language = "");
+//     };
+//
+//     interface HTMLVideoElement : HTMLMediaElement {
+//                attribute unsigned long width;
+//                attribute unsigned long height;
+//       readonly attribute unsigned long videoWidth;
+//       readonly attribute unsigned long videoHeight;
+//                attribute DOMString poster;
+//     };
+
+/** @constructor */
+function TTYPlayerInternalState(ttyPlayer) {
+	this.ttyPlayer = ttyPlayer;
+}
+
+var ISP = TTYPlayerInternalState.prototype;
+
+ISP.setUp = function() {
+	var self = this;
+	var ttyPlayer = self.ttyPlayer;
+	self.titleElement = document.createElement("div");
+	self.titleElement.className = "title";
+	ttyPlayer.appendChild(self.titleElement);
+
+	self.terminal = new Terminal({"useFocus": false});
+	self.terminal.on("title", function(newTitle) {
+		ttyPlayer["title"] = newTitle;
+	});
+
+	self.terminal.open(ttyPlayer);
+
+	if (FANCY_TECHNICAL_ERROR_EXPLANATIONS) {
+		ttyPlayer.addEventListener("error", function() {
+			var details = ERROR_DETAILS[self.error.code];
+			self.terminal.reset();
+			self.terminal.write(
+					"\x1b]2;Error :-(\x07" +
+					"\r\n\x1b[1mMediaError.\x1b[31m" + details[0] + "\x1b[m " +
+					"(numeric value " + self.error.code + ")\r\n\r\n" +
+					"    " + details[1] + "\r\n\r\n(Sorry ’bout that.)");
+		});
+	}
+
+	var rows = +ttyPlayer.getAttribute("rows");
+	var cols = +ttyPlayer.getAttribute("cols");
+	ttyPlayer["resize"](cols > 0 ? cols : ttyPlayer["cols"],
+						rows > 0 ? rows : ttyPlayer["rows"]);
+
+	// XXX: properties with names used in the DOM don’t get shrunk by Closure
+	// Compiler’s advanced optimizations, for safety. We could get size down a
+	// smidgeon more by renaming them all, but that’d be uglier.
+	// Candidates: defaultPlaybackRate, playbackRate, currentSrc, readyState, networkState, paused, duration.
+
+	self.defaultPlaybackRate = self.playbackRate = 1;
+	self.defaultPlaybackStartPosition = 0;
+	self.currentSrc = "";
+	self.readyState = HAVE_NOTHING;
+	self.networkState = NETWORK_EMPTY;
+	self.paused = true;
+	self.duration = NaN;
+	self.defaultTitle = ttyPlayer.getAttribute("window-title") || "";
+	self.posterOverlay = document.createElement("tty-player-poster");
+	self.posterOverlay.onclick = function() {
+		ttyPlayer["play"]();
+	};
+
+	self.terminal.on("resize", function() {
+		// ttyPlayer.rows and ttyPlayer.cols have changed, fire an appropriate event
+		self.fireSimpleEvent("resize");
+	});
+
+	self.menu = makeMenu(ttyPlayer);
+	if (self.menu) {
+		ttyPlayer.appendChild(self.menu);
+		ttyPlayer.setAttribute("contextmenu", self.menu.id);
+	}
+
+	self.controlsElement = document.createElement("tty-player-controls");
+	var play = document.createElement("button");
+	play.className = "play";
+	play.onclick = function() {
+		if (ttyPlayer["paused"]) {
+			ttyPlayer["play"]();
+		} else {
+			ttyPlayer["pause"]();
+		}
+	};
+	ttyPlayer.addEventListener("play", function() {
+		play.className = "pause";
+	});
+	ttyPlayer.addEventListener("pause", function() {
+		play.className = "play";
+	});
+	self.currentTimeElement = document.createElement("span");
+	self.currentTimeElement.className = "current-time";
+	self.currentTimeElement.textContent = "0:00";
+	self.durationElement = document.createElement("span");
+	self.durationElement.className = "duration";
+	self.durationElement.textContent = "0:00";
+	self.progressElement = document.createElement("input");
+	self.progressElement.type = "range";
+	self.progressElement.value = 0;
+	self.progressElement.min = 0;
+	self.progressElement.step = "any";
+	var skipChange = false;
+	self.progressElement.addEventListener("input", function() {
+		if (!skipChange) {
+			skipChange = true;
+			self.semipaused = true;
+			ttyPlayer["currentTime"] = self.progressElement.value;
+			self.updateCurrentTimeElement();
+			skipChange = false;
+		}
+	});
+	self.progressElement.addEventListener("change", function() {
+		if (!skipChange) {
+			skipChange = true;
+			self.semipaused = false;
+			ttyPlayer["currentTime"] = self.progressElement.value;
+			self.updateCurrentTimeElement();
+			skipChange = false;
+		}
+	});
+	ttyPlayer.addEventListener("durationchange", function() {
+		self.progressElement.max = self.duration;
+		self.durationElement.textContent = formatTime(self.duration);
+	});
+	ttyPlayer.addEventListener("timeupdate", function() {
+		if (!skipChange) {
+			skipChange = true;
+			self.progressElement.value = self.currentTime;
+			self.updateCurrentTimeElement();
+			skipChange = false;
+		}
+	});
+	self.controlsElement.appendChild(play);
+	self.controlsElement.appendChild(self.currentTimeElement);
+	self.controlsElement.appendChild(self.progressElement);
+	self.controlsElement.appendChild(self.durationElement);
+	ttyPlayer.appendChild(self.posterOverlay);
+	ttyPlayer.appendChild(self.controlsElement);
+	self.showPoster = true;
+};
+
+Object.defineProperties(ISP, {
+	/** @lends {ISP} */
+	showPoster: {
+		get: function() {
+			return this._showPoster;
+		},
+		set: function(newValue) {
+			// TODO: this is problematic because it doesn’t keep track of what
+			// poster is active, it just uses the current value of poster. We
+			// should probably store the value of poster and use it for
+			// removing it.
+			var self = this;
+			var oldValue = self._showPoster;
+			newValue = !!newValue;
+
+			var newPoster = classifyPosterURL(self.ttyPlayer["poster"]);
+			self._showPoster = !!newValue;
+
+			// We don’t show the overlay if there is an error
+			var showOverlay = newValue && !self.error;
+
+			self.posterOverlay.style.display = showOverlay ? "" : "none";
+			self.controlsElement.classList[showOverlay ? "add" : "remove"]("poster");
+			self.progressElement.disabled = newValue;
+			self.controlsShownOrHidden();
+
+			if (oldValue === newValue && self.activePoster === newPoster) {
+				// No change to make
+				return;
+			}
+
+			// If we need to do anything special to remove a poster, here’s what we’ll do:
+			// if (oldValue) {
+			// 	switch (self.activePoster.type) {
+			// 		case "foo":
+			// 			…
+			// 	}
+			// }
+
+			self.activePoster = newPoster;
+
+			if (oldValue || newValue) {
+				// Yes, we’re missing the optimisation possibility of poster=npt:X
+				// changing to poster=npt:Y where Y > X. Seriously, adjusting
+				// poster *at all* is rare enough that I don’t care.
+				self.resetTerminal();
+			}
+
+			if (newValue) {
+				// Show the new poster
+				switch (newPoster.type) {
+					case "npt":
+						// We have an NPT poster to create.
+						self.resetTerminal();
+
+						var realShowPoster = function() {
+							if (newValue !== self._showPoster) {
+								// Sorry, you took too long and I don’t want to do anything now;
+								// something else is doing it.
+								return;
+							}
+
+							if (newValue) {
+								var currentTime = self.currentTime;
+								var semipaused = self.semipaused;
+								self.semipaused = true;
+								self.currentTime = newPoster.time;
+								self.nextDataIndex = 0;
+								self.render();
+								self.semipaused = semipaused;
+								self.currentTime = currentTime;
+							}
+						};
+
+						if (self.data) {
+							realShowPoster();
+						} else {
+							var loaded = function() {
+								self.ttyPlayer.removeEventListener("canplaythrough", loaded);
+								realShowPoster();
+							};
+							self.ttyPlayer.addEventListener("canplaythrough", loaded);
+							self.loadIfNotLoading();
+						}
+						break;
+					case "text":
+						self.resetTerminal();
+						self.terminal.write(newPoster.data);
+				}
+			}
+		}
+	}
+});
+
+/// Firing a simple event named e means that a trusted event with the name
+/// e, which does not bubble (except where otherwise stated) and is not
+/// cancelable (except where otherwise stated), and which uses the Event
+/// interface, must be created and dispatched at the given target.
+/// INCONSISTENCY: isTrusted = false
+ISP.fireSimpleEvent = function(name) {
+	var event = document.createEvent("HTMLEvents");
+	event.initEvent(name, false, false);
+	var f = this.ttyPlayer["on" + name];
+	if (typeof f === "function") {
+		f(event);
+	}
+	this.ttyPlayer.dispatchEvent(event);
+};
+
+ISP.controlsShownOrHidden = function() {
+	this.updateCurrentTimeElement();
+	if (this.menu) {
+		this.menu.onControlsShownOrHidden();
+	}
+};
+
+ISP.updateCurrentTimeElement = function() {
+	this.currentTimeElement.textContent = formatTime(this.currentTime);
+	var left = this.progressElement.offsetLeft - (this.currentTimeElement.offsetWidth / 2);
+	if (!isNaN(this.duration)) {
+		left += this.currentTime / this.duration * this.progressElement.offsetWidth;
+	}
+	this.currentTimeElement.style.left = left + "px";
+};
+
+/** @const */ var TICK = 16;
+/** @const */ var TIME_UPDATE_FREQUENCY = 100;
+ISP.lastTimeUpdate = 0;
+
+ISP.render = function() {
+	// Should the currently rendered frame (next - 1) be drawn?
+	if (this.nextDataIndex > 0 && this.data[this.nextDataIndex - 1][1] > this.currentTime) {
+		// No, but undoing isn’t possible, so we must replay from the start.
+		// This is highly inefficient; for large scripts it’s utterly untenable.
+		this.resetTerminal();
+		this.nextDataIndex = 0;
+	}
+	while (this.nextDataIndex < this.data.length && this.data[this.nextDataIndex][1] <= this.currentTime) {
+		this.terminal.write(this.data[this.nextDataIndex][0]);
+		this.nextDataIndex++;
+	}
+
+	if (this.semipaused) {
+		return;
+	}
+
+	// Have we reached the end? Let’s stop.
+	if ((this.currentTime >= this.duration && this.playbackRate > 0) ||
+			(this.currentTime <= 0 && this.playbackRate < 0)) {
+		if (this.ttyPlayer["loop"]) {
+			this.ttyPlayer["currentTime"] = this.playbackRate > 0 ? 0 : this.duration;
+		} else {
+			this.fireSimpleEvent("timeupdate");
+			this.ttyPlayer["pause"]();
+			this.fireSimpleEvent("ended");
+		}
+	} else {
+		// Do we need to fire a timeupdate event? We should do them every 66–350ms; Firefox does 250 for video, but because the average length is going to be shorter and because I can, I’m going for 100ms.
+		var time = +new Date();
+		if (time - this.lastTimeUpdate >= TIME_UPDATE_FREQUENCY) {
+			this.lastTimeUpdate = time;
+			this.fireSimpleEvent("timeupdate");
+		}
+	}
+};
+
+ISP.resetTerminal = function() {
+	this.terminal.reset();
+	this.ttyPlayer["title"] = this.defaultTitle;
+};
+
+ISP.loadIfNotLoading = function() {
+	if (this.networkState < NETWORK_LOADING) {
+		this.mediaLoadAlgorithm();
+	}
+};
+
+ISP.mediaLoadAlgorithm = function() {
+	this.resetTerminal();
+
+	// > The media load algorithm consists of the following steps.
+
+	// > 1. Abort any already-running instance of the resource selection
+	// >    algorithm for this element.
+	if (this.resourceFetchXHR) {
+		this.resourceFetchXHR.abort();
+	}
+
+	// > 2. If there are any tasks from the media element's media element
+	// >    event task source in one of the task queues, then remove those
+	// >    tasks.
+	// >
+	// >    If there are any tasks that were queued by the resource
+	// >    selection algorithm (including the algorithms that it itself
+	// >    invokes) for this same media element from the DOM manipulation
+	// >    task source in one of the task queues, then remove those tasks.
+	// >
+	// >    Note: Basically, pending events and callbacks for the media
+	// >    element are discarded when the media element starts loading a
+	// >    new resource.
+	//
+	// [Nothing to do, we aren’t queuing events.]
+
+	// > 3. If the media element's networkState is set to NETWORK_LOADING
+	// >    or NETWORK_IDLE, queue a task to fire a simple event named
+	// >    abort at the media element.
+	if (this.networkState === NETWORK_LOADING ||
+			this.networkState === NETWORK_IDLE) {
+		this.fireSimpleEvent("abort");
+	}
+
+	// > 4. If the media element's networkState is not set to
+	// >    NETWORK_EMPTY, then run these substeps:
+	if (this.networkState !== NETWORK_EMPTY) {
+		// > 1. Queue a task to fire a simple event named emptied at the
+		// >    media element.
+		this.fireSimpleEvent("emptied");
+
+		// > 2. If a fetching process is in progress for the media element,
+		// >    the user agent should stop it.
+		// TODO.
+
+		// > 3. Forget the media element's media-resource-specific tracks.
+		// [Not applicable.]
+
+		// > 4. If readyState is not set to HAVE_NOTHING, then set it to
+		// >    that state.
+		this.readyState = HAVE_NOTHING;
+
+		// > 5. If the paused attribute is false, then set it to true.
+		this.paused = true;
+		clearInterval(this.ticker);
+
+		// > 6. If seeking is true, set it to false.
+		// [Not applicable.]
+
+		// > 7. Set the current playback position to 0.
+		// >
+		// >    Set the official playback position to 0.
+		// >
+		// >    If this changed the official playback position, then queue
+		// >    a task to fire a simple event named timeupdate at the
+		// >    media element.
+		var oldTime = this.currentTime;
+		this.currentTime = 0;
+		this.nextDataIndex = 0;
+		if (oldTime !== 0) {
+			this.fireSimpleEvent("timeupdate");
+		}
+
+		// > 8. Set the initial playback position to 0.
+		// Not applicable (TODO? Might be useful?)
+
+		// > 9. Set the timeline offset to Not-a-Number (NaN).
+		// TODO (haven’t finished supporting timeline offsets)
+
+		// > 10. Update the duration attribute to Not-a-Number (NaN).
+		// >
+		// >     The user agent will not fire a durationchange event for
+		// >     this particular change of the duration.
+		this.data = null;
+		this.duration = NaN;
+	}
+
+	// > 5. Set the playbackRate attribute to the value of the defaultPlaybackRate attribute.
+	this.playbackRate = this.defaultPlaybackRate;
+
+	// > 6. Set the error attribute to null and the autoplaying flag to true.
+	this.error = null;
+	// TODO.
+
+	// > 7. Invoke the media element's resource selection algorithm.
+	this.resourceSelectionAlgorithm();
+
+	// > 8. Note: Playback of any previously playing media resource for this element stops.
+	// Already done.
+};
+
+ISP.resourceSelectionAlgorithm = function() {
+	var self = this;
+	// We use a simplified version of the resource selection algorithm,
+	// as we support only one type, don’t use <source> (src only) and
+	// handle synchronosity differently.
+
+	// > 1. Set the element's networkState attribute to the
+	// >    NETWORK_NO_SOURCE value.
+	self.networkState = NETWORK_NO_SOURCE;
+
+	// > 2. Set the element's show poster flag to true.
+	self.showPoster = true;
+
+	// > 3. Set the media element's delaying-the-load-event flag to
+	// >    true (this delays the load event).
+	// TODO.
+
+	// > 4. Asynchronously await a stable state, allowing the task that
+	// >    invoked this algorithm to continue. The synchronous section
+	// >    consists of all the remaining steps of this algorithm until
+	// >    the algorithm says the synchronous section has ended.
+	// >    (Steps in synchronous sections are marked with ⌛.)
+
+	// > 5. ⌛ If the media element's blocked-on-parser flag is false,
+	// >    then populate the list of pending text tracks.
+	// [Not applicable.]
+
+	// > 6. ⌛ If the media element has a src attribute, then let mode
+	// >    be attribute.
+	// >
+	// >    ⌛ Otherwise, if the media element does not have a src
+	// >    attribute but has a source element child, then let mode be
+	// >    children and let candidate be the first such source element
+	// >    child in tree order.
+	// >
+	// >    ⌛ Otherwise the media element has neither a src attribute
+	// >    nor a source element child: set the networkState to
+	// >    NETWORK_EMPTY, and abort these steps; the synchronous
+	// >    section ends.
+	//
+	// We don’t support <source> at present, so this is simpler.
+	var src = self.ttyPlayer.getAttribute("src");
+	if (src === null) {
+		self.networkState = NETWORK_EMPTY;
+		return;
+	}
+
+	// > 7. ⌛ Set the media element's networkState to NETWORK_LOADING.
+	self.networkState = NETWORK_LOADING;
+
+	// > 8. ⌛ Queue a task to fire a simple event named loadstart at
+	// >    the media element.
+	self.fireSimpleEvent("loadstart");
+
+	// > 9. If mode is attribute, then run these substeps:
+	// [We don’t support <source>, so this is guaranteed.]
+
+	// > 1. ⌛ If the src attribute's value is the empty string, then
+	// >    end the synchronous section, and jump down to the failed
+	// >    with attribute step below.
+	if (src === "") {
+		return self.resourceSelectionAlgorithmFailedWithAttribute();
+	}
+
+	// > 2. ⌛ Let absolute URL be the absolute URL that would have
+	// >    resulted from resolving the URL specified by the src
+	// >    attribute's value relative to the media element when the
+	// >    src attribute was last changed.
+	var absoluteURL = new URL(src.trim(), self.ttyPlayer.baseURI);
+
+	// > 3. ⌛ If absolute URL was obtained successfully, set the
+	// >    currentSrc attribute to absolute URL.
+	self.currentSrc = absoluteURL.toString();
+
+	// > 4. End the synchronous section, continuing the remaining steps
+	// >    asynchronously.
+	setTimeout(function() {
+
+		// > 5. If absolute URL was obtained successfully, run the resource
+		// >    fetch algorithm with absolute URL. If that algorithm
+		// >    returns without aborting this one, then the load failed.
+		// Due to the simpler model used, supporting aborting isn’t necessary.
+		self.resourceFetchAlgorithm();
+	}, 0);
+};
+
+ISP.resourceSelectionAlgorithmFailedWithAttribute = function() {
+	// > 6. Failed with attribute: Reaching this step indicates that
+	// >    the media resource failed to load or that the given URL
+	// >    could not be resolved. Queue a task to run the following
+	// >    steps, using the DOM manipulation task source:
+
+	// >     1. Set the error attribute to a new MediaError object whose code attribute is set to MEDIA_ERR_SRC_NOT_SUPPORTED.
+	this.error = new My.MediaError(MEDIA_ERR_SRC_NOT_SUPPORTED);
+
+	// >     2. Forget the media element's media-resource-specific tracks.
+	// [Nothing to do.]
+
+	// >     3. Set the element's networkState attribute to the NETWORK_NO_SOURCE value.
+	this.networkState = NETWORK_NO_SOURCE;
+
+	// >     4. Set the element's show poster flag to true.
+	this.showPoster = true;
+
+	// >     5. Fire a simple event named error at the media element.
+	this.fireSimpleEvent("error");
+
+	// >     6. Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
+	//this.delayingTheLoadEvent = false;
+
+	// > 7. Wait for the task queued by the previous step to have executed.
+	// [Not queueing tasks, so nothing to do.]
+
+	// > 8. Abort these steps. Until the load() method is invoked or the src attribute is changed, the element won't attempt to load another resource.
+};
+
+ISP.resourceFetchAlgorithm = function() {
+	var self = this;
+	function finishResourceFetchAlgorithm() {
+		delete self.resourceFetchXHR;
+	}
+
+	function continueResourceFetchAlgorithm(data) {
+		// > Once enough of the media data has been fetched to determine
+		// > the duration of the media resource, its dimensions, and other
+		// > metadata:
+		// >
+		// > This indicates that the resource is usable. The user agent
+		// > must follow these substeps:
+		// >
+		// > 1. Establish the media timeline for the purposes of the
+		// >    current playback position, the earliest possible position,
+		// >    and the initial playback position, based on the media data.
+		// [TODO support such things?]
+
+		// > 2. Update the timeline offset to the date and time that
+		// >    corresponds to the zero time in the media timeline
+		// >    established in the previous step, if any. If no explicit
+		// >    time and date is given by the media resource, the timeline
+		// >    offset must be set to Not-a-Number (NaN).
+		// [Nothing to do.]
+
+		// > 3. Set the current playback position and the official playback
+		// >    position to the earliest possible position.
+		self.currentTime = 0;
+		self.nextDataIndex = 0;
+
+		// > 4. Update the duration attribute with the time of the last
+		// >    frame of the resource, if known, on the media timeline
+		// >    established above. If it is not known (e.g. a stream that
+		// >    is in principle infinite), update the duration attribute to
+		// >    the value positive Infinity.
+		// >
+		// >    Note: The user agent will queue a task to fire a simple
+		// >    event named durationchange at the element at this point.
+		self.data = data.data;
+		self.duration = data.data.length === 0 ? 0 : data.data[data.data.length - 1][1];
+		self.fireSimpleEvent("durationchange");
+
+		// > 5. For video elements, set the videoWidth and videoHeight
+		// >    attributes, and queue a task to fire a simple event named
+		// >    resize at the media element.
+		// >
+		// >    Note: Further resize events will be fired if the dimensions
+		// >    subsequently change.
+		// TODO: allow this to be written on the HTML
+		// TODO: modify the file format to track window sizes, then do
+		// something like this (ttyWidth and ttyHeight, in chars, I
+		// think).
+		// These are taken straight from term.js; TODO: modify it to send resize events.
+		if (data.dimensions) {
+			self.ttyPlayer["resize"](data.dimensions.cols, data.dimensions.rows);
+		}
+
+		// XXX: the spec mentions getStartDate(), which data.startDate
+		// covers, but Firefox and Chrome at least (dunno about others)
+		// don’t implement that, so I’m not doing anything with it yet.
+
+		// We could render the first frame if we wanted to. Should we?
+		//self.render();
+
+		// > 6. Set the readyState attribute to HAVE_METADATA.
+		// >
+		// >    Note: A loadedmetadata DOM event will be fired as part of
+		// >    setting the readyState attribute to a new value.
+		self.readyState = HAVE_METADATA;
+		self.fireSimpleEvent("loadedmetadata");
+
+		// > 7. Let jumped be false.
+		var jumped = false;
+
+		// > 8. If the media element's default playback start position is
+		// >    greater than zero, then seek to that time, and let jumped
+		// >    be true.
+		if (self.defaultPlaybackStartPosition > 0) {
+			self.currentTime = self.defaultPlaybackStartPosition;
+			jumped = true;
+		}
+
+		// > 9. Let the media element's default playback start position be
+		// >    zero.
+		self.defaultPlaybackStartPosition = 0;
+
+		// > 10. If either the media resource or the address of the current
+		// >     media resource indicate a particular start time, then set
+		// >     the initial playback position to that time and, if jumped
+		// >     is still false, seek to that time and let jumped be true.
+		// >
+		// >     For example, with media formats that support the Media
+		// >     Fragments URI fragment identifier syntax, the fragment
+		// >     identifier can be used to indicate a start position.
+		// >     [MEDIAFRAG]
+		// TODO: support Media Fragments, e.g. ?t=a,b#t=c will trim the
+		// range to [a, b) seconds, starting at c seconds into that range,
+		// ?t=,b is [0, b); ?t=a is [a, end), it uses NPT.
+
+		// > 11. If either the media resource or the address of the current
+		// >     media resource indicate a particular set of audio or video
+		// >     tracks to enable, or if the user agent has information
+		// >     that would enable it to select specific tracks to improve
+		// >     the user's experience, then the relevant audio tracks must
+		// >     be enabled in the element's audioTracks object, and, of
+		// >     the relevant video tracks, the one that is listed first in
+		// >     the element's videoTracks object must be selected. All
+		// >     other tracks must be disabled.
+		// >
+		// >     This could again be triggered by Media Fragments URI
+		// >     fragment identifier syntax, but it could also be triggered
+		// >     e.g. by the user agent selecting a 5.1 surround sound
+		// >     audio track over a stereo audio track. [MEDIAFRAG]
+		// [Not applicable.]
+
+		// > 12. If the media element has a current media controller, then:
+		// >     if jumped is true and the initial playback position,
+		// >     relative to the current media controller's timeline, is
+		// >     greater than the current media controller's media
+		// >     controller position, then seek the media controller to the
+		// >     media element's initial playback position, relative to the
+		// >     current media controller's timeline; otherwise, seek the
+		// >     media element to the media controller position, relative
+		// >     to the media element's timeline.
+		// [Not applicable.]
+
+		// >    Once the readyState attribute reaches HAVE_CURRENT_DATA, after the loadeddata event has been fired, set the element's delaying-the-load-event flag to false. This stops delaying the load event.
+		// >
+		// >    A user agent that is attempting to reduce network usage while still fetching the metadata for each media resource would also stop buffering at this point, following the rules described previously, which involve the networkState attribute switching to the NETWORK_IDLE value and a suspend event firing.
+		// >
+		// >    The user agent is required to determine the duration of the media resource and go through this step before playing.
+
+		// > Once the entire media resource has been fetched (but
+		// > potentially before any of it has been decoded)
+		// >
+		// >    Fire a simple event named progress at the media element.
+		self.fireSimpleEvent("progress");
+
+		// >    Set the networkState to NETWORK_IDLE and fire a simple event named suspend at the media element.
+		self.networkState = NETWORK_IDLE;
+		self.fireSimpleEvent("suspend");
+
+		// >    If the user agent ever discards any media data and then needs to resume the network activity to obtain it again, then it must queue a task to set the networkState to NETWORK_LOADING.
+		// [This won’t happen.]
+
+		// >    If the user agent can keep the media resource loaded, then the algorithm will continue to its final step below, which aborts the algorithm.
+
+		// The description of when this is supposed to happen is
+		// surprisingly unclear. Hopefully this will do.
+		self.readyState = HAVE_ENOUGH_DATA;
+		self.fireSimpleEvent("loadeddata");
+		self.fireSimpleEvent("canplay");
+		self.fireSimpleEvent("canplaythrough");
+
+		finishResourceFetchAlgorithm();
+	}
+
+	function handleResponse(xhr, useResponseText) {
+		if (xhr.status === 200) {
+			var data;
+			try {
+				/** @type {Array<number>|ArrayBuffer} */
+				var response;
+				if (useResponseText) {
+					var string = xhr.responseText;
+					response = [];
+					for (var i = 0; i < string.length; i++) {
+						response.push(string.charCodeAt(i) & 0xff);
+					}
+				} else {
+					response = xhr.response;
+				}
+
+				data = parseTTYRec(response);
+				// TODO: add a bit of validation/sanity checking?
+			} catch (e) {
+				// window.console && console.warn && console.warn("parseTTYRec failed: ", e);
+				// > If the media data can be fetched but is found by
+				// > inspection to be in an unsupported format, or can
+				// > otherwise not be rendered at all
+				// > [Give up and go back to resource selection, which
+				// > we don’t need to return to due to our design.]
+				finishResourceFetchAlgorithm();
+				self.resourceSelectionAlgorithmFailedWithAttribute();
+				return;
+			}
+
+			// TODO: implement something like this:
+			//
+			// > If the media resource is found to have a video track
+			// >
+			// > 1. Create a VideoTrack object to represent the
+			// >    video track.
+			// >
+			// > 2. Update the media element's videoTracks
+			// >    attribute's VideoTrackList object with the new
+			// >    VideoTrack object.
+			// >
+			// > 3. Fire a trusted event with the name addtrack,
+			// >    that does not bubble and is not cancelable, and
+			// >    that uses the TrackEvent interface, with the
+			// >    track attribute initialized to the new
+			// >    VideoTrack object, at this VideoTrackList
+			// >    object.
+			continueResourceFetchAlgorithm(data);
+		} else {
+			// > If the media data cannot be fetched at all, due to
+			// > network errors, causing the user agent to give up
+			// > trying to fetch the resource
+			// > [Give up and go back to resource selection, which
+			// > we don’t need to return to due to our design.]
+			finishResourceFetchAlgorithm();
+			self.resourceSelectionAlgorithmFailedWithAttribute();
+			return;
+		}
+	}
+
+	// > 1. Let the current media resource be the resource given by the
+	// >    absolute URL passed to this algorithm. This is now the
+	// >    element's media resource.
+	// current media resource = self.currentSrc
+
+	// > 2. Remove all media-resource-specific text tracks from the
+	// >    media element's list of pending text tracks, if any.
+	// [Nothing to do.]
+
+	// > 3. Optionally, run the following substeps. This is the expected
+	// >    behavior if the user agent intends to not attempt to fetch
+	// >    the resource until the user requests it explicitly (e.g. as
+	// >    a way to implement the preload attribute's none keyword).
+	// [Substeps omitted as I don’t wish to implement no-preload.]
+
+	// > 4. Perform a potentially CORS-enabled fetch of the current
+	// >    media resource's absolute URL, with the mode being the
+	// >    state of the media element's crossorigin content attribute,
+	// >    the origin being the origin of the media element's
+	// >    Document, and the default origin behaviour set to taint.
+	// >
+	//
+	// [Vast swathes of text follow, mostly irrelevant as we load the
+	// entire resource at once; we don’t need to bother about the
+	// "stalled" and "suspend" events, and won’t bother for now about
+	// "progress" every 350±200ms/every byte (whichever is least
+	// frequent)]
+	//
+	// INCORRECTNESS: the window’s origin is used instead of the media
+	// element’s document’s. Security prevents doing this right.
+	// Dunno about the taint bit.
+
+	// Past here we go laissez-faire, mostly ignoring the specs.
+
+	var useResponseText;
+
+	// Some browsers (Firefox, Chrome) allow you to use data URIs with
+	// an XMLHttpRequest, others (IE) don’t.
+	// To be sure, let’s parse it ourself. (TODO: assess perf.)
+	var data = parseDataURI(self.currentSrc);
+	if (data !== null) {
+		handleResponse({status: 200, responseText: data[1]}, true);
+	} else {
+		var xhr = new XMLHttpRequest();
+		if (self.ttyPlayer["crossOrigin"] === "use-credentials") {
+			xhr.withCredentials = true;
+		} else if (self.ttyPlayer["crossOrigin"] === "anonymous" && "mozAnon" in xhr) {
+			// INCORRECTNESS: no anonymous support outside Firefox.
+			// (No one has implemented AnonXMLHttpRequest ☹.)
+			xhr.mozAnon = true;
+		}
+		xhr.onabort = finishResourceFetchAlgorithm;
+		xhr.open("GET", self.currentSrc);
+		useResponseText = !("responseType" in xhr);
+		xhr.responseType = "arraybuffer";
+		if (xhr.responseType !== "arraybuffer") {
+			useResponseText = true;
+		}
+		if (useResponseText) {
+			xhr.overrideMimeType("text/plain; charset=x-user-defined");
+			xhr.onreadystatechange = function() {
+				if (xhr.readyState === 4) {
+					handleResponse(xhr, true);
+				}
+			};
+		} else {
+			xhr.onload = xhr.onerror = function() { handleResponse(xhr, false); };
+		}
+		self.resourceFetchXHR = xhr;
+		try {
+			xhr.send();
+		} catch (e) {
+			// e.g. relative URL on file: in some browsers.
+			handleResponse(xhr, undefined);
+		}
+	}
+};
+
+var TTYPlayerPrototype = Object.create(HTMLElement.prototype);
+
+TTYPlayerPrototype["createdCallback"] = function() {
+	this["_"] = new TTYPlayerInternalState(this);
+	this["_"].setUp();
+
+	// TODO: put no-preload in load(), as defined, rather than here.
+	// As it stands, changing src will preload even though it need not.
+	if (this["preload"] !== "none") {
+		this["load"]();
+	}
+
+	if (this["autoplay"]) {
+		this["play"]();
+	}
+};
+
+TTYPlayerPrototype["attributeChangedCallback"] = function(name) {
+	if (name === "src" && this.hasAttribute("src")) {
+		this["pause"]();
+		// > If a src attribute of a media element is set or changed, the user
+		// > agent must invoke the media element's media element load
+		// > algorithm. (Removing the src attribute does not do this, even if
+		// > there are source elements present.)
+		this["load"]();
+	} else if (name === "controls" && this.hasAttribute("controls")) {
+		// While the controls are display: none, the position of
+		// this element is garbage, so we need to fix it now.
+		this["_"].controlsShownOrHidden();
+	} else if (name === "poster") {
+		// Update the poster if necessary.
+		//
+		// > If the specified resource is to be used, then, when the element is
+		// > created or when the poster attribute is set, changed, or removed,
+		// > the user agent must run the following steps to determine the
+		// > element's poster frame (regardless of the value of the element's
+		// > show poster flag):
+		//
+		// Due to the poster=npt:… possibility and how we could otherwise palm
+		// it off to the browser, we *do* actually regard the show poster flag
+		// in deciding whether to “run these steps”.
+		this["_"].showPoster = this["_"].showPoster;
+	}
+};
+
+TTYPlayerPrototype["attachedCallback"] = function() {
+	this["_"].controlsShownOrHidden();
+};
+
+Object.defineProperties(TTYPlayerPrototype, {
+	/** @lends {TTYPlayerPrototype} */
+
+	/// @idl readonly attribute MediaError? error;
+	"error": {
+		get: function() {
+			return this["_"].error;
+		}
+	},
+
+	/// @idl attribute DOMString src;
+	"src": {
+		get: function() {
+			// It needs to be an absolute URL, and we’re not doing <source> tags,
+			// so src and currentSrc will actually always be the same.
+			return this["_"].currentSrc;
+		},
+		set: function(value) {
+			this.setAttribute("src", value);
+		}
+	},
+
+	/// @idl readonly attribute DOMString currentSrc;
+	"currentSrc": {
+		get: function() {
+			return this["_"].currentSrc;
+		}
+	},
+
+	/// @idl attribute DOMString crossOrigin;
+	"crossOrigin": {
+		get: function() {
+			var value = this.getAttribute("crossorigin");
+			if (value === null || value === "anonymous" || value === "use-credentials") {
+				return value;
+			} else {
+				return "anonymous";
+			}
+		},
+		set: function(value) {
+			if (value === null) {
+				this.removeAttribute("crossorigin");
+			} else if (value === "use-credentials") {
+				this.setAttribute("crossorigin", value);
+			} else {
+				// "" == invalid value == "anonymous"
+				this.setAttribute("crossorigin", "anonymous");
+			}
+		}
+	},
+
+	/// @idl const unsigned short NETWORK_EMPTY = 0;
+	"NETWORK_EMPTY": { value: 0 },
+
+	/// @idl const unsigned short NETWORK_IDLE = 1;
+	"NETWORK_IDLE": { value: 1 },
+
+	/// @idl const unsigned short NETWORK_LOADING = 2;
+	"NETWORK_LOADING": { value: 2 },
+
+	/// @idl const unsigned short NETWORK_NO_SOURCE = 3;
+	"NETWORK_NO_SOURCE": { value: 3 },
+
+	/// @idl readonly attribute unsigned short networkState;
+	"networkState": {
+		get: function() {
+			return this["_"].networkState;
+		}
+	},
+
+	/// @idl attribute DOMString preload;
+	"preload": {
+		get: function() {
+			var value = this.getAttribute("preload");
+			if (value === "none" || value === "metadata" || value === "auto") {
+				return value;
+			} else {
+				// "" == auto, nothing is said about malformed values, and the missing value default is user-agent defined and we have no use for Metadata.
+				return "auto";
+			}
+		},
+		set: function(value) {
+			if (value === "none" || value === "metadata" || value === "auto") {
+				this.setAttribute("metadata", value);
+			} else {
+				this.removeAttribute("metadata");
+			}
+		}
+	},
+
+	/// @idl readonly attribute TimeRanges buffered;
+	"buffered": {
+		get: function() {
+			return this["seekable"];
+		}
+	},
+
+	// Although they sit here in the IDL, load() and canPlayType() are defined
+	// later because they’re methods, not properties.
+
+	/// @idl const unsigned short HAVE_NOTHING = 0;
+	"HAVE_NOTHING": { value: 0 },
+
+	/// @idl const unsigned short HAVE_METADATA = 1;
+	"HAVE_METADATA": { value: 1 },
+
+	/// @idl const unsigned short HAVE_CURRENT_DATA = 2;
+	"HAVE_CURRENT_DATA": { value: 2 },
+
+	/// @idl const unsigned short HAVE_FUTURE_DATA = 3;
+	"HAVE_FUTURE_DATA": { value: 3 },
+
+	/// @idl const unsigned short HAVE_ENOUGH_DATA = 4;
+	"HAVE_ENOUGH_DATA": { value: 4 },
+
+	/// @idl readonly attribute unsigned short readyState;
+	"readyState": {
+		get: function() {
+			return this["_"].readyState;
+		}
+	},
+
+	/// @idl readonly attribute boolean seeking;
+	// I’m sloppily ignoring the whole seeking thing. Meh, it’s fast, hopefully no one cares about the seeking and seeked events? (TODO evaluate further.)
+	"seeking": {
+		value: false
+	},
+
+	/// @idl attribute double currentTime;
+	"currentTime": {
+		get: function() {
+			return this["_"].currentTime;
+		},
+		set: function(newTime) {
+			if (!this["_"].data) {
+				throw invalidStateError();
+			}
+			this["_"].currentTime = Math.max(0, Math.min(newTime, this["duration"]));
+			this["_"].render();
+		}
+	},
+
+	/// @idl readonly attribute unrestricted double duration;
+	"duration": {
+		get: function() {
+			return this["_"].duration;
+		}
+	},
+
+	// @idl Date getStartDate();
+	// Firefox and Chrome don’t implement this on HTMLMediaElement, so I’m skipping it for now.
+
+	/// @idl readonly attribute boolean paused
+	"paused": {
+		get: function() {
+			return this["_"].paused;
+		}
+	},
+
+	/// @idl attribute double defaultPlaybackRate;
+	"defaultPlaybackRate": {
+		get: function() {
+			return this["_"].defaultPlaybackRate;
+		},
+		set: function(rate) {
+			rate = +rate;
+			var notify = this["_"].defaultPlaybackRate !== rate;
+			this["_"].defaultPlaybackRate = rate;
+			if (notify) {
+				this["_"].fireSimpleEvent("ratechange");
+			}
+		}
+	},
+
+	/// @idl attribute double playbackRate;
+	"playbackRate": {
+		get: function() {
+			return this["_"].playbackRate;
+		},
+		set: function(rate) {
+			rate = +rate;
+			var notify = this["_"].playbackRate !== rate;
+			this["_"].playbackRate = rate;
+			if (notify) {
+				this["_"].fireSimpleEvent("ratechange");
+			}
+		}
+	},
+
+	/// @idl readonly attribute TimeRanges played;
+	/// @stub Tracking which ranges have been played would take effort!
+	"played": {
+		value: EMPTY_TIME_RANGES
+	},
+
+	/// @idl readonly attribute TimeRanges seekable;
+	"seekable": {
+		get: function() {
+			if (this["readyState"] === HAVE_ENOUGH_DATA) {
+				return new My.TimeRanges([0, this["duration"]]);
+			} else {
+				return EMPTY_TIME_RANGES;
+			}
+		}
+	},
+
+	/// @idl readonly attribute boolean ended;
+	"ended": {
+		get: function() {
+			// XXX: I’m guessing these semantics, haven’t checked them.
+			return this["paused"] && this["currentTime"] === (this["playbackRate"] < 0 ? 0 : this["duration"]);
+		}
+	},
+
+	/// @idl attribute boolean autoplay;
+	"autoplay": attributeBooleanProperty("autoplay"),
+
+	/// @idl attribute boolean loop;
+	"loop": attributeBooleanProperty("loop"),
+
+	// play() and pause() are simple properties and so appear later
+
+	// @idl attribute DOMString mediaGroup;
+	// Firefox and Chrome don’t implement this on HTMLMediaElement, so I’m skipping it for now.
+
+	// @idl attribute MediaController? controller;
+	// Firefox and Chrome don’t implement this on HTMLMediaElement, so I’m skipping it for now.
+
+	/// @idl attribute boolean controls;
+	"controls": attributeBooleanProperty("controls"),
+
+	// volume and muted are simple properties and so appear later
+
+	/// @idl attribute boolean defaultMuted;
+	/// @stub volume is irrelevant
+	"defaultMuted": attributeBooleanProperty("muted"),
+
+	// @idl readonly attribute AudioTrackList audioTracks;
+	// Firefox and Chrome don’t implement this on HTMLMediaElement, so I’m skipping it for now.
+
+	// @idl readonly attribute VideoTrackList videoTracks;
+	// Firefox and Chrome don’t implement this on HTMLMediaElement, so I’m skipping it for now.
+
+	/// @idl readonly attribute TextTrackList textTracks;
+	/// @stub text tracks aren’t implemented yet—will they be?
+	"textTracks": {
+		get: function() {
+			return document.createElement("video").textTracks;
+		}
+	},
+
+	// addTextTrack() is a simple property and so is added later.
+
+	// The remainder is things that are not part of HTMLMediaElement, as noted earlier.
+
+	/// The window title.
+	///
+	/// @idl attribute DOMString title;
+	"title": {
+		get: function() {
+			return this["_"].titleElement.textContent;
+		},
+		set: function(value) {
+			this["_"].titleElement.textContent = value;
+			this["_"].fireSimpleEvent("titlechange");
+		}
+	},
+
+	/// defaultTitle is to title as defaultRateChange is to rateChange.
+	///
+	/// @idl attribute DOMString defaultTitle;
+	"defaultTitle": {
+		get: function() {
+			return this["_"].defaultTitle;
+		},
+		set: function(value) {
+			this["_"].defaultTitle = value;
+			this["_"].fireSimpleEvent("titlechange");
+		}
+	},
+
+	/// The number of columns in the terminal.
+	/// This is like HTMLVideoElement.videoWidth but not in pixels.
+	///
+	/// Read-only as it’s rarely altered alone; use this.resize(cols, this.rows) instead.
+	"cols": {
+		get: function() {
+			return this["_"].terminal.cols;
+		}
+	},
+
+	/// The number of rows in the terminal.
+	/// This is like HTMLVideoElement.videoHeight but not in pixels.
+	///
+	/// Read-only as it’s rarely altered alone; use this.resize(this.cols, rows) instead.
+	"rows": {
+		get: function() {
+			return this["_"].terminal.rows;
+		}
+	},
+
+	// Borrowed from HTMLVideoElement.
+	/// @idl attribute DOMString poster;
+	"poster": {
+		get: function() {
+			return (this.getAttribute("poster") || "").trim();
+		},
+		set: function(value) {
+			this.setAttribute("poster", value);
+		}
+	}
+});
+
+// Here are the simple properties that don’t go in the defineProperties block above.
+
+/// @idl void load();
+TTYPlayerPrototype["load"] = function() {
+	this["_"].mediaLoadAlgorithm();
+};
+
+/// @idl CanPlayTypeEnum canPlayType(DOMString type);
+/// @stub we only support one format at present, anyway.
+TTYPlayerPrototype["canPlayType"] = function() {
+	return "maybe";
+};
+
+/// @idl void play();
+TTYPlayerPrototype["play"] = function() {
+	var self = this;
+
+	function realPlay() {
+		if (self["ended"]) {
+			self["currentTime"] = self["playbackRate"] < 0 ? self["duration"] : 0;
+		}
+		self["_"].showPoster = false;
+		self["_"].paused = false;
+		var lastTime = new Date();
+		self["_"].ticker = setInterval(function() {
+			var newTime = new Date();
+			if (!self["_"].semipaused) {
+				self["currentTime"] += (newTime - lastTime) / 1000 * self["playbackRate"];
+			}
+			lastTime = newTime;
+		}, TICK);
+		self["_"].fireSimpleEvent("play");
+	}
+
+	function loaded() {
+		self.removeEventListener("loadeddata", loaded);
+		realPlay();
+	}
+
+	if (this["_"].paused) {
+		if (this["_"].data) {
+			realPlay();
+		} else {
+			this.addEventListener("loadeddata", loaded);
+			this["_"].loadIfNotLoading();
+		}
+	}
+};
+
+/// @idl void pause();
+TTYPlayerPrototype["pause"] = function() {
+	if (!this["_"].paused) {
+		this["_"].paused = true;
+		clearInterval(this["_"].ticker);
+		this["_"].fireSimpleEvent("pause");
+	}
+};
+
+/// @idl attribute double volume;
+/// @stub volume is irrelevant
+TTYPlayerPrototype["volume"] = 1;
+
+/// @idl attribute boolean muted;
+/// @stub volume is irrelevant
+TTYPlayerPrototype["muted"] = false;
+
+/// @idl TextTrack addTextTrack(TextTrackKind kind, optional DOMString label = "", optional DOMString language = "");
+/// @stub text tracks aren’t implemented yet—will they be?
+TTYPlayerPrototype["addTextTrack"] = function() {
+	return null;
+};
+// This should theoretically go on HTMLElement.prototype. Too bad.
+/// @idl attribute EventHandler ontitlechange;
+TTYPlayerPrototype["ontitlechange"] = null;
+
+TTYPlayerPrototype["resize"] = function(x, y) {
+	this["_"].terminal.resize(x, y);
+};
+
+TTYPlayerPrototype["pretendToBeAVideo"] = function() {
+	Object.defineProperties(this, {
+		/** @lends {TTYPlayerPrototype} */
+
+		// Let’s pretend (badly) that we’re an HTMLVideoElement!
+		"tagName": {value: "VIDEO"},
+		"width": {
+			get: function() {
+				return this.offsetWidth;
+			},
+			set: function(value) {
+				// TODO this is a little poor as a technique, refine it.
+				this.style.fontSize = "100%";
+				this.style.fontSize = (value / this.offsetWidth * 100) + "%";
+			}
+		},
+		"height": {
+			get: function() {
+				return this.offsetHeight;
+			},
+			set: function(value) {
+				// TODO this is a little poor as a technique, refine it.
+				this.style.fontSize = "100%";
+				this.style.fontSize = (value / this.offsetHeight * 100) + "%";
+			}
+		},
+		"videoWidth": {
+			get: function() {
+				return this["width"];
+			}
+		},
+		"videoHeight": {
+			get: function() {
+				return this["height"];
+			}
+		}
+	});
+};
+
+document.registerElement("tty-player", {prototype: TTYPlayerPrototype});
+})();
diff --git a/tty-screencast.snapshot.png b/tty-screencast.snapshot.png
new file mode 100644
index 0000000..f2cd038
Binary files /dev/null and b/tty-screencast.snapshot.png differ
diff --git a/tty-screencast.ttyrec b/tty-screencast.ttyrec
new file mode 100644
index 0000000..254a686
Binary files /dev/null and b/tty-screencast.ttyrec differ