From a07eac432af686e3f3f127d25f07ef274c54bb40 Mon Sep 17 00:00:00 2001
From: Rich Harris <richard.a.harris@gmail.com>
Date: Fri, 29 Mar 2019 21:49:31 -0400
Subject: [PATCH] update API reference docs (#2206)

---
 site/content/docs/00-introduction.md          |    9 +
 site/content/docs/01-component-format.md      |  193 ++++
 site/content/docs/02-template-syntax.md       | 1000 +++++++++++++++++
 site/content/docs/03-run-time.md              |  550 +++++++++
 site/content/docs/04-compile-time.md          |  291 +++++
 .../_old_docs}/02-template-syntax.md          |    0
 .../_old_docs}/03-scoped-styles.md            |    0
 .../{guide => docs/_old_docs}/04-behaviour.md |    0
 .../_old_docs}/05-nested-components.md        |    0
 .../_old_docs}/06-special-components.md       |    0
 .../{guide => docs/_old_docs}/07-events.md    |    0
 .../{guide => docs/_old_docs}/08-bindings.md  |    0
 .../_old_docs}/09-transitions.md              |    0
 .../{guide => docs/_old_docs}/10-actions.md   |    0
 .../{guide => docs/_old_docs}/11-classes.md   |    0
 .../_old_docs}/14-module-context.md           |    0
 .../_old_docs}/15-server-side-rendering.md    |    0
 .../_old_docs}/16-state-management.md         |    0
 .../_old_docs}/17-preprocessing.md            |    0
 .../{guide => docs/_old_docs}/18-advanced.md  |    0
 .../_old_docs}/19-custom-elements.md          |    0
 .../_old_docs}/20-miscellaneous.md            |    0
 .../_old_docs}/98-api-reference.md            |    0
 .../_old_docs}/99-still-to-come.md            |    0
 site/content/guide/0-important-note.md        |    7 -
 site/content/guide/00-introduction.md         |  112 --
 site/src/routes/about.svelte                  |    7 -
 .../blog/[slug].js => blog/[slug].json.js}    |    0
 site/src/routes/blog/[slug].svelte            |    2 +-
 site/src/routes/{api => }/blog/_posts.js      |    2 +-
 .../{api/blog/index.js => blog/index.json.js} |    0
 site/src/routes/blog/index.svelte             |    2 +-
 site/src/routes/blog/rss.xml.js               |    2 +-
 site/src/routes/docs/_GuideContents.svelte    |   38 +-
 site/src/routes/docs/_sections.js             |   80 +-
 site/src/routes/docs/demo/[hash].json.js      |   22 -
 site/src/routes/docs/index.svelte             |   98 +-
 site/static/global.css                        |    2 +-
 site/static/prism.css                         |    2 +-
 site/static/repl-viewer.css                   |    2 +-
 src/compile/index.ts                          |    2 +-
 .../action-custom-event-handler/expected.js   |    6 +-
 test/js/samples/action/expected.js            |    6 +-
 test/js/samples/bind-online/expected.js       |    6 +-
 test/js/samples/bind-width-height/expected.js |    6 +-
 .../expected.js                               |    6 +-
 .../component-static-array/expected.js        |    6 +-
 .../component-static-immutable/expected.js    |    6 +-
 .../component-static-immutable2/expected.js   |    6 +-
 test/js/samples/component-static/expected.js  |    6 +-
 .../samples/computed-collapsed-if/expected.js |    6 +-
 test/js/samples/css-media-query/expected.js   |    6 +-
 .../css-shadow-dom-keyframes/expected.js      |    6 +-
 test/js/samples/debug-empty/expected.js       |   10 +-
 .../debug-foo-bar-baz-things/expected.js      |   28 +-
 test/js/samples/debug-foo/expected.js         |   16 +-
 test/js/samples/debug-ssr-foo/expected.js     |    4 +-
 .../samples/deconflict-builtins/expected.js   |    6 +-
 .../js/samples/deconflict-globals/expected.js |    6 +-
 .../expected.js                               |   10 +-
 test/js/samples/do-use-dataset/expected.js    |    6 +-
 .../samples/dont-invalidate-this/expected.js  |    6 +-
 .../dont-use-dataset-in-legacy/expected.js    |    6 +-
 .../dont-use-dataset-in-svg/expected.js       |    6 +-
 test/js/samples/dynamic-import/expected.js    |    6 +-
 .../each-block-array-literal/expected.js      |    6 +-
 .../each-block-changed-check/expected.js      |    6 +-
 .../each-block-keyed-animated/expected.js     |    6 +-
 test/js/samples/each-block-keyed/expected.js  |    6 +-
 .../event-handler-no-passive/expected.js      |    6 +-
 test/js/samples/event-modifiers/expected.js   |    6 +-
 .../js/samples/head-no-whitespace/expected.js |    6 +-
 test/js/samples/hoisted-const/expected.js     |    6 +-
 test/js/samples/hoisted-let/expected.js       |    6 +-
 .../js/samples/if-block-no-update/expected.js |    6 +-
 test/js/samples/if-block-simple/expected.js   |    6 +-
 .../expected.js                               |    6 +-
 .../inline-style-optimized-url/expected.js    |    6 +-
 .../inline-style-optimized/expected.js        |    6 +-
 .../inline-style-unoptimized/expected.js      |    6 +-
 test/js/samples/input-files/expected.js       |    6 +-
 test/js/samples/input-range/expected.js       |    6 +-
 .../input-without-blowback-guard/expected.js  |    6 +-
 .../expected.js                               |    6 +-
 .../expected.js                               |    6 +-
 .../expected.js                               |    6 +-
 .../expected.js                               |    6 +-
 test/js/samples/legacy-input-type/expected.js |    6 +-
 test/js/samples/media-bindings/expected.js    |    6 +-
 .../non-imported-component/expected.js        |    6 +-
 .../samples/non-mutable-reference/expected.js |    6 +-
 .../expected.js                               |    6 +-
 .../expected.js                               |    6 +-
 .../samples/select-dynamic-value/expected.js  |    6 +-
 test/js/samples/setup-method/expected.js      |    6 +-
 .../samples/ssr-no-oncreate-etc/expected.js   |    4 +-
 .../samples/ssr-preserve-comments/expected.js |    4 +-
 test/js/samples/svg-title/expected.js         |    6 +-
 test/js/samples/title/expected.js             |    6 +-
 test/js/samples/transition-local/expected.js  |    6 +-
 .../use-elements-as-anchors/expected.js       |    6 +-
 .../samples/window-binding-scroll/expected.js |    6 +-
 102 files changed, 2364 insertions(+), 459 deletions(-)
 create mode 100644 site/content/docs/00-introduction.md
 create mode 100644 site/content/docs/01-component-format.md
 create mode 100644 site/content/docs/02-template-syntax.md
 create mode 100644 site/content/docs/03-run-time.md
 create mode 100644 site/content/docs/04-compile-time.md
 rename site/content/{guide => docs/_old_docs}/02-template-syntax.md (100%)
 rename site/content/{guide => docs/_old_docs}/03-scoped-styles.md (100%)
 rename site/content/{guide => docs/_old_docs}/04-behaviour.md (100%)
 rename site/content/{guide => docs/_old_docs}/05-nested-components.md (100%)
 rename site/content/{guide => docs/_old_docs}/06-special-components.md (100%)
 rename site/content/{guide => docs/_old_docs}/07-events.md (100%)
 rename site/content/{guide => docs/_old_docs}/08-bindings.md (100%)
 rename site/content/{guide => docs/_old_docs}/09-transitions.md (100%)
 rename site/content/{guide => docs/_old_docs}/10-actions.md (100%)
 rename site/content/{guide => docs/_old_docs}/11-classes.md (100%)
 rename site/content/{guide => docs/_old_docs}/14-module-context.md (100%)
 rename site/content/{guide => docs/_old_docs}/15-server-side-rendering.md (100%)
 rename site/content/{guide => docs/_old_docs}/16-state-management.md (100%)
 rename site/content/{guide => docs/_old_docs}/17-preprocessing.md (100%)
 rename site/content/{guide => docs/_old_docs}/18-advanced.md (100%)
 rename site/content/{guide => docs/_old_docs}/19-custom-elements.md (100%)
 rename site/content/{guide => docs/_old_docs}/20-miscellaneous.md (100%)
 rename site/content/{guide => docs/_old_docs}/98-api-reference.md (100%)
 rename site/content/{guide => docs/_old_docs}/99-still-to-come.md (100%)
 delete mode 100644 site/content/guide/0-important-note.md
 delete mode 100644 site/content/guide/00-introduction.md
 delete mode 100644 site/src/routes/about.svelte
 rename site/src/routes/{api/blog/[slug].js => blog/[slug].json.js} (100%)
 rename site/src/routes/{api => }/blog/_posts.js (93%)
 rename site/src/routes/{api/blog/index.js => blog/index.json.js} (100%)
 delete mode 100644 site/src/routes/docs/demo/[hash].json.js

diff --git a/site/content/docs/00-introduction.md b/site/content/docs/00-introduction.md
new file mode 100644
index 0000000000..4730a0c1d5
--- /dev/null
+++ b/site/content/docs/00-introduction.md
@@ -0,0 +1,9 @@
+---
+title: Before we begin
+---
+
+> Temporary note: This document is a work-in-progress. Please forgive any missing or misleading parts, and don't be shy about asking for help in the [Discord chatroom](https://discord.gg/yy75DKs).  The [tutorial](tutorial) is more complete; start there.
+
+This page contains detailed API reference documentation. It's intended to be a resource for people who already have some familiarity with Svelte.
+
+If that's not you (yet), you may prefer to visit the [interactive tutorial](tutorial) or the [examples](examples) before consulting this reference.
diff --git a/site/content/docs/01-component-format.md b/site/content/docs/01-component-format.md
new file mode 100644
index 0000000000..f001fee6aa
--- /dev/null
+++ b/site/content/docs/01-component-format.md
@@ -0,0 +1,193 @@
+---
+title: Component format
+---
+
+---
+
+Components are the building blocks of Svelte applications. They are written into `.svelte` files, using a superset of HTML.
+
+All three sections — script, styles and markup — are optional.
+
+```html
+<script>
+	// logic goes here
+</script>
+
+<style>
+	/* styles go here */
+</style>
+
+<!-- markup (zero or more items) goes here -->
+```
+
+### &lt;script&gt;
+
+A `<script>` block contains JavaScript that runs when a component instance is created. Variables declared (or imported) at the top level are 'visible' from the component's markup. There are four additional rules:
+
+#### 1. `export` creates a component prop
+
+---
+
+Svelte uses the `export` keyword to mark a variable declaration as a *property* or *prop*, which means it becomes accessible to consumers of the component:
+
+```html
+<script>
+	// these properties can be set externally
+	export let foo;
+	export let bar = 'optional default value';
+
+	// Values that are passed in as props
+	// are immediately available
+	console.log(foo, bar);
+
+	// function declarations cannot be set externally,
+	// but can be accessed from outside
+	export function instanceMethod() {
+		alert(foo);
+	}
+</script>
+```
+
+#### 2. Assignments are 'reactive'
+
+---
+
+To change component state and trigger a re-render, just assign to a locally declared variable.
+
+Update expressions (`count += 1`) and property assignments (`obj.x = y`) have the same effect.
+
+```html
+<script>
+	let count = 0;
+
+	function handleClick () {
+		// calling this function will trigger a re-render
+		// if the markup references `count`
+		count = count + 1;
+	}
+</script>
+```
+
+#### 3. `$:` marks a statement as reactive
+
+---
+
+Any top-level statement (i.e. not inside a block or a function) can be made reactive by prefixing it with the `$:` label. Reactive statements run immediately before the component updates, whenever the values that they depend on have changed.
+
+```html
+<script>
+	export let title;
+
+	// this will update `document.title` whenever
+	// the `title` prop changes
+	$: document.title = title;
+
+	$: {
+		console.log(`multiple statements can be combined`);
+		console.log(`the current title is ${title}`);
+	}
+</script>
+```
+
+---
+
+If a statement consists entirely of an assignment to an undeclared variable, Svelte will inject a `let` declaration on your behalf.
+
+```html
+<script>
+	export let num;
+
+	// we don't need to declare `squared` and `cubed`
+	// — Svelte does it for us
+	$: squared = num * num;
+	$: cubed = squared * num;
+</script>
+```
+
+#### 4. Prefix stores with `$` to access their values
+
+---
+
+Any time you have a reference to a store, you can access its value inside a component by prefixing it with the `$` character. This causes Svelte to declare the prefixed variable, and set up a store subscription that will be unsubscribed when appropriate.
+
+Note that the store must be declared at the top level of the component — not inside an `if` block or a function, for example.
+
+Local variables (that do not represent store values) must *not* have a `$` prefix.
+
+```html
+<script>
+	import { writable } from 'svelte/store';
+
+	const count = writable(0);
+	console.log($count); // logs 0
+
+	count.set(1);
+	console.log($count); // logs 1
+</script>
+```
+
+
+### &lt;script context="module"&gt;
+
+---
+
+A `<script>` tag with a `context="module"` attribute runs once when the module first evaluates, rather than for each component instance. Values declared in this block are accessible from a regular `<script>` (and the component markup) but not vice versa.
+
+You can `export` bindings from this block, and they will become exports of the compiled module.
+
+You cannot `export default`, since the default export is the component itself.
+
+```html
+<script context="module">
+	let totalComponents = 0;
+
+	// this allows an importer to do e.g.
+	// `import Example, { alertTotal } from './Example.svelte'`
+	export function alertTotal() {
+		alert(totalComponents);
+	}
+</script>
+
+<script>
+	totalComponents += 1;
+	console.log(`total number of times this component has been created: ${totalComponents}`);
+</script>
+```
+
+
+### &lt;style&gt;
+
+---
+
+CSS inside a `<style>` block will be scoped to that component.
+
+This works by adding a class to affected elements, which is based on a hash of the component styles (e.g. `svelte-123xyz`).
+
+```html
+<style>
+	p {
+		/* this will only affect <p> elements in this component */
+		color: burlywood;
+	}
+</style>
+```
+
+---
+
+To apply styles to a selector globally, use the `:global(...)` modifier.
+
+```html
+<style>
+	:global(body) {
+		/* this will apply to <body> */
+		margin: 0;
+	}
+
+	div :global(strong) {
+		/* this will apply to all <strong> elements, in any
+			 component, that are inside <div> elements belonging
+			 to this component */
+		color: goldenrod;
+	}
+</style>
+```
\ No newline at end of file
diff --git a/site/content/docs/02-template-syntax.md b/site/content/docs/02-template-syntax.md
new file mode 100644
index 0000000000..8778694789
--- /dev/null
+++ b/site/content/docs/02-template-syntax.md
@@ -0,0 +1,1000 @@
+---
+title: Template syntax
+---
+
+
+### Tags
+
+---
+
+A lowercase tag, like `<div>`, denotes a regular HTML element. A capitalised tag, such as `<Widget>`, indicates a *component*.
+
+```html
+<script>
+	import Widget from './Widget.svelte';
+</script>
+
+<div>
+	<Widget/>
+</div>
+```
+
+
+### Attributes
+
+---
+
+By default, attributes work exactly like their HTML counterparts.
+
+```html
+<div class="foo">
+	<button disabled>can't touch this</button>
+</div>
+```
+
+---
+
+As in HTML, values may be unquoted.
+
+```html
+<input type=checkbox>
+```
+
+---
+
+Attribute values can contain JavaScript expressions.
+
+```html
+<a href="page/{p}">page {p}</a>
+```
+
+---
+
+Or they can *be* JavaScript expressions.
+
+```html
+<button disabled={!clickable}>...</button>
+```
+
+---
+
+An expression might include characters that would cause syntax highlighting to fail in regular HTML, so quoting the value is permitted. The quotes do not affect how the value is parsed:
+
+```html
+<button disabled="{number !== 42}">...</button>
+```
+
+---
+
+When the attribute name and value match (`name={name}`), they can be replaced with `{name}`.
+
+```html
+<!-- These are equivalent -->
+<button disabled={disabled}>...</button>
+<button {disabled}>...</button>
+```
+
+---
+
+*Spread attributes* allow many attributes or properties to be passed to an element or component at once.
+
+An element or component can have multiple spread attributes, interspersed with regular ones.
+
+```html
+<Widget {...things}/>
+```
+
+
+### Text expressions
+
+* `{expression}`
+
+---
+
+Text can also contain JavaScript expressions:
+
+```html
+<h1>Hello {name}!</h1>
+<p>{a} + {b} = {a + b}.</p>
+```
+
+
+### HTML expressions
+
+* `{@html expression}`
+
+---
+
+In a text expression, characters like `<` and `>` are escaped. With HTML expressions, they're not.
+
+> Svelte does not sanitize expressions before injecting HTML. If the data comes from an untrusted source, you must sanitize it, or you are exposing your users to an XSS vulnerability.
+
+```html
+<div class="blog-post">
+	<h1>{post.title}</h1>
+	{@html post.content}
+</div>
+```
+
+
+### If blocks
+
+* `{#if expression}...{/if}`
+* `{#if expression}...{:else if expression}...{/if}`
+* `{#if expression}...{:else}...{/if}`
+
+---
+
+Content that is conditionally rendered can be wrapped in an if block.
+
+```html
+{#if answer === 42}
+	<p>what was the question?</p>
+{/if}
+```
+
+---
+
+Additional conditions can be added with `{:else if expression}`, optionally ending in an `{:else}` clause.
+
+```html
+{#if porridge.temperature > 100}
+	<p>too hot!</p>
+{:else if 80 > porridge.temperature}
+	<p>too cold!</p>
+{:else}
+	<p>just right!</p>
+{/if}
+```
+
+
+### Each blocks
+
+* `{#each expression as name}...{/each}`
+* `{#each expression as name, index}...{/each}`
+* `{#each expression as name, index (key)}...{/each}`
+* `{#each expression as name}...{:else}...{/each}`
+
+---
+
+Iterating over lists of values can be done with an each block.
+
+```html
+<h1>Shopping list</h1>
+<ul>
+	{#each items as item}
+		<li>{item.name} x {item.qty}</li>
+	{/each}
+</ul>
+```
+
+---
+
+An each block can also specify an *index*, equivalent to the second argument in an `array.map(...)` callback:
+
+```html
+{#each items as item, i}
+	<li>{i + 1}: {item.name} x {item.qty}</li>
+{/each}
+```
+
+---
+
+If a *key* expression is provided — which must uniquely identify each list item — Svelte will use it to diff the list when data changes, rather than adding or removing items at the end.
+
+```html
+{#each items as item, i (item.id)}
+	<li>{i + 1}: {item.name} x {item.qty}</li>
+{/each}
+```
+
+---
+
+You can freely use destructuring patterns in each blocks.
+
+```html
+{#each items as { id, name, qty }, i (id)}
+	<li>{i + 1}: {name} x {qty}</li>
+{/each}
+```
+
+---
+
+An each block can also have an `{:else}` clause, which is rendered if the list is empty.
+
+```html
+{#each todos as todo}
+	<p>{todo.text}</p>
+{:else}
+	<p>No tasks today!</p>
+{/each}
+```
+
+
+### Await blocks
+
+* `{#await expression}...{:then name}...{:catch name}...{/await}`
+* `{#await expression}...{:then name}...{/await}`
+* `{#await expression then name}...{/await}`
+
+---
+
+Await blocks allow you to branch on the three possible states of a Promise — pending, fulfilled or rejected.
+
+```html
+{#await promise}
+	<!-- promise is pending -->
+	<p>waiting for the promise to resolve...</p>
+{:then value}
+	<!-- promise was fulfilled -->
+	<p>The value is {value}</p>
+{:catch error}
+	<!-- promise was rejected -->
+	<p>Something went wrong: {error.message}</p>
+{/await}
+```
+
+---
+
+The `catch` block can be omitted if you don't need to render anything when the promise rejects (or no error is possible).
+
+```html
+{#await promise}
+	<!-- promise is pending -->
+	<p>waiting for the promise to resolve...</p>
+{:then value}
+	<!-- promise was fulfilled -->
+	<p>The value is {value}</p>
+{/await}
+```
+
+---
+
+If you don't care about the pending state, you can also omit the initial block.
+
+```html
+{#await promise then value}
+	<p>The value is {value}</p>
+{/await}
+```
+
+
+### DOM events
+
+* `on:eventname={handler}`
+* `on:eventname|modifiers={handler}`
+
+---
+
+Use the `on:` directive to listen to DOM events.
+
+```html
+<script>
+	let count = 0;
+
+	function handleClick(event) {
+		count += 1;
+	}
+</script>
+
+<button on:click={handleClick}>
+	count: {count}
+</button>
+```
+
+---
+
+Handlers can be declared inline with no performance penalty. As with attributes, directive values may be quoted for the sake of syntax highlighters.
+
+```html
+<button on:click="{() => count += 1}">
+	count: {count}
+</button>
+```
+
+---
+
+Add *modifiers* to DOM events with the `|` character.
+
+The following modifiers are available:
+
+* `preventDefault` — calls `event.preventDefault()` before running the handler
+* `stopPropagation` — calls `event.stopPropagation()`, preventing the event reaching the next element
+* `passive` — improves scrolling performance on touch/wheel events (Svelte will add it automatically where it's safe to do so)
+* `capture` — fires the handler during the *capture* phase instead of the *bubbling* phase
+* `once` — remove the handler after the first time it runs
+
+Modifiers can be chained together, e.g. `on:click|once|capture={...}`.
+
+```html
+<form on:submit|preventDefault={handleSubmit}>
+	<!-- the `submit` event's default is prevented,
+	     so the page won't reload -->
+</form>
+```
+
+---
+
+If the `on:` directive is used without a value, the component will *forward* the event, meaning that a consumer of the component can listen for it.
+
+```html
+<button on:click>
+	The component itself will emit the click event
+</button>
+```
+
+
+### Component events
+
+* `on:eventname={handler}`
+
+---
+
+Components can emit events using [createEventDispatcher](#docs/createEventDispatcher), or by forwarding DOM events. Listening for component events looks the same as listening for DOM events:
+
+```html
+<SomeComponent on:whatever={handler}/>
+```
+
+
+
+### Element bindings
+
+* `bind:property={value}`
+
+---
+
+Data ordinarily flows down, from parent to child. The `bind:` directive allows data to flow the other way, from child to parent. Most bindings are specific to particular elements.
+
+The simplest bindings reflect the value of a property, such as `input.value`.
+
+```html
+<input bind:value={name}>
+<textarea bind:value={text}></textarea>
+
+<input type="checkbox" bind:checked={yes}>
+```
+
+---
+
+If the name matches the value, you can use a shorthand.
+
+```html
+<!-- These are equivalent -->
+<input bind:value={value}>
+<input bind:value>
+```
+
+---
+
+Numeric input values are coerced; even though `input.value` is a string as far as the DOM is concerned, Svelte will treat it as a number. If the input is empty or invalid (in the case of `type="number"`), the value is `undefined`.
+
+```html
+<input type="number" bind:value={num}>
+<input type="range" bind:value={num}>
+```
+
+---
+
+Inputs that work together can use `bind:group`.
+
+```html
+<script>
+	let tortilla = 'Plain';
+	let fillings = [];
+</script>
+
+<!-- grouped radio inputs are mutually exclusive -->
+<input type="radio" bind:group={tortilla} value="Plain">
+<input type="radio" bind:group={tortilla} value="Whole wheat">
+<input type="radio" bind:group={tortilla} value="Spinach">
+
+<!-- grouped checkbox inputs populate an array -->
+<input type="checkbox" bind:group={fillings} value="Rice">
+<input type="checkbox" bind:group={fillings} value="Beans">
+<input type="checkbox" bind:group={fillings} value="Cheese">
+<input type="checkbox" bind:group={fillings} value="Guac (extra)">
+```
+
+---
+
+A `<select>` value binding corresponds to the `value` property on the selected `<option>`, which can be any value (not just strings, as is normally the case in the DOM).
+
+```html
+<select bind:value={selected}>
+	<option value={a}>a</option>
+	<option value={b}>b</option>
+	<option value={c}>c</option>
+</select>
+```
+
+---
+
+A `<select multiple>` element behaves similarly to a checkbox group.
+
+```html
+<select multiple bind:value={fillings}>
+	<option value="Rice">Rice</option>
+	<option value="Beans">Beans</option>
+	<option value="Cheese">Cheese</option>
+	<option value="Guac (extra)">Guac (extra)</option>
+</select>
+```
+
+---
+
+When the value of an `<option>` matches its text content, the attribute can be omitted.
+
+```html
+<select multiple bind:value={fillings}>
+	<option>Rice</option>
+	<option>Beans</option>
+	<option>Cheese</option>
+	<option>Guac (extra)</option>
+</select>
+```
+
+---
+
+Media elements (`<audio>` and `<video>`) have their own set of bindings — four *readonly* ones...
+
+* `duration` (readonly) — the total duration of the video, in seconds
+* `buffered` (readonly) — an array of `{start, end}` objects
+* `seekable` (readonly) — ditto
+* `played` (readonly) — ditto
+
+...and three *two-way* bindings:
+
+* `currentTime` — the current point in the video, in seconds
+* `paused` — this one should be self-explanatory
+* `volume` — a value between 0 and 1
+
+```html
+<video
+	src={clip}
+	bind:duration
+	bind:buffered
+	bind:seekable
+	bind:played
+	bind:currentTime
+	bind:paused
+	bind:volume
+></video>
+```
+
+---
+
+Block-level elements have readonly `clientWidth`, `clientHeight`, `offsetWidth` and `offsetHeight` bindings, measured using a technique similar to [this one](http://www.backalleycoder.com/2013/03/18/cross-browser-event-based-element-resize-detection/).
+
+```html
+<div bind:offsetWidth={width} bind:offsetHeight={height}>
+	<Chart {width} {height}/>
+</div>
+```
+
+---
+
+To get a reference to a DOM node, use `bind:this`.
+
+```html
+<script>
+	import { onMount } from 'svelte';
+
+	let canvasElement;
+
+	onMount(() => {
+		const ctx = canvasElement.getContext('2d');
+		drawStuff(ctx);
+	});
+</script>
+
+<canvas bind:this={canvasElement}></canvas>
+```
+
+
+### Component bindings
+
+* `bind:property={value}`
+
+---
+
+You can bind to component props using the same mechanism.
+
+```html
+<Keypad bind:value={pin}/>
+```
+
+---
+
+Components also support `bind:this`, allowing you to interact with component instances programmatically.
+
+> Note that we can do `{cart.empty}` rather than `{() => cart.empty()}`, since component methods are closures. You don't need to worry about the value of `this` when calling them.
+
+```html
+<ShoppingCart bind:this={cart}/>
+
+<button on:click={cart.empty}>
+	Empty shopping cart
+</button>
+```
+
+
+### Classes
+
+* `class:name={value}`
+* `class:name`
+
+---
+
+A `class:` directive provides a shorter way of toggling a class on an element.
+
+```html
+<!-- These are equivalent -->
+<div class="{active ? 'active' : ''}">...</div>
+<div class:active={active}>...</div>
+
+<!-- Shorthand, for when name and value match -->
+<div class:active>...</div>
+```
+
+
+### Actions
+
+* `use:action`
+* `use:action={parameters}`
+
+```js
+action = (node: HTMLElement, parameters: any) => {
+	update?: (parameters: any) => void,
+	destroy?: () => void
+}
+```
+
+---
+
+Actions are functions that are called when an element is created. They can return an object with a `destroy` method that is called after the element is unmounted:
+
+```html
+<script>
+	function foo(node) {
+		// the node has been mounted in the DOM
+
+		return {
+			destroy() {
+				// the node has been removed from the DOM
+			}
+		};
+	}
+</script>
+
+<div use:foo></div>
+```
+
+---
+
+An action can have parameters. If the returned value has an `update` method, it will be called whenever those parameters change, immediately after Svelte has applied updates to the markup.
+
+> Don't worry about the fact that we're redeclaring the `foo` function for every component instance — Svelte will hoist any functions that don't depend on local state out of the component definition.
+
+```html
+<script>
+	export let bar;
+
+	function foo(node, bar) {
+		// the node has been mounted in the DOM
+
+		return {
+			update(bar) {
+				// the value of `bar` has changed
+			},
+
+			destroy() {
+				// the node has been removed from the DOM
+			}
+		};
+	}
+</script>
+
+<div use:foo={bar}></div>
+```
+
+
+### Transitions
+
+* `transition:name`
+* `transition:name={params}`
+* `transition:name|local`
+* `transition:name|local={params}`
+* `in:name`
+* `in:name={params}`
+* `in:name|local`
+* `in:name|local={params}`
+* `out:name`
+* `out:name={params}`
+* `out:name|local`
+* `out:name|local={params}`
+
+```js
+transition = (node: HTMLElement, params: any) => {
+	delay?: number,
+	duration?: number,
+	easing?: (t: number) => number,
+	css?: (t: number, u: number) => string,
+	tick?: (t: number, u: number) => void
+}
+```
+
+---
+
+A transition is triggered by an element entering or leaving the DOM as a result of a state change. Transitions do not run when a component is first mounted, but only on subsequent updates.
+
+Elements inside an *outroing* block are kept in the DOM until all current transitions have completed.
+
+The `transition:` directive indicates a *bidirectional* transition, which means it can be smoothly reversed while the transition is in progress.
+
+```html
+{#if visible}
+	<div transition:fade>
+		fades in and out
+	</div>
+{/if}
+```
+
+---
+
+The `in:` and `out:` directives are not bidirectional. An in transition will continue to 'play' alongside the out transition, if the block is outroed while the transition is in progress. If an out transition is aborted, transitions will restart from scratch.
+
+```html
+{#if visible}
+	<div in:fly out:fade>
+		flies in, fades out
+	</div>
+{/if}
+```
+
+---
+
+Like actions, transitions can have parameters.
+
+(The double `{{curlies}}` aren't a special syntax; this is an object literal inside an expression tag.)
+
+```html
+{#if visible}
+	<div transition:fade="{{ duration: 2000 }}">
+		flies in, fades out over two seconds
+	</div>
+{/if}
+```
+
+---
+
+Transitions can use custom functions. If the returned object has a `css` function, Svelte will create a CSS animation that plays on the element.
+
+The `t` argument passed to `css` is a value between `0` and `1` after the `easing` function has been applied. *In* transitions run from `0` to `1`, *out* transitions run from `1` to `0` — in other words `1` is the element's natural state, as though no transition had been applied. The `u` argument is equal to `1 - t`.
+
+The function is called repeatedly *before* the transition begins, with different `t` and `u` arguments.
+
+```html
+<script>
+	import { elasticOut } from 'svelte/easing';
+
+	export let visible;
+
+	function whoosh(node, params) {
+		const existingTransform = getComputedStyle(node).transform.replace('none', '');
+
+		return {
+			delay: params.delay || 0,
+			duration: params.duration || 400,
+			easing: params.easing || elasticOut,
+			css: (t, u) => `transform: ${existingTransform} scale(${t})`
+		};
+	}
+</script>
+
+{#if visible}
+	<div in:whoosh>
+		whooshes in
+	</div>
+{/if}
+```
+
+---
+
+A custom transition function can also return a `tick` function, which is called *during* the transition with the same `t` and `u` arguments.
+
+> If it's possible to use `css` instead of `tick`, do so — CSS animations can run off the main thread, preventing jank on slower devices.
+
+```html
+<script>
+	export let visible = false;
+
+	function typewriter(node, { speed = 50 }) {
+		const valid = (
+			node.childNodes.length === 1 &&
+			node.childNodes[0].nodeType === 3
+		);
+
+		if (!valid) return {};
+
+		const text = node.textContent;
+		const duration = text.length * speed;
+
+		return {
+			duration,
+			tick: (t, u) => {
+				const i = ~~(text.length * t);
+				node.textContent = text.slice(0, i);
+			}
+		};
+	}
+</script>
+
+{#if visible}
+	<p in:typewriter="{{ speed: 20 }}">
+		The quick brown fox jumps over the lazy dog
+	</p>
+{/if}
+```
+
+If a transition returns a function instead of a transition object, the function will be called in the next microtask. This allows multiple transitions to coordinate, making [crossfade effects](https://v3.svelte.technology/tutorial/deferred-transitions) possible.
+
+---
+
+An element with transitions will dispatch the following events in addition to any standard DOM events:
+
+* `introstart`
+* `introend`
+* `outrostart`
+* `outroend`
+
+```html
+{#if visible}
+	<p
+		transition:fly="{{ y: 200, duration: 2000 }}"
+		on:introstart="{() => status = 'intro started'}"
+		on:outrostart="{() => status = 'outro started'}"
+		on:introend="{() => status = 'intro ended'}"
+		on:outroend="{() => status = 'outro ended'}"
+	>
+		Flies in and out
+	</p>
+{/if}
+```
+
+---
+
+Local transitions only play when the block they belong to is created or destroyed, *not* when parent blocks are created or destroyed.
+
+```html
+{#if x}
+	{#if y}
+		<p transition:fade>
+			fades in and out when x or y change
+		</p>
+
+		<p transition:fade|local>
+			fades in and out only when y changes
+		</p>
+	{/if}
+{/if}
+```
+
+
+### Animations
+
+TODO i can't remember how any of this works
+
+
+### Slots
+
+* `<slot><!-- optional fallback --></slot>`
+* `<slot name="x"><!-- optional fallback --></slot>`
+* `<slot prop={value}></slot>`
+
+---
+
+Components can have child content, in the same way that elements can.
+
+The content is exposed in the child component using the `<slot>` element, which can contain fallback content that is rendered if no children are provided.
+
+```html
+<!-- App.svelte -->
+<Widget>
+	<p>this is some child content</p>
+</Widget>
+
+<!-- Widget.svelte -->
+<div>
+	<slot>
+		this will be rendered if someone does <Widget/>
+	</slot>
+</div>
+```
+
+---
+
+Named slots allow consumers to target specific areas. They can also have fallback content.
+
+```html
+<!-- App.svelte -->
+<Widget>
+	<h1 slot="header">Hello</h1>
+	<p slot="footer">Copyright (c) 2019 Svelte Industries</p>
+</Widget>
+
+<!-- Widget.svelte -->
+<div>
+	<slot name"header">No header was provided</slot>
+	<p>Some content between header and footer</p>
+	</slot name="footer"></slot>
+</div>
+```
+
+---
+
+Slots can be rendered zero or more times, and can pass values *back* to the parent using props. The parent exposes the values to the slot template using the `let:` directive.
+
+The usual shorthand rules apply — `let:item` is equivalent to `let:item={item}`, and `<slot {item}>` is equivalent to `<slot item={item}>`.
+
+```html
+<!-- App.svelte -->
+<FancyList {items} let:item={item}>
+	<div>{item.text}</div>
+</FancyList>
+
+<!-- FancyList.svelte -->
+<ul>
+	{#each items as item}
+		<li class="fancy">
+			<slot item={item}></slot>
+		</li>
+	{/each}
+</ul>
+```
+
+---
+
+Named slots can also expose values. The `let:` directive goes on the element with the `slot` attribute.
+
+```html
+<!-- App.svelte -->
+<FancyList {items}>
+	<div slot="item" let:item={item}>{item.text}</div>
+	<p slot="footer">Copyright (c) 2019 Svelte Industries</p>
+</FancyList>
+
+<!-- FancyList.svelte -->
+<ul>
+	{#each items as item}
+		<li class="fancy">
+			<slot name="item" item={item}></slot>
+		</li>
+	{/each}
+</ul>
+
+</slot name="footer"></slot>
+```
+
+
+### &lt;svelte:self&gt;
+
+---
+
+The `<svelte:self>` element allows a component to include itself, recursively.
+
+It cannot appear at the top level of your markup; it must be inside an if or each block to prevent an infinite loop.
+
+```html
+<script>
+	export let count;
+</script>
+
+{#if count > 0}
+	<p>counting down... {count}</p>
+	<svelte:self count="{count - 1}"/>
+{:else}
+	<p>lift-off!</p>
+{/if}
+```
+
+### &lt;svelte:component&gt;
+
+* `<svelte:component this={expression}>`
+
+---
+
+The `<svelte:component>` element renders a component dynamically, using the component constructor specified as the `this` property. When the property changes, the component is destroyed and recreated.
+
+If `this` is falsy, no component is rendered.
+
+```html
+<svelte:component this={currentSelection.component} foo={bar}/>
+```
+
+
+### &lt;svelte:window&gt;
+
+* `<svelte:window on:event={handler}/>`
+* `<svelte:window bind:prop={value}/>`
+
+---
+
+The `<svelte:window>` element allows you to add event listeners to the `window` object without worrying about removing them when the component is destroyed, or checking for the existence of `window` when server-side rendering.
+
+```html
+<script>
+	function handleKeydown(event) {
+		alert(`pressed the ${event.key} key`);
+	}
+</script>
+
+<svelte:window on:keydown={handleKeydown}/>
+```
+
+---
+
+You can also bind to the following properties:
+
+* `innerWidth`
+* `innerHeight`
+* `outerWidth`
+* `outerHeight`
+* `scrollX`
+* `scrollY`
+* `online` — an alias for window.navigator.onLine
+
+All except `scrollX` and `scrollY` are readonly.
+
+```html
+<svelte:window bind:scrollY={y}/>
+```
+
+
+### &lt;svelte:body&gt;
+
+* `<svelte:body on:event={handler}/>`
+
+---
+
+As with `<svelte:window>`, this element allows you to add listeners to events on `document.body`, such as `mouseenter` and `mouseleave` which don't fire on `window`.
+
+```html
+<svelte:body
+	on:mouseenter={handleMouseenter}
+	on:mouseleave={handleMouseleave}
+/>
+```
+
+
+### &lt;svelte:head&gt;
+
+* `<svelte:head>`
+
+---
+
+This element makes it possible to insert elements into `document.head`. During server-side rendering, `head` content exposed separately to the main `html` content.
+
+```html
+<svelte:head>
+	<link rel="stylesheet" href="tutorial/dark-theme.css">
+</svelte:head>
+```
+
+
+### &lt;svelte:options&gt;
+
+* `<svelte:options option={value}>`
+
+---
+
+The `<svelte:options>` element provides a place to specify per-component compiler options, which are detailed in the next section. The possible options are:
+
+* `immutable={true}` — you never use mutable data, so the compiler can do simple referential equality checks to determine if values have changed
+* `immutable={false}` — the default. Svelte will be more conservative about whether or not mutable objects have changed
+* `namespace="..."` — the namespace where this component will be used, most commonly "svg"
+* `tag="..."` — the name to use when compiling this component as a custom element
+
+```html
+<svelte:options tag="my-custom-element"/>
+```
\ No newline at end of file
diff --git a/site/content/docs/03-run-time.md b/site/content/docs/03-run-time.md
new file mode 100644
index 0000000000..fe1c88532d
--- /dev/null
+++ b/site/content/docs/03-run-time.md
@@ -0,0 +1,550 @@
+---
+title: Run time
+---
+
+
+### svelte
+
+The `svelte` package exposes [lifecycle functions](tutorial/onmount) and the [context API](tutorial/context-api).
+
+* `onMount(callback: () => void)`
+* `onMount(callback: () => () => void)`
+
+---
+
+The `onMount` function schedules a callback to run as soon as the component has been mounted to the DOM. It must be called during the component's initialisation (but doesn't need to live *inside* the component; it can be called from an external module).
+
+`onMount` does not run inside a [server-side component](docs#server-side-component-api).
+
+```html
+<script>
+	import { onMount } from 'svelte';
+
+	onMount(() => {
+		console.log('the component has mounted');
+	});
+</script>
+```
+
+---
+
+If a function is returned from `onMount`, it will be called when the component is unmounted.
+
+```html
+<script>
+	import { onMount } from 'svelte';
+
+	onMount(() => {
+		const interval = setInterval(() => {
+			console.log('beep');
+		}, 1000);
+
+		return () => clearInterval(interval);
+	});
+</script>
+```
+
+* `beforeUpdate(callback: () => void)`
+
+---
+
+Schedules a callback to run immediately before the component is updated after any state change.
+
+> The first time the callback runs will be before the initial `onMount`
+
+```html
+<script>
+	import { beforeUpdate } from 'svelte';
+
+	beforeUpdate(() => {
+		console.log('the component is about to update');
+	});
+</script>
+```
+
+* `afterUpdate(callback: () => void)`
+
+---
+
+Schedules a callback to run immediately after the component has been updated.
+
+```html
+<script>
+	import { afterUpdate } from 'svelte';
+
+	afterUpdate(() => {
+		console.log('the component just updated');
+	});
+</script>
+```
+
+* `onDestroy(callback: () => void)`
+
+---
+
+Schedules a callback to run once the component is unmounted.
+
+Out of `onMount`, `beforeUpdate`, `afterUpdate` and `onDestroy`, this is the only one that runs inside a server-side component.
+
+```html
+<script>
+	import { onDestroy } from 'svelte';
+
+	onDestroy(() => {
+		console.log('the component is being destroyed');
+	});
+</script>
+```
+
+* `promise: Promise = tick()`
+
+---
+
+Returns a promise that resolves once any pending state changes have been applied, or in the next microtask if there are none.
+
+```html
+<script>
+	import { beforeUpdate, tick } from 'svelte';
+
+	beforeUpdate(async () => {
+		console.log('the component is about to update');
+		await tick();
+		console.log('the component just updated');
+	});
+</script>
+```
+
+* `setContext(key: any, context: any)`
+
+---
+
+Associates an arbitrary `context` object with the current component and the specified `key`. The context is then available to children of the component (including slotted content) with `getContext`.
+
+Like lifecycle functions, this must be called during component initialisation.
+
+```html
+<script>
+	import { setContext } from 'svelte';
+
+	setContext('answer', 42);
+</script>
+```
+
+* `context: any = getContext(key: any)`
+
+---
+
+Retrieves the context that belongs to the closest parent component with the specified `key`. Must be called during component initialisation.
+
+```html
+<script>
+	import { getContext } from 'svelte';
+
+	const answer = getContext('answer');
+</script>
+```
+
+
+
+### svelte/store
+
+The `svelte/store` module exports functions for creating [stores](http://localhost:3000/tutorial/writable-stores).
+
+---
+
+To be considered a store, an object must have a `subscribe` method that returns an `unsubscribe` function.
+
+```js
+const unsubscribe = store.subscribe(value => {
+	console.log(value);
+}); // logs `value`
+
+// later...
+unsubscribe();
+```
+
+---
+
+Stores have special significance inside Svelte components. Their values can be read by prefixing the store's name with the `$` character, which causes Svelte to set up subscriptions and unsubscriptions automatically during the component's lifecycle.
+
+```html
+<script>
+	import { count } from './stores.js';
+
+	function handleClick() {
+		// this is equivalent to count.update(n => n + 1)
+		$count += 1;
+	}
+</script>
+
+<button on:click={handleClick}>
+	Clicks: {$count}
+</button>
+```
+
+* `store = writable(value: any)`
+* `store = writable(value: any, () => () => void)`
+
+---
+
+Creates a store with additional `set` and `update` methods.
+
+```js
+import { writable } from 'svelte/store';
+
+const count = writable(0);
+
+count.subscribe(value => {
+	console.log(value);
+}); // logs '0'
+
+count.set(1); // logs '1'
+
+count.update(n => n + 1); // logs '2'
+```
+
+---
+
+If a function is passed as the second argument, it will be called when the number of subscribers goes from zero to one (but not from one to two, etc). That function can return another function that is called when the number of subscribers goes from one to zero.
+
+```js
+import { writable } from 'svelte/store';
+
+const count = writable(0, () => {
+	console.log('got a subscriber');
+	return () => console.log('no more subscribers');
+});
+
+count.set(1); // does nothing
+
+const unsubscribe = count.subscribe(value => {
+	console.log(value);
+}); // logs 'got a subscriber', then '1'
+
+unsubscribe(); // logs 'no more subscribers'
+```
+
+* `store = readable((set: (value: any) => void) => () => void)`
+* `store = readable((set: (value: any) => void) => () => void, value: any)`
+
+---
+
+Creates a store whose value cannot be set from 'outside'. Instead, the function passed to `readable`, which is called when the subscriber count goes from zero to one, must call the provided `set` value. It must return a function that is called when the subscriber count goes from one to zero.
+
+If a second argument is provided, it becomes the store's initial value.
+
+```js
+import { readable } from 'svelte/store';
+
+const time = readable(set => {
+	const interval = setInterval(() => {
+		set(new Date());
+	}, 1000);
+
+	return () => clearInterval(interval);
+}, new Date());
+```
+
+* `store = derive(a, callback: (a: any) => any)`
+* `store = derive(a, callback: (a: any, set: (value: any) => void) => void)`
+* `store = derive([a, ...b], callback: ([a: any, ...b: any[]]) => any)`
+* `store = derive([a, ...b], callback: ([a: any, ...b: any[]], set: (value: any) => void) => void)`
+
+---
+
+Derives a store from one or more other stores. Whenever those dependencies change, the callback runs.
+
+In the simplest version, `derive` takes a single store, and the callback returns a derived value.
+
+```js
+import { derive } from 'svelte/store';
+
+const doubled = derive(a, $a => $a * 2);
+```
+
+---
+
+The callback can set a value asynchronously by accepting a second argument, `set`, and calling it when appropriate.
+
+```js
+import { derive } from 'svelte/store';
+
+const delayed = derive(a, ($a, set) => {
+	setTimeout(() => set($a), 1000);
+});
+```
+
+---
+
+In both cases, an array of arguments can be passed as the first argument instead of a single store.
+
+```js
+import { derive } from 'svelte/store';
+
+const summed = derive([a, b], ([$a, $b]) => $a + $b);
+
+const delayed = derive([a, b], ([$a, $b], set) => {
+	setTimeout(() => set($a + $b), 1000);
+});
+```
+
+* `value: any = get(store)`
+
+---
+
+Generally, you should read the value of a store by subscribing to it and using the value as it changes over time. Occasionally, you may need to retrieve the value of a store to which you're not subscribed. `get` allows you to do so.
+
+> This works by creating a subscription, reading the value, then unsubscribing. It's therefore not recommended in hot code paths.
+
+```js
+import { get } from 'svelte/store';
+
+const value = get(store);
+```
+
+
+### svelte/motion
+
+The `svelte/motion` module exports two functions, `tweened` and `spring`, for creating writable stores whose values change over time after `set` and `update`, rather than immediately.
+
+#### tweened
+
+* `store = tweened(value: any, options)`
+
+Tweened stores update their values over a fixed duration. The following options are available:
+
+* `delay` (`number`, default 0) — milliseconds before starting
+* `duration` (`number`, default 400) — milliseconds the tween lasts
+* `easing` (`function`, default `t => t`) — an [easing function](docs#svelte-easing)
+* `interpolator` (`function`) — see below
+
+`store.set` and `store.update` can accept a second `options` argument that will override the options passed in upon instantiation.
+
+Both functions return a Promise that resolves when the tween completes. If the tween is interrupted, the promise will never resolve.
+
+---
+
+Out of the box, Svelte will interpolate between two numbers, two arrays or two objects (as long as the arrays and objects are the same 'shape', and their 'leaf' properties are also numbers).
+
+```html
+<script>
+	import { tweened } from 'svelte/motion';
+	import { cubicOut } from 'svelte/easing';
+
+	const size = tweened(1, {
+		duration: 300,
+		easing: cubicOut
+	});
+
+	function handleClick() {
+		// this is equivalent to size.update(n => n + 1)
+		$size += 1;
+	}
+</script>
+
+<button
+	on:click={handleClick}
+	style="transform: scale({$size}); transform-origin: 0 0"
+>embiggen</button>
+```
+
+---
+
+The `interpolator` option allows you to tween between *any* arbitrary values. It must be an `(a, b) => t => value` function, where `a` is the starting value, `b` is the target value, `t` is a number between 0 and 1, and `value` is the result. For example, we can use the [d3-interpolate](https://github.com/d3/d3-interpolate) package to smoothly interpolate between two colours.
+
+```html
+<script>
+	import { interpolateLab } from 'd3-interpolate';
+	import { tweened } from 'svelte/motion';
+
+	const colors = [
+		'rgb(255, 62, 0)',
+		'rgb(64, 179, 255)',
+		'rgb(103, 103, 120)'
+	];
+
+	const color = tweened(colors[0], {
+		duration: 800,
+		interpolate: interpolateLab
+	});
+</script>
+
+{#each colors as c}
+	<button
+		style="background-color: {c}; color: white; border: none;"
+		on:click="{e => color.set(c)}"
+	>{c}</button>
+{/each}
+
+<h1 style="color: {$color}">{$color}</h1>
+```
+
+#### spring
+
+* `store = spring(value: any, options)`
+
+A `spring` store gradually changes to its target value based on its `stiffness` and `damping` parameters. Whereas `tweened` stores change their values over a fixed duration, `spring` stores change over a duration that is determined by their existing velocity, allowing for more natural-seeming motion in many situations. The following options are available:
+
+* `stiffness` (`number`, default `0.15`) — a value between 0 and 1 where higher means a 'tighter' spring
+* `damping` (`number`, default `0.8`) — a value between 0 and 1 where lower means a 'springier' spring
+* `precision` (`number`, default `0.001`) — determines the threshold at which the spring is considered to have 'settled', where lower means more precise
+
+---
+
+As with `tweened` stores, `set` and `update` return a Promise that resolves if the spring settles. The `store.stiffness` and `store.damping` properties can be changed while the spring is in motion, and will take immediate effect.
+
+[See a full example here.](tutorial/spring)
+
+```html
+<script>
+	import { spring } from 'svelte/motion';
+
+	const coords = spring({ x: 50, y: 50 }, {
+		stiffness: 0.1,
+		damping: 0.25
+	});
+</script>
+```
+
+### svelte/transition
+
+TODO
+
+* fade, fly, slide, draw
+* crossfade...
+
+### svelte/animation
+
+TODO
+
+* TODO this doesn't even exist yet
+
+TODO
+
+### svelte/easing
+
+* TODO could have nice little interactive widgets showing the different functions, maybe
+
+### svelte/register
+
+TODO
+
+
+### Client-side component API
+
+* `const component = new Component(options)`
+
+---
+
+A client-side component — that is, a component compiled with `generate: 'dom'` (or the `generate` option left unspecified) is a JavaScript class.
+
+```js
+import App from './App.svelte';
+
+const app = new App({
+	target: document.body,
+	props: {
+		// assuming App.svelte contains something like
+		// `export let answer`:
+		answer: 42
+	}
+});
+```
+
+The following initialisation options can be provided:
+
+| option | default | description |
+| --- | --- | --- |
+| `target` | **none** | An `HTMLElement` to render to. This option is required
+| `anchor` | `null` | A child of `target` to render the component immediately before
+| `props` | `{}` | An object of proeprties to supply to the component
+| `hydrate` | `false` | See below
+| `intro` | `false` | If `true`, will play transitions on initial render, rather than waiting for subsequent state changes
+
+Existing children of `target` are left where they are.
+
+
+---
+
+The `hydrate` option instructs Svelte to upgrade existing DOM (usually from server-side rendering) rather than creating new elements. It will only work if the component was compiled with the `hydratable: true` option.
+
+Whereas children of `target` are normally left alone, `hydrate: true` will cause any children to be removed. For that reason, the `anchor` option cannot be used alongside `hydrate: true`.
+
+The existing DOM doesn't need to match the component — Svelte will 'repair' the DOM as it goes.
+
+```js
+import App from './App.svelte';
+
+const app = new App({
+	target: document.querySelector('#server-rendered-html'),
+	hydrate: true
+});
+```
+
+* `component.$set(props)`
+
+---
+
+Programmatically sets props on an instance. `component.$set({ x: 1 })` is equivalent to `x = 1` inside the component's `<script>` block.
+
+Calling this method schedules an update for the next microtask — the DOM is *not* updated synchronously.
+
+```js
+app.$set({ answer: 42 });
+```
+
+* `component.$on(event, callback)`
+
+---
+
+Causes the `callback` function to be called whenever the component dispatches an `event`.
+
+```js
+app.$on('selected', event => {
+	console.log(event.detail.selection);
+});
+```
+
+
+* `component.$destroy()`
+
+Removes a component from the DOM and triggers any `onDestroy` handlers.
+
+
+* `component.prop`
+* `component.prop = value`
+
+---
+
+If a component is compiled with `accessors: true`, each instance will have getters and setters corresponding to each of the component's props. Setting a value will cause a *synchronous* update, rather than the default async update caused by `component.$set(...)`.
+
+By default, `accessors` is `false`, unless you're compiling as a custom element.
+
+```js
+console.log(app.count);
+app.count += 1;
+```
+
+
+### Custom element API
+
+* TODO
+
+
+### Server-side component API
+
+* `const result = Component.render(...)`
+
+---
+
+Unlike client-side components, server-side components don't have a lifespan after you render them — their whole job is to create some HTML and CSS. For that reason, the API is somewhat different.
+
+A server-side component exposes a `render` method that can be called with optional props. It returns an object with `head`, `html`, and `css` properties, where `head` contains the contents of any `<svelte:head>` elements encountered.
+
+```js
+const App = require('./App.svelte');
+
+const { head, html, css } = App.render({
+	answer: 42
+});
+```
\ No newline at end of file
diff --git a/site/content/docs/04-compile-time.md b/site/content/docs/04-compile-time.md
new file mode 100644
index 0000000000..9071cdeaae
--- /dev/null
+++ b/site/content/docs/04-compile-time.md
@@ -0,0 +1,291 @@
+---
+title: Compile time
+---
+
+Typically, you won't interact with the Svelte compiler directly, but will instead integrate it into your build system using a bundler plugin:
+
+* [rollup-plugin-svelte](https://github.com/rollup/rollup-plugin-svelte) for users of [Rollup](https://rollupjs.org)
+* [svelte-loader](https://github.com/sveltejs/svelte-loader) for users of [webpack](https://webpack.js.org)
+* [parcel-plugin-svelte](https://github.com/DeMoorJasper/parcel-plugin-svelte) for users of [Parcel](https://parceljs.org/)
+
+Nonetheless, it's useful to understand how to use the compiler, since bundler plugins generally expose compiler options to you.
+
+
+
+### svelte.compile
+
+```js
+result: {
+	js,
+	css,
+	ast,
+	warnings,
+	vars,
+	stats
+} = svelte.compile(source: string, options?: {...})
+```
+
+---
+
+This is where the magic happens. `svelte.compile` takes your component source code, and turns it into a JavaScript module that exports a class.
+
+```js
+const svelte = require('svelte/compiler');
+
+const result = svelte.compile(source, {
+	// options
+});
+```
+
+The following options can be passed to the compiler. None are required:
+
+<!-- | option | type | default
+| --- | --- | --- |
+| `filename` | string | `null`
+| `name` | string | `"Component"`
+| `format` | `"esm"` or `"cjs"` | `"esm"`
+| `generate` | `"dom"` or `"ssr"` | `"dom"`
+| `dev` | boolean | `false`
+| `immutable` | boolean | `false`
+| `hydratable` | boolean | `false`
+| `legacy` | boolean | `false`
+| `customElement` | boolean | `false`
+| `tag` | string | null
+| `accessors` | boolean | `false`
+| `css` | boolean | `true`
+| `preserveComments` | boolean | `false`
+| `preserveWhitespace` | boolean | `false`
+| `outputFilename` | string | `null`
+| `cssOutputFilename` | string | `null`
+| `sveltePath` | string | `"svelte"` -->
+
+| option | default | description |
+| --- | --- | --- |
+| `filename` | `null` | `string` used for debugging hints and sourcemaps. Your bundler plugin will set it automatically.
+| `name` | `"Component"` | `string` that sets the name of the resulting JavaScript class (though the compiler will rename it if it would otherwise conflict with other variables in scope). It will normally be inferred from `filename`.
+| `format` | `"esm"` | If `"esm"`, creates a JavaScript module (with `import` and `export`). If `"cjs"`, creates a CommonJS module (with `require` and `module.exports`), which is useful in some server-side rendering situations or for testing.
+| `generate` | `"dom"` | If `"dom"`, Svelte emits a JavaScript class for mounting to the DOM. If `"ssr"`, Svelte emits an object with a `render` method suitable for server-side rendering. If `false`, no JavaScript or CSS is returned; just metadata.
+| `dev` | `false` | If `true`, causes extra code to be added to components that will perform runtime checks and provide debugging information during development.
+| `immutable` | `false` | If `true`, tells the compiler that you promise not to mutate any objects. This allows it to be less conservative about checking whether values have changed.
+| `hydratable` | `false` | If `true`, enables the `hydrate: true` runtime option, which allows a component to upgrade existing DOM rather than creating new DOM from scratch.
+| `legacy` | `false` | If `true`, generates code that will work in IE9 and IE10, which don't support things like `element.dataset`.
+| `accessors` | `false` | If `true`, getters and setters will be created for the component's props. If `false`, they will only be created for readonly exported values (i.e. those declared with `const`, `class` and `function`). If compiling with `customElement: true` this option defaults to `true`.
+| `customElement` | `false` | If `true`, tells the compiler to generate a custom element constructor instead of a regular Svelte component.
+| `tag` | `null` | A `string` that tells Svelte what tag name to register the custom element with. It must be a lowercase alphanumeric string with at least one hyphen, e.g. `"my-element"`.
+| `css` | `true` | If `true`, styles will be included in the JavaScript class and injected at runtime. It's recommended that you set this to `false` and use the CSS that is statically generated, as it will result in smaller JavaScript bundles and better performance.
+| `preserveComments` | `false` | If `true`, your HTML comments will be preserved during server-side rendering. By default, they are stripped out.
+| `preserveWhitespace` | `false` | If `true`, whitespace inside and between elements is kept as you typed it, rather than optimised by Svelte.
+| `outputFilename` | `null` | A `string` used for your JavaScript sourcemap.
+| `cssOutputFilename` | `null` | A `string` used for your CSS sourcemap.
+| `sveltePath` | `"svelte"` | The location of the `svelte` package. Any imports from `svelte` or `svelte/[module]` will be modified accordingly.
+
+
+---
+
+The returned `result` object contains the code for your component, along with useful bits of metadata.
+
+```js
+const {
+	js,
+	css,
+	ast,
+	warnings,
+	vars,
+	stats
+} = svelte.compile(source);
+```
+
+* `js` and `css` are obejcts with the following properties:
+	* `code` is a JavaScript string
+	* `map` is a sourcemap with additional `toString()` and `toUrl()` convenience methods
+* `ast` is an abstract syntax tree representing the structure of your component.
+* `warnings` is an array of warning objects that were generated during compilation. Each warning has several properties:
+	* `code` is a string identifying the category of warning
+	* `message` describes the issue in human-readable terms
+	* `start` and `end`, if the warning relates to a specific location, are objects with `line`, `column` and `character` properties
+	* `frame`, if applicable, is a string highlighting the offending code with line numbers
+* `vars` is an array of the component's declarations, used by [eslint-plugin-svelte3](https://github.com/sveltejs/eslint-plugin-svelte3) for example. Each variable has several properties:
+	* `name` is self-explanatory
+	* `export_name` is the name the value is exported as, if it is exported (will match `name` unless you do `export...as`)
+	* `injected` is `true` if the declaration is injected by Svelte, rather than in the code you wrote
+	* `module` is `true` if the value is declared in a `context="module"` script
+	* `mutated` is `true` if the value's properties are assigned to inside the component
+	* `reassigned` is `true` if the value is reassigned inside the component
+	* `referenced` is `true` if the value is used outside the declaration
+	* `writable` is `true` if the value was declared with `let` or `var` (but not `const`, `class` or `function`)
+* `stats` is an object used by the Svelte developer team for diagnosing the compiler. Avoid relying on it to stay the same!
+
+
+<!--
+
+```js
+compiled: {
+	// `map` is a v3 sourcemap with toString()/toUrl() methods
+	js: { code: string, map: {...} },
+	css: { code: string, map: {...} },
+	ast: {...}, // ESTree-like syntax tree for the component, including HTML, CSS and JS
+	warnings: Array<{
+		code: string,
+		message: string,
+		filename: string,
+		pos: number,
+		start: { line: number, column: number },
+		end: { line: number, column: number },
+		frame: string,
+		toString: () => string
+	}>,
+	vars: Array<{
+		name: string,
+		export_name: string,
+		injected: boolean,
+		module: boolean,
+		mutated: boolean,
+		reassigned: boolean,
+		referenced: boolean,
+		writable: boolean
+	}>,
+	stats: {
+		timings: { [label]: number }
+	}
+} = svelte.compile(source: string, options?: {...})
+```
+
+-->
+
+
+### svelte.preprocess
+
+```js
+result: {
+	code: string,
+	dependencies: Array<string>
+} = svelte.preprocess(
+	source: string,
+	preprocessors: Array<{
+		markup?: (input: { source: string, filename: string }) => Promise<{
+			code: string,
+			dependencies?: Array<string>
+		}>,
+		script?: (input: { source: string, attributes: Record<string, string>, filename: string }) => Promise<{
+			code: string,
+			dependencies?: Array<string>
+		}>,
+		style?: (input: { source: string, attributes: Record<string, string>, filename: string }) => Promise<{
+			code: string,
+			dependencies?: Array<string>
+		}>
+	}>,
+	options?: {
+		filename?: string
+	}
+)
+```
+
+---
+
+The `preprocess` function provides convenient hooks for arbitrarily transforming component source code. For example, it can be used to convert a `<style lang="sass">` block into vanilla CSS.
+
+The first argument is the component source code. The second is an array of *preprocessors* (or a single preprocessor, if you only have one), where a preprocessor is an object with `markup`, `script` and `style` functions, each of which is optional.
+
+Each `markup`, `script` or `style` function must return an object (or a Promise that resolves to an object) with a `code` property, representing the transformed source code, and an optional array of `dependencies`.
+
+The `markup` function receives the entire component source text, along with the component's `filename` if it was specified in the third argument.
+
+> Preprocessor functions may additionally return a `map` object alongside `code` and `dependencies`, where `map` is a sourcemap representing the transformation. In current versions of Svelte it will be ignored, but future versions of Svelte may take account of preprocessor sourcemaps.
+
+```js
+const svelte = require('svelte/compiler');
+
+const { code } = svelte.preprocess(source, {
+	markup: ({ content, filename }) => {
+		return {
+			code: content.replace(/foo/g, 'bar')
+		};
+	}
+}, {
+	filename: 'App.svelte'
+});
+```
+
+---
+
+The `script` and `style` functions receive the contents of `<script>` and `<style>` elements respectively. In addition to `filename`, they get an object of the element's attributes.
+
+If a `dependencies` array is returned, it will be included in the result object. This is used by packages like [rollup-plugin-svelte](https://github.com/rollup/rollup-plugin-svelte) to watch additional files for changes, in the case where your `<style>` tag has an `@import` (for example).
+
+```js
+const svelte = require('svelte/compiler');
+const sass = require('node-sass');
+
+const { code, dependencies } = svelte.preprocess(source, {
+	style: ({ content, attributes, filename }) => {
+		// only process <style lang="sass">
+		if (attributes.lang !== 'sass') return;
+
+		const { css, stats } = await new Promise((resolve, reject) => sass.render({
+			file: filename,
+			data: content,
+			includePaths: [
+				dirname(filename),
+			],
+		}), (err, result) => {
+			if (err) reject(err);
+			else resolve(result);
+		}));
+
+		return {
+			code: css.toString(),
+			dependencies: stats.includedFiles
+		};
+	}
+}, {
+	filename: 'App.svelte'
+});
+```
+
+---
+
+Multiple preprocessors can be used together. The output of the first becomes the input to the second. `markup` functions run first, then `script` and `style`.
+
+```js
+const svelte = require('svelte/compiler');
+
+const { code } = svelte.preprocess(source, [
+	{
+		markup: () => {
+			console.log('this runs first');
+		},
+		script: () => {
+			console.log('this runs third');
+		},
+		style: () => {
+			console.log('this runs fifth');
+		}
+	},
+	{
+		markup: () => {
+			console.log('this runs second');
+		},
+		script: () => {
+			console.log('this runs fourth');
+		},
+		style: () => {
+			console.log('this runs sixth');
+		}
+	}
+], {
+	filename: 'App.svelte'
+});
+```
+
+
+### svelte.VERSION
+
+---
+
+The current version, as set in package.json.
+
+```js
+const svelte = require('svelte/compiler');
+console.log(`running svelte version ${svelte.VERSION}`);
+```
diff --git a/site/content/guide/02-template-syntax.md b/site/content/docs/_old_docs/02-template-syntax.md
similarity index 100%
rename from site/content/guide/02-template-syntax.md
rename to site/content/docs/_old_docs/02-template-syntax.md
diff --git a/site/content/guide/03-scoped-styles.md b/site/content/docs/_old_docs/03-scoped-styles.md
similarity index 100%
rename from site/content/guide/03-scoped-styles.md
rename to site/content/docs/_old_docs/03-scoped-styles.md
diff --git a/site/content/guide/04-behaviour.md b/site/content/docs/_old_docs/04-behaviour.md
similarity index 100%
rename from site/content/guide/04-behaviour.md
rename to site/content/docs/_old_docs/04-behaviour.md
diff --git a/site/content/guide/05-nested-components.md b/site/content/docs/_old_docs/05-nested-components.md
similarity index 100%
rename from site/content/guide/05-nested-components.md
rename to site/content/docs/_old_docs/05-nested-components.md
diff --git a/site/content/guide/06-special-components.md b/site/content/docs/_old_docs/06-special-components.md
similarity index 100%
rename from site/content/guide/06-special-components.md
rename to site/content/docs/_old_docs/06-special-components.md
diff --git a/site/content/guide/07-events.md b/site/content/docs/_old_docs/07-events.md
similarity index 100%
rename from site/content/guide/07-events.md
rename to site/content/docs/_old_docs/07-events.md
diff --git a/site/content/guide/08-bindings.md b/site/content/docs/_old_docs/08-bindings.md
similarity index 100%
rename from site/content/guide/08-bindings.md
rename to site/content/docs/_old_docs/08-bindings.md
diff --git a/site/content/guide/09-transitions.md b/site/content/docs/_old_docs/09-transitions.md
similarity index 100%
rename from site/content/guide/09-transitions.md
rename to site/content/docs/_old_docs/09-transitions.md
diff --git a/site/content/guide/10-actions.md b/site/content/docs/_old_docs/10-actions.md
similarity index 100%
rename from site/content/guide/10-actions.md
rename to site/content/docs/_old_docs/10-actions.md
diff --git a/site/content/guide/11-classes.md b/site/content/docs/_old_docs/11-classes.md
similarity index 100%
rename from site/content/guide/11-classes.md
rename to site/content/docs/_old_docs/11-classes.md
diff --git a/site/content/guide/14-module-context.md b/site/content/docs/_old_docs/14-module-context.md
similarity index 100%
rename from site/content/guide/14-module-context.md
rename to site/content/docs/_old_docs/14-module-context.md
diff --git a/site/content/guide/15-server-side-rendering.md b/site/content/docs/_old_docs/15-server-side-rendering.md
similarity index 100%
rename from site/content/guide/15-server-side-rendering.md
rename to site/content/docs/_old_docs/15-server-side-rendering.md
diff --git a/site/content/guide/16-state-management.md b/site/content/docs/_old_docs/16-state-management.md
similarity index 100%
rename from site/content/guide/16-state-management.md
rename to site/content/docs/_old_docs/16-state-management.md
diff --git a/site/content/guide/17-preprocessing.md b/site/content/docs/_old_docs/17-preprocessing.md
similarity index 100%
rename from site/content/guide/17-preprocessing.md
rename to site/content/docs/_old_docs/17-preprocessing.md
diff --git a/site/content/guide/18-advanced.md b/site/content/docs/_old_docs/18-advanced.md
similarity index 100%
rename from site/content/guide/18-advanced.md
rename to site/content/docs/_old_docs/18-advanced.md
diff --git a/site/content/guide/19-custom-elements.md b/site/content/docs/_old_docs/19-custom-elements.md
similarity index 100%
rename from site/content/guide/19-custom-elements.md
rename to site/content/docs/_old_docs/19-custom-elements.md
diff --git a/site/content/guide/20-miscellaneous.md b/site/content/docs/_old_docs/20-miscellaneous.md
similarity index 100%
rename from site/content/guide/20-miscellaneous.md
rename to site/content/docs/_old_docs/20-miscellaneous.md
diff --git a/site/content/guide/98-api-reference.md b/site/content/docs/_old_docs/98-api-reference.md
similarity index 100%
rename from site/content/guide/98-api-reference.md
rename to site/content/docs/_old_docs/98-api-reference.md
diff --git a/site/content/guide/99-still-to-come.md b/site/content/docs/_old_docs/99-still-to-come.md
similarity index 100%
rename from site/content/guide/99-still-to-come.md
rename to site/content/docs/_old_docs/99-still-to-come.md
diff --git a/site/content/guide/0-important-note.md b/site/content/guide/0-important-note.md
deleted file mode 100644
index ae751e1f93..0000000000
--- a/site/content/guide/0-important-note.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-title: Important note
----
-
-### Read the RFCs
-
-Much of the documentation below is out of date! For more accurate and current information on how Svelte 3 works in the meantime, check out the RFCS on [reactive assignments](https://github.com/sveltejs/rfcs/blob/master/text/0001-reactive-assignments.md), [reactive stores](https://github.com/sveltejs/rfcs/blob/master/text/0002-reactive-stores.md) and [reactive declarations](https://github.com/sveltejs/rfcs/blob/master/text/0003-reactive-declarations.md).
diff --git a/site/content/guide/00-introduction.md b/site/content/guide/00-introduction.md
deleted file mode 100644
index ea28d2faf0..0000000000
--- a/site/content/guide/00-introduction.md
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: Introduction
----
-
-### What is Svelte?
-
-Svelte is a tool for building fast web applications.
-
-It is similar to JavaScript frameworks such as React and Vue, which share a goal of making it easy to build slick interactive user interfaces.
-
-But there's a crucial difference: Svelte converts your app into ideal JavaScript at *build time*, rather than interpreting your application code at *run time*. This means you don't pay the performance cost of the framework's abstractions, and you don't incur a penalty when your app first loads.
-
-You can build your entire app with Svelte, or you can add it incrementally to an existing codebase. You can also ship components as standalone packages that work anywhere, without the overhead of a dependency on a conventional framework.
-
-[Read the introductory blog post](/blog/frameworks-without-the-framework) to learn more about Svelte's goals and philosophy.
-
-
-### Understanding components
-
-In Svelte, an application is composed from one or more *components*. A component is a reusable self-contained block of code that encapsulates markup, styles and behaviours that belong together, written into an `.html` file. Here's a simple example:
-
-```html
-<!--{ title: 'Hello world!' }-->
-<h1>Hello {name}!</h1>
-```
-
-```json
-/* { hidden: true } */
-{
-	name: 'world'
-}
-```
-
-> Wherever you see <strong style="font-weight: 700; font-size: 16px; font-family: Inconsolata, monospace; color: rgba(170,30,30, 0.8)">REPL</strong> links, click through for an interactive example
-
-Svelte turns this into a JavaScript module that you can import into your app:
-
-```js
-/* { filename: 'main.js' } */
-import App from './App.html';
-
-const app = new App({
-  target: document.querySelector('main'),
-  props: { name: 'world' },
-});
-
-// change the component's "name" prop. We'll learn about props (aka properties) below
-app.name = 'everybody';
-
-// detach the component and clean everything up
-app.$destroy();
-```
-
-Congratulations, you've just learned about half of Svelte's API!
-
-
-### Getting started
-
-Normally, this is the part where the instructions might tell you to add the framework to your page as a `<script>` tag. But because Svelte runs at build time, it works a little bit differently.
-
-The best way to use Svelte is to integrate it into your build system – there are plugins for Rollup, Webpack and others, with more on the way. See [here](https://github.com/sveltejs/svelte/#svelte) for an up-to-date list.
-
-> You will need to have [Node.js](https://nodejs.org/en/) installed, and have some familiarity with the command line
-
-#### Getting started using the REPL
-
-Going to the [REPL](/repl) and pressing the *download* button on any of the examples will give you a .zip file containing everything you need to run that example locally. Just unzip it, `cd` to the directory, and run `npm install` and `npm run dev`. See [this blog post](/blog/the-easiest-way-to-get-started) for more information.
-
-#### Getting started using degit
-
-[degit](https://github.com/Rich-Harris/degit) is a tool for creating projects from templates stored in git repos. Install it globally...
-
-```bash
-npm install -g degit
-```
-
-...then you can use it to spin up a new project:
-
-```bash
-degit sveltejs/template my-new-project
-cd my-new-project
-npm install
-npm run dev
-```
-
-You can use any git repo you like — these are the 'official' templates:
-
-* [sveltejs/template](https://github.com/sveltejs/template) — this is what you get by downloading from the REPL
-* [sveltejs/template-webpack](https://github.com/sveltejs/template-webpack) — similar, but uses [webpack](https://webpack.js.org/) instead of [Rollup](https://rollupjs.org/guide/en)
-
-#### Getting started using the CLI
-
-Svelte also provides a Command Line Interface, but it's not recommended for production use. The CLI will compile your components to standalone JavaScript files, but won't automatically recompile them when they change, and won't deduplicate code shared between your components. Use one of the above methods instead.
-
-If you've installed `svelte` globally, you can use `svelte --help` for a complete list of options. Some examples of the more common operations are:
-
-```bash
-# Generate a JavaScript module from MyComponent.html
-svelte compile MyComponent.html > MyComponent.js
-svelte compile -i MyComponent.html -o MyComponent.js
-
-# Generate a UMD module from MyComponent.html, inferring its name from the filename ('MyComponent')
-svelte compile -f umd MyComponent.html > MyComponent.js
-
-# Generate a UMD module, specifying the name
-svelte compile -f umd -n CustomName MyComponent.html > MyComponent.js
-
-# Compile all .html files in a directory
-svelte compile -i src/components -o build/components
-```
-
-> You can also use [npx](https://medium.com/@maybekatz/introducing-npx-an-npm-package-runner-55f7d4bd282b) to use the CLI without installing Svelte globally — just prefix your command with `npx`: `npx svelte compile ...`
diff --git a/site/src/routes/about.svelte b/site/src/routes/about.svelte
deleted file mode 100644
index e1734b3c4e..0000000000
--- a/site/src/routes/about.svelte
+++ /dev/null
@@ -1,7 +0,0 @@
-<svelte:head>
-	<title>About</title>
-</svelte:head>
-
-<h1>About this site</h1>
-
-<p>This is the 'about' page. There's not much here.</p>
\ No newline at end of file
diff --git a/site/src/routes/api/blog/[slug].js b/site/src/routes/blog/[slug].json.js
similarity index 100%
rename from site/src/routes/api/blog/[slug].js
rename to site/src/routes/blog/[slug].json.js
diff --git a/site/src/routes/blog/[slug].svelte b/site/src/routes/blog/[slug].svelte
index 10ce7c6bb0..e913606c1b 100644
--- a/site/src/routes/blog/[slug].svelte
+++ b/site/src/routes/blog/[slug].svelte
@@ -1,6 +1,6 @@
 <script context="module">
 	export async function preload({ params }) {
-		const post = await this.fetch(`api/blog/${params.slug}`).then(r => r.json());
+		const post = await this.fetch(`blog/${params.slug}.json`).then(r => r.json());
 		return { post };
 	}
 </script>
diff --git a/site/src/routes/api/blog/_posts.js b/site/src/routes/blog/_posts.js
similarity index 93%
rename from site/src/routes/api/blog/_posts.js
rename to site/src/routes/blog/_posts.js
index 33c033b517..3b6ec37dab 100644
--- a/site/src/routes/api/blog/_posts.js
+++ b/site/src/routes/blog/_posts.js
@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { extract_frontmatter, langs } from '../../../utils/markdown.js';
+import { extract_frontmatter, langs } from '../../utils/markdown.js';
 import marked from 'marked';
 import PrismJS from 'prismjs';
 import 'prismjs/components/prism-bash';
diff --git a/site/src/routes/api/blog/index.js b/site/src/routes/blog/index.json.js
similarity index 100%
rename from site/src/routes/api/blog/index.js
rename to site/src/routes/blog/index.json.js
diff --git a/site/src/routes/blog/index.svelte b/site/src/routes/blog/index.svelte
index b6743d94a1..3a53c0bf8d 100644
--- a/site/src/routes/blog/index.svelte
+++ b/site/src/routes/blog/index.svelte
@@ -1,6 +1,6 @@
 <script context="module">
 	export async function preload() {
-		const posts = await this.fetch(`api/blog`).then(r => r.json());
+		const posts = await this.fetch(`blog.json`).then(r => r.json());
 		return { posts };
 	}
 </script>
diff --git a/site/src/routes/blog/rss.xml.js b/site/src/routes/blog/rss.xml.js
index 135e70499f..5b0da33cfe 100644
--- a/site/src/routes/blog/rss.xml.js
+++ b/site/src/routes/blog/rss.xml.js
@@ -1,4 +1,4 @@
-import get_posts from '../api/blog/_posts.js';
+import get_posts from '../blog/_posts.js';
 
 const months = ',Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec'.split(',');
 
diff --git a/site/src/routes/docs/_GuideContents.svelte b/site/src/routes/docs/_GuideContents.svelte
index 6fc7c6c588..bbee664895 100644
--- a/site/src/routes/docs/_GuideContents.svelte
+++ b/site/src/routes/docs/_GuideContents.svelte
@@ -72,35 +72,55 @@
 </script>
 
 <style>
-	.guide-toc li {
+	.reference-toc li {
 		display: block;
 		line-height: 1.2;
 		margin: 0 0 4.8rem 0;
 	}
 
+	a {
+		position: relative;
+		opacity: 0.7;
+		transition: opacity 0.2s;
+	}
+
 	.section {
 		display: block;
 		padding: 0 0 .8rem 0;
 		font: 400 var(--h6) var(--font);
 		text-transform: uppercase;
 		letter-spacing: 0.12em;
+		font-weight: 700;
 	}
 
 	.subsection {
 		display: block;
 		font-size: 1.6rem;
 		font-family: var(--font);
-		padding: 0.3em 0;
+		padding: 0 0 0.6em 0;
 	}
 
 	.section:hover,
-	.subsection:hover { color: var(--flash) }
-	.active           { color: var(--prime) }
+	.subsection:hover {
+		color: var(--flash);
+		opacity: 1
+	}
+
+	.active {
+		opacity: 1;
+		/* font-weight: 700; */
+	}
+
+	.icon-container {
+		position: absolute;
+		top: -.3rem;
+		right: 3.2rem;
+	}
 </style>
 
 <ul
 	bind:this={ul}
-	class="guide-toc"
+	class="reference-toc"
 	on:mouseenter="{() => prevent_sidebar_scroll = true}"
 	on:mouseleave="{() => prevent_sidebar_scroll = false}"
 >
@@ -110,7 +130,9 @@
 				{section.metadata.title}
 
 				{#if section.slug === active_section}
-					<Icon name="arrow-right" />
+					<div class="icon-container">
+						<Icon name="arrow-right" />
+					</div>
 				{/if}
 			</a>
 
@@ -120,7 +142,9 @@
 					{subsection.title}
 
 					{#if subsection.slug === active_section}
-						<Icon name="arrow-right" />
+						<div class="icon-container">
+							<Icon name="arrow-right" />
+						</div>
 					{/if}
 				</a>
 			{/each}
diff --git a/site/src/routes/docs/_sections.js b/site/src/routes/docs/_sections.js
index d4adeebd09..79b64c58b3 100644
--- a/site/src/routes/docs/_sections.js
+++ b/site/src/routes/docs/_sections.js
@@ -35,33 +35,27 @@ const blockTypes = [
 	'tablecell'
 ];
 
-// https://github.com/darkskyapp/string-hash/blob/master/index.js
-function getHash(str) {
-	let hash = 5381;
-	let i = str.length;
-
-	while (i--) hash = ((hash << 5) - hash) ^ str.charCodeAt(i);
-	return (hash >>> 0).toString(36);
-}
-
-export const demos = new Map();
-
 export default function() {
 	return fs
-		.readdirSync(`content/guide`)
+		.readdirSync(`content/docs`)
 		.filter(file => file[0] !== '.' && path.extname(file) === '.md')
 		.map(file => {
-			const markdown = fs.readFileSync(`content/guide/${file}`, 'utf-8');
+			const markdown = fs.readFileSync(`content/docs/${file}`, 'utf-8');
 
 			const { content, metadata } = extract_frontmatter(markdown);
 
 			const subsections = [];
-			const groups = [];
-			let group = null;
-			let uid = 1;
 
 			const renderer = new marked.Renderer();
 
+			let block_open = false;
+
+			renderer.hr = (...args) => {
+				block_open = true;
+
+				return '<div class="side-by-side"><div class="copy">';
+			};
+
 			renderer.code = (source, lang) => {
 				source = source.replace(/^ +/gm, match =>
 					match.split('    ').join('\t')
@@ -74,15 +68,6 @@ export default function() {
 				let prefix = '';
 				let className = 'code-block';
 
-				if (lang === 'html' && !group) {
-					if (!meta || meta.repl !== false) {
-						prefix = `<a class='open-in-repl' href='repl?demo=@@${uid}' title='open in REPL'><svg class='icon'><use xlink:href='#maximize-2' /></svg></a>`;
-					}
-
-					group = { id: uid++, blocks: [] };
-					groups.push(group);
-				}
-
 				if (meta) {
 					source = lines.slice(1).join('\n');
 					const filename = meta.filename || (lang === 'html' && 'App.svelte');
@@ -92,8 +77,6 @@ export default function() {
 					}
 				}
 
-				if (group) group.blocks.push({ meta: meta || {}, lang, source });
-
 				if (meta && meta.hidden) return '';
 
 				const plang = langs[lang];
@@ -103,13 +86,20 @@ export default function() {
 					lang
 				);
 
-				return `<div class='${className}'>${prefix}<pre class='language-${plang}'><code>${highlighted}</code></pre></div>`;
+				let html = `<div class='${className}'>${prefix}<pre class='language-${plang}'><code>${highlighted}</code></pre></div>`;
+
+				if (block_open) {
+					block_open = false;
+					return `</div><div class="code">${html}</div></div>`;
+				}
+
+				return html;
 			};
 
 			const seen = new Set();
 
 			renderer.heading = (text, level, rawtext) => {
-				if (level <= 3) {
+				if (level <= 4) {
 					const slug = rawtext
 						.toLowerCase()
 						.replace(/[^a-zA-Z0-9]+/g, '-')
@@ -147,7 +137,6 @@ export default function() {
 			blockTypes.forEach(type => {
 				const fn = renderer[type];
 				renderer[type] = function() {
-					group = null;
 					return fn.apply(this, arguments);
 				};
 			});
@@ -156,37 +145,6 @@ export default function() {
 
 			const hashes = {};
 
-			groups.forEach(group => {
-				const main = group.blocks[0];
-				if (main.meta.repl === false) return;
-
-				const hash = getHash(group.blocks.map(block => block.source).join(''));
-				hashes[group.id] = hash;
-
-				const json5 = group.blocks.find(block => block.lang === 'json');
-
-				const title = main.meta.title;
-				if (!title) console.error(`Missing title for demo in ${file}`);
-
-				demos.set(
-					hash,
-					JSON.stringify({
-						title: title || 'Example from guide',
-						components: group.blocks
-							.filter(block => block.lang === 'html' || block.lang === 'js')
-							.map(block => {
-								const [name, type] = (block.meta.filename || '').split('.');
-								return {
-									name: name || 'App',
-									type: type || 'html',
-									source: block.source,
-								};
-							}),
-						json5: json5 && json5.source,
-					})
-				);
-			});
-
 			return {
 				html: html.replace(/@@(\d+)/g, (m, id) => hashes[id] || m),
 				metadata,
diff --git a/site/src/routes/docs/demo/[hash].json.js b/site/src/routes/docs/demo/[hash].json.js
deleted file mode 100644
index ffc30d0f14..0000000000
--- a/site/src/routes/docs/demo/[hash].json.js
+++ /dev/null
@@ -1,22 +0,0 @@
-import { demos } from '../_sections.js';
-
-export function get(req, res) {
-	const { hash } = req.params;
-
-	if (!demos.has(hash)) {
-		res.writeHead(404, {
-			'Content-Type': 'application/json'
-		});
-
-		res.end(JSON.stringify({
-			error: 'not found'
-		}));
-	} else {
-		const json = demos.get(hash);
-		res.writeHead(200, {
-			'Content-Type': 'application/json'
-		});
-
-		res.end(json);
-	}
-}
\ No newline at end of file
diff --git a/site/src/routes/docs/index.svelte b/site/src/routes/docs/index.svelte
index 5a4962336a..0cbbf547f5 100644
--- a/site/src/routes/docs/index.svelte
+++ b/site/src/routes/docs/index.svelte
@@ -82,7 +82,6 @@
 		overflow: hidden;
 		border: 1px solid #eee;
 		box-shadow: 1px 1px 6px rgba(0,0,0,0.1);
-		border-radius: var(--border-r);
 		padding: 1.6rem;
 		transition: width 0.2s, height 0.2s;
 	}
@@ -107,7 +106,7 @@
 		bottom: calc(100vh - var(--nav-h) - 10.8rem);
 		width: 100%;
 		height: 2em;
-		background: linear-gradient(to top, rgba(255,255,255,0) 0%, rgba(255,255,255,0.7) 50%, rgba(255,255,255,1) 100%);
+		background: linear-gradient(to top, rgba(103,103,120,0) 0%, rgba(103,103,120,0.7) 50%, rgba(103,103,120,1) 100%);
 		pointer-events: none;
 		z-index: 2;
 	}
@@ -119,7 +118,7 @@
 		bottom: 1.9em;
 		width: 100%;
 		height: 2em;
-		background: linear-gradient(to bottom, rgba(255,255,255,0) 0%, rgba(255,255,255,0.7) 50%, rgba(255,255,255,1) 100%);
+		background: linear-gradient(to bottom, rgba(103,103,120,0) 0%, rgba(103,103,120,0.7) 50%, rgba(103,103,120,1) 100%);
 		pointer-events: none;
 	}
 
@@ -135,10 +134,10 @@
 
 	.content {
 		width: 100%;
-		max-width: calc(var(--main-width) + var(--side-nav));
-		margin: 0 auto;
+		/* max-width: calc(var(--main-width) + var(--side-nav)); */
+		margin: 0;
 		-moz-tab-size: 2;
-		padding: var(--top-offset) 0;
+		padding: var(--top-offset) var(--side-nav);
 		tab-size: 2;
 	}
 
@@ -146,14 +145,15 @@
 		aside {
 			display: block;
 			width: var(--sidebar-w);
-			height: calc(100vh - var(--nav-h));
-			top: var(--nav-h);
-			left: var(--side-nav);
+			height: 100vh;
+			top: 0;
+			left: 0;
 			overflow: hidden;
 			box-shadow: none;
 			border: none;
 			overflow: hidden;
-			padding: 0;
+			background-color: var(--second);
+			color: white;
 		}
 
 		aside.open::before {
@@ -171,30 +171,33 @@
 		}
 
 		.sidebar {
-			padding: var(--top-offset) 3.2rem var(--top-offset) 0;
+			padding: var(--top-offset) 0;
 			font-family: var(--font);
 			overflow-y: auto;
 			height: 100%;
 			bottom: auto;
-			width: calc(var(--sidebar-w) + 5rem);
+			width: 100%;
 		}
 
 		.content {
-			max-width: none;
-			padding-left: 28rem;
+			/* max-width: none; */
+			padding-left: calc(var(--sidebar-w) + var(--side-nav));
+		}
+
+		.content :global(.side-by-side) {
+			display: grid;
+			grid-template-columns: calc(50% - 0.5em) calc(50% - 0.5em);
+			grid-gap: 1em;
 		}
 	}
 
 	@media (min-width: 1200px) { /* can't use vars in @media :( */
 		aside {
 			display: block;
-			left: calc(50vw - (60rem - var(--side-nav)));
 		}
 
 		.content {
-			width: 80rem;
-			padding-left: calc(50vw - 32rem);
-			box-sizing: content-box;
+			/* box-sizing: content-box; */
 			/* padding-right: calc(50% - 50rem); */
 		}
 	}
@@ -205,12 +208,17 @@
 		border-top: 2px solid var(--second);
 		color: var(--second);
 		line-height: 1;
+		text-transform: uppercase;
 	}
 
 	.content section:first-of-type > h2 {
 		margin-top: 0;
 	}
 
+	.content :global(h4) {
+		margin: 2em 0 1em 0;
+	}
+
 	.content :global(.offset-anchor) {
 		position: relative;
 		display: block;
@@ -234,9 +242,14 @@
 
 	@media (min-width: 768px) {
 		.content :global(h2):hover :global(.anchor),
-		.content :global(h3):hover :global(.anchor) {
+		.content :global(h3):hover :global(.anchor),
+		.content :global(h4):hover :global(.anchor) {
 			opacity: 1;
 		}
+
+		.content :global(h4):hover :global(.anchor) {
+			top: 0.4em;
+		}
 	}
 
 	.content :global(h3),
@@ -263,6 +276,10 @@
 		background: transparent;
 	}
 
+	.content :global(pre) {
+		margin: 0 0 2em 0;
+	}
+
 	.content :global(.icon) {
 		width: 20px;
 		height: 20px;
@@ -273,6 +290,18 @@
 		fill: none;
 	}
 
+	.content :global(table) {
+		margin: 0 0 2em 0;
+	}
+
+	section > :global(.code-block)> :global(pre) {
+		background: transparent;
+		color: white;
+		padding: 0;
+		border: none;
+		box-shadow: none;
+	}
+
 	/* max line-length ~60 chars */
 	section > :global(p) {
 		max-width: var(--linemax)
@@ -290,11 +319,10 @@
 	small a        { all: unset }
 	small a:before { all: unset }
 
-
 	section :global(blockquote) {
 		color: hsl(204, 100%, 50%);
 		border: 2px solid var(--flash);
-		padding-left: 8.8rem;
+		/* padding-left: 8.8rem; */
 	}
 
 	section :global(blockquote) :global(code) {
@@ -315,24 +343,24 @@
 </style>
 
 <svelte:head>
-	<title>Learn Svelte</title>
+	<title>API Docs • Svelte</title>
 </svelte:head>
 
 <div bind:this={container} class='content linkify listify'>
 	{#each sections as section}
-	<section data-id={section.slug}>
-		<h2>
-			<span class="offset-anchor" id={section.slug}></span>
-			<a href="#{section.slug}" class="anchor" aria-hidden></a>
-
-			{section.metadata.title}
-			<small>
-				<a href='https://github.com/sveltejs/svelte/edit/master/site/content/guide/{section.file}' title='edit this section'>
-					<Icon name='edit' /></a>
-			</small>
-		</h2>
-		{@html section.html}
-	</section>
+		<section data-id={section.slug}>
+			<h2>
+				<span class="offset-anchor" id={section.slug}></span>
+				<a href="#{section.slug}" class="anchor" aria-hidden></a>
+
+				{section.metadata.title}
+				<small>
+					<a href='https://github.com/sveltejs/svelte/edit/master/site/content/docs/{section.file}' title='edit this section'>
+						<Icon name='edit' /></a>
+				</small>
+			</h2>
+			{@html section.html}
+		</section>
 	{/each}
 </div>
 
diff --git a/site/static/global.css b/site/static/global.css
index 63f9d6ad5e..438a6ba5cf 100644
--- a/site/static/global.css
+++ b/site/static/global.css
@@ -166,7 +166,7 @@ a:focus {
 :root {
 	--nav-h:       6rem;
 	--top-offset:  6rem;
-	--sidebar-w:  24rem;
+	--sidebar-w:  30rem;
 	--main-width: 80rem;
 	--code-w:      72em;
 	--side-nav:  1.6rem;
diff --git a/site/static/prism.css b/site/static/prism.css
index 912aee8834..a0e0e2ab78 100644
--- a/site/static/prism.css
+++ b/site/static/prism.css
@@ -39,7 +39,7 @@ pre[class*='language-'] {
 	overflow: auto;
 	padding: 1.5rem 2rem;
 	margin: .8rem 0 2.4rem;
-	max-width: var(--code-w);
+	/* max-width: var(--code-w); */
 	border-radius: var(--border-r);
 	box-shadow: 1px 1px 0.1rem rgba(68, 68, 68, 0.05) inset;
 }
diff --git a/site/static/repl-viewer.css b/site/static/repl-viewer.css
index 9d682a3961..f4520f5109 100644
--- a/site/static/repl-viewer.css
+++ b/site/static/repl-viewer.css
@@ -33,7 +33,7 @@ input, button, select, textarea {
 	font-family: inherit;
 	font-size: inherit;
 	padding: 0.4em;
-	margin: 0 0 0.5em 0;
+	margin: 0 0.5em 0.5em 0;
 	box-sizing: border-box;
 	border: 1px solid #ccc;
 	border-radius: 2px;
diff --git a/src/compile/index.ts b/src/compile/index.ts
index b8eace97b5..e80a937932 100644
--- a/src/compile/index.ts
+++ b/src/compile/index.ts
@@ -91,7 +91,7 @@ export default function compile(source: string, options: CompileOptions = {}) {
 	const component = new Component(
 		ast,
 		source,
-		options.name || get_name(options.filename) || 'SvelteComponent',
+		options.name || get_name(options.filename) || 'Component',
 		options,
 		stats,
 		warnings
diff --git a/test/js/samples/action-custom-event-handler/expected.js b/test/js/samples/action-custom-event-handler/expected.js
index 8ecabf94be..4b758da030 100644
--- a/test/js/samples/action-custom-event-handler/expected.js
+++ b/test/js/samples/action-custom-event-handler/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -59,11 +59,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { bar, foo_function };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["bar"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/action/expected.js b/test/js/samples/action/expected.js
index edc82cc67e..cbbcb0d317 100644
--- a/test/js/samples/action/expected.js
+++ b/test/js/samples/action/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -53,11 +53,11 @@ function link(node) {
   }
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/bind-online/expected.js b/test/js/samples/bind-online/expected.js
index fa38562412..0c9faa3ef6 100644
--- a/test/js/samples/bind-online/expected.js
+++ b/test/js/samples/bind-online/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	add_render_callback,
 	init,
 	listen,
@@ -43,11 +43,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { online, onlinestatuschanged };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/bind-width-height/expected.js b/test/js/samples/bind-width-height/expected.js
index 45c9e6a835..2ef190588f 100644
--- a/test/js/samples/bind-width-height/expected.js
+++ b/test/js/samples/bind-width-height/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	add_render_callback,
 	add_resize_listener,
 	detach,
@@ -58,11 +58,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { w, h, div_resize_handler };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["w", "h"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/collapses-text-around-comments/expected.js b/test/js/samples/collapses-text-around-comments/expected.js
index e40997203b..12164d0579 100644
--- a/test/js/samples/collapses-text-around-comments/expected.js
+++ b/test/js/samples/collapses-text-around-comments/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -61,7 +61,7 @@ function instance($$self, $$props, $$invalidate) {
 	return { foo };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		if (!document.getElementById("svelte-1a7i8ec-style")) add_css();
@@ -69,4 +69,4 @@ class SvelteComponent extends SvelteComponent_1 {
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/component-static-array/expected.js b/test/js/samples/component-static-array/expected.js
index 5cb7afde75..875c741076 100644
--- a/test/js/samples/component-static-array/expected.js
+++ b/test/js/samples/component-static-array/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	mount_component,
 	noop,
@@ -48,11 +48,11 @@ function instance($$self) {
 	return { Nested };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/component-static-immutable/expected.js b/test/js/samples/component-static-immutable/expected.js
index d0335b6ba0..6612a7f1b6 100644
--- a/test/js/samples/component-static-immutable/expected.js
+++ b/test/js/samples/component-static-immutable/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	mount_component,
 	noop,
@@ -48,11 +48,11 @@ function instance($$self) {
 	return { Nested };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/component-static-immutable2/expected.js b/test/js/samples/component-static-immutable2/expected.js
index d0335b6ba0..6612a7f1b6 100644
--- a/test/js/samples/component-static-immutable2/expected.js
+++ b/test/js/samples/component-static-immutable2/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	mount_component,
 	noop,
@@ -48,11 +48,11 @@ function instance($$self) {
 	return { Nested };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/component-static/expected.js b/test/js/samples/component-static/expected.js
index faad84b26c..12ebeb28b7 100644
--- a/test/js/samples/component-static/expected.js
+++ b/test/js/samples/component-static/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	mount_component,
 	noop,
@@ -48,11 +48,11 @@ function instance($$self) {
 	return { Nested };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/computed-collapsed-if/expected.js b/test/js/samples/computed-collapsed-if/expected.js
index bc01e0dfc0..bc7c383319 100644
--- a/test/js/samples/computed-collapsed-if/expected.js
+++ b/test/js/samples/computed-collapsed-if/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	noop,
 	safe_not_equal
@@ -35,7 +35,7 @@ function instance($$self, $$props, $$invalidate) {
 	return { x, a, b };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["x", "a", "b"]);
@@ -50,4 +50,4 @@ class SvelteComponent extends SvelteComponent_1 {
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/css-media-query/expected.js b/test/js/samples/css-media-query/expected.js
index 25ee94e03f..d4be134376 100644
--- a/test/js/samples/css-media-query/expected.js
+++ b/test/js/samples/css-media-query/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -42,7 +42,7 @@ function create_fragment(ctx) {
 	};
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		if (!document.getElementById("svelte-1slhpfn-style")) add_css();
@@ -50,4 +50,4 @@ class SvelteComponent extends SvelteComponent_1 {
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/css-shadow-dom-keyframes/expected.js b/test/js/samples/css-shadow-dom-keyframes/expected.js
index 2e410e11dd..2cb5b9e974 100644
--- a/test/js/samples/css-shadow-dom-keyframes/expected.js
+++ b/test/js/samples/css-shadow-dom-keyframes/expected.js
@@ -35,7 +35,7 @@ function create_fragment(ctx) {
 	};
 }
 
-class SvelteComponent extends SvelteElement {
+class Component extends SvelteElement {
 	constructor(options) {
 		super();
 
@@ -55,6 +55,6 @@ class SvelteComponent extends SvelteElement {
 	}
 }
 
-customElements.define("custom-element", SvelteComponent);
+customElements.define("custom-element", Component);
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/debug-empty/expected.js b/test/js/samples/debug-empty/expected.js
index efe966c552..98c2837ab7 100644
--- a/test/js/samples/debug-empty/expected.js
+++ b/test/js/samples/debug-empty/expected.js
@@ -72,7 +72,7 @@ function instance($$self, $$props, $$invalidate) {
 	return { name };
 }
 
-class SvelteComponent extends SvelteComponentDev {
+class Component extends SvelteComponentDev {
 	constructor(options) {
 		super(options);
 		init(this, options, instance, create_fragment, safe_not_equal, ["name"]);
@@ -80,17 +80,17 @@ class SvelteComponent extends SvelteComponentDev {
 		const { ctx } = this.$$;
 		const props = options.props || {};
 		if (ctx.name === undefined && !('name' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'name'");
+			console.warn("<Component> was created without expected prop 'name'");
 		}
 	}
 
 	get name() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set name(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/debug-foo-bar-baz-things/expected.js b/test/js/samples/debug-foo-bar-baz-things/expected.js
index 0220664d12..c1391475b2 100644
--- a/test/js/samples/debug-foo-bar-baz-things/expected.js
+++ b/test/js/samples/debug-foo-bar-baz-things/expected.js
@@ -161,7 +161,7 @@ function instance($$self, $$props, $$invalidate) {
 	return { things, foo, bar, baz };
 }
 
-class SvelteComponent extends SvelteComponentDev {
+class Component extends SvelteComponentDev {
 	constructor(options) {
 		super(options);
 		init(this, options, instance, create_fragment, safe_not_equal, ["things", "foo", "bar", "baz"]);
@@ -169,50 +169,50 @@ class SvelteComponent extends SvelteComponentDev {
 		const { ctx } = this.$$;
 		const props = options.props || {};
 		if (ctx.things === undefined && !('things' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'things'");
+			console.warn("<Component> was created without expected prop 'things'");
 		}
 		if (ctx.foo === undefined && !('foo' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'foo'");
+			console.warn("<Component> was created without expected prop 'foo'");
 		}
 		if (ctx.bar === undefined && !('bar' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'bar'");
+			console.warn("<Component> was created without expected prop 'bar'");
 		}
 		if (ctx.baz === undefined && !('baz' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'baz'");
+			console.warn("<Component> was created without expected prop 'baz'");
 		}
 	}
 
 	get things() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set things(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	get foo() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set foo(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	get bar() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set bar(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	get baz() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set baz(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/debug-foo/expected.js b/test/js/samples/debug-foo/expected.js
index ccd5f14ec4..f5daa7dad7 100644
--- a/test/js/samples/debug-foo/expected.js
+++ b/test/js/samples/debug-foo/expected.js
@@ -159,7 +159,7 @@ function instance($$self, $$props, $$invalidate) {
 	return { things, foo };
 }
 
-class SvelteComponent extends SvelteComponentDev {
+class Component extends SvelteComponentDev {
 	constructor(options) {
 		super(options);
 		init(this, options, instance, create_fragment, safe_not_equal, ["things", "foo"]);
@@ -167,28 +167,28 @@ class SvelteComponent extends SvelteComponentDev {
 		const { ctx } = this.$$;
 		const props = options.props || {};
 		if (ctx.things === undefined && !('things' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'things'");
+			console.warn("<Component> was created without expected prop 'things'");
 		}
 		if (ctx.foo === undefined && !('foo' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'foo'");
+			console.warn("<Component> was created without expected prop 'foo'");
 		}
 	}
 
 	get things() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set things(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	get foo() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set foo(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/debug-ssr-foo/expected.js b/test/js/samples/debug-ssr-foo/expected.js
index 02bbec5fba..1b51af2592 100644
--- a/test/js/samples/debug-ssr-foo/expected.js
+++ b/test/js/samples/debug-ssr-foo/expected.js
@@ -6,7 +6,7 @@ import {
 	escape
 } from "svelte/internal";
 
-const SvelteComponent = create_ssr_component(($$result, $$props, $$bindings, $$slots) => {
+const Component = create_ssr_component(($$result, $$props, $$bindings, $$slots) => {
 	let { things, foo } = $$props;
 
 	if ($$props.things === void 0 && $$bindings.things && things !== void 0) $$bindings.things(things);
@@ -18,4 +18,4 @@ const SvelteComponent = create_ssr_component(($$result, $$props, $$bindings, $$s
 	<p>foo: ${escape(foo)}</p>`;
 });
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/deconflict-builtins/expected.js b/test/js/samples/deconflict-builtins/expected.js
index 3985faa362..3294778aa3 100644
--- a/test/js/samples/deconflict-builtins/expected.js
+++ b/test/js/samples/deconflict-builtins/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	destroy_each,
 	detach,
@@ -123,11 +123,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { createElement };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["createElement"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/deconflict-globals/expected.js b/test/js/samples/deconflict-globals/expected.js
index fe941d2b24..347d0417ec 100644
--- a/test/js/samples/deconflict-globals/expected.js
+++ b/test/js/samples/deconflict-globals/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	noop,
 	safe_not_equal
@@ -32,11 +32,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { foo };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["foo"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/dev-warning-missing-data-computed/expected.js b/test/js/samples/dev-warning-missing-data-computed/expected.js
index 3840e9544d..ff1f48e2be 100644
--- a/test/js/samples/dev-warning-missing-data-computed/expected.js
+++ b/test/js/samples/dev-warning-missing-data-computed/expected.js
@@ -78,7 +78,7 @@ function instance($$self, $$props, $$invalidate) {
 	return { foo, bar };
 }
 
-class SvelteComponent extends SvelteComponentDev {
+class Component extends SvelteComponentDev {
 	constructor(options) {
 		super(options);
 		init(this, options, instance, create_fragment, safe_not_equal, ["foo"]);
@@ -86,17 +86,17 @@ class SvelteComponent extends SvelteComponentDev {
 		const { ctx } = this.$$;
 		const props = options.props || {};
 		if (ctx.foo === undefined && !('foo' in props)) {
-			console.warn("<SvelteComponent> was created without expected prop 'foo'");
+			console.warn("<Component> was created without expected prop 'foo'");
 		}
 	}
 
 	get foo() {
-		throw new Error("<SvelteComponent>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 
 	set foo(value) {
-		throw new Error("<SvelteComponent>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
+		throw new Error("<Component>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/do-use-dataset/expected.js b/test/js/samples/do-use-dataset/expected.js
index 60a8c54869..4a1ffc4913 100644
--- a/test/js/samples/do-use-dataset/expected.js
+++ b/test/js/samples/do-use-dataset/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -57,11 +57,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { bar };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["bar"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/dont-invalidate-this/expected.js b/test/js/samples/dont-invalidate-this/expected.js
index 2b3cd63514..92033148eb 100644
--- a/test/js/samples/dont-invalidate-this/expected.js
+++ b/test/js/samples/dont-invalidate-this/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -41,11 +41,11 @@ function make_uppercase() {
 	this.value = this.value.toUpperCase();
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/dont-use-dataset-in-legacy/expected.js b/test/js/samples/dont-use-dataset-in-legacy/expected.js
index 4d63cb8c73..12ba50e69f 100644
--- a/test/js/samples/dont-use-dataset-in-legacy/expected.js
+++ b/test/js/samples/dont-use-dataset-in-legacy/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	attr,
 	detach,
 	element,
@@ -58,11 +58,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { bar };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["bar"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/dont-use-dataset-in-svg/expected.js b/test/js/samples/dont-use-dataset-in-svg/expected.js
index 3f58d7f155..0862d1bbc6 100644
--- a/test/js/samples/dont-use-dataset-in-svg/expected.js
+++ b/test/js/samples/dont-use-dataset-in-svg/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	attr,
 	detach,
@@ -56,11 +56,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { bar };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["bar"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/dynamic-import/expected.js b/test/js/samples/dynamic-import/expected.js
index 85d5ed0cbe..2d51bcf60d 100644
--- a/test/js/samples/dynamic-import/expected.js
+++ b/test/js/samples/dynamic-import/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	mount_component,
 	noop,
@@ -47,11 +47,11 @@ function func() {
 	return import('./Foo.svelte');
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/each-block-array-literal/expected.js b/test/js/samples/each-block-array-literal/expected.js
index 766cfceb71..455cb2f25f 100644
--- a/test/js/samples/each-block-array-literal/expected.js
+++ b/test/js/samples/each-block-array-literal/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	destroy_each,
 	detach,
@@ -126,11 +126,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { a, b, c, d, e };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["a", "b", "c", "d", "e"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/each-block-changed-check/expected.js b/test/js/samples/each-block-changed-check/expected.js
index c65cd3479a..951565bae4 100644
--- a/test/js/samples/each-block-changed-check/expected.js
+++ b/test/js/samples/each-block-changed-check/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	destroy_each,
 	detach,
@@ -167,11 +167,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { comments, elapsed, time, foo };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["comments", "elapsed", "time", "foo"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/each-block-keyed-animated/expected.js b/test/js/samples/each-block-keyed-animated/expected.js
index aa9215b56d..b168fb024e 100644
--- a/test/js/samples/each-block-keyed-animated/expected.js
+++ b/test/js/samples/each-block-keyed-animated/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	blank_object,
 	create_animation,
@@ -142,11 +142,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { things };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["things"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/each-block-keyed/expected.js b/test/js/samples/each-block-keyed/expected.js
index 8688d3af9a..a24841813c 100644
--- a/test/js/samples/each-block-keyed/expected.js
+++ b/test/js/samples/each-block-keyed/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	blank_object,
 	destroy_block,
@@ -110,11 +110,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { things };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["things"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/event-handler-no-passive/expected.js b/test/js/samples/event-handler-no-passive/expected.js
index 55e22666c1..41fcbeeb2a 100644
--- a/test/js/samples/event-handler-no-passive/expected.js
+++ b/test/js/samples/event-handler-no-passive/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -43,11 +43,11 @@ function touchstart_handler(e) {
 	return e.preventDefault();
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/event-modifiers/expected.js b/test/js/samples/event-modifiers/expected.js
index 617ccff197..bd449ea5a4 100644
--- a/test/js/samples/event-modifiers/expected.js
+++ b/test/js/samples/event-modifiers/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -68,11 +68,11 @@ function handleClick() {
 	// ...
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/head-no-whitespace/expected.js b/test/js/samples/head-no-whitespace/expected.js
index 552281ba66..b95177bba7 100644
--- a/test/js/samples/head-no-whitespace/expected.js
+++ b/test/js/samples/head-no-whitespace/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -38,11 +38,11 @@ function create_fragment(ctx) {
 	};
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/hoisted-const/expected.js b/test/js/samples/hoisted-const/expected.js
index 8f061bf80b..3e711e99ab 100644
--- a/test/js/samples/hoisted-const/expected.js
+++ b/test/js/samples/hoisted-const/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -41,11 +41,11 @@ const ANSWER = 42;
 
 function get_answer() { return ANSWER; }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/hoisted-let/expected.js b/test/js/samples/hoisted-let/expected.js
index 52390c1e26..210a63e28a 100644
--- a/test/js/samples/hoisted-let/expected.js
+++ b/test/js/samples/hoisted-let/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -41,11 +41,11 @@ let ANSWER = 42;
 
 function get_answer() { return ANSWER; }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/if-block-no-update/expected.js b/test/js/samples/if-block-no-update/expected.js
index 1605696736..0dca40a81e 100644
--- a/test/js/samples/if-block-no-update/expected.js
+++ b/test/js/samples/if-block-no-update/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	empty,
@@ -110,11 +110,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { foo };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["foo"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/if-block-simple/expected.js b/test/js/samples/if-block-simple/expected.js
index 44c8ed31db..94b0f37f31 100644
--- a/test/js/samples/if-block-simple/expected.js
+++ b/test/js/samples/if-block-simple/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	empty,
@@ -84,11 +84,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { foo };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["foo"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/inline-style-optimized-multiple/expected.js b/test/js/samples/inline-style-optimized-multiple/expected.js
index 9766ca3738..ea1d90e831 100644
--- a/test/js/samples/inline-style-optimized-multiple/expected.js
+++ b/test/js/samples/inline-style-optimized-multiple/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -57,11 +57,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { color, x, y };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["color", "x", "y"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/inline-style-optimized-url/expected.js b/test/js/samples/inline-style-optimized-url/expected.js
index ffa679c429..8dfc48447d 100644
--- a/test/js/samples/inline-style-optimized-url/expected.js
+++ b/test/js/samples/inline-style-optimized-url/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -50,11 +50,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { data };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["data"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/inline-style-optimized/expected.js b/test/js/samples/inline-style-optimized/expected.js
index 0b97d34d56..1170c25458 100644
--- a/test/js/samples/inline-style-optimized/expected.js
+++ b/test/js/samples/inline-style-optimized/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -50,11 +50,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { color };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["color"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/inline-style-unoptimized/expected.js b/test/js/samples/inline-style-unoptimized/expected.js
index f2e52ebb48..8f3b668827 100644
--- a/test/js/samples/inline-style-unoptimized/expected.js
+++ b/test/js/samples/inline-style-unoptimized/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -63,11 +63,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { style, key, value };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["style", "key", "value"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/input-files/expected.js b/test/js/samples/input-files/expected.js
index dad2af168c..ed11518df2 100644
--- a/test/js/samples/input-files/expected.js
+++ b/test/js/samples/input-files/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	attr,
 	detach,
 	element,
@@ -55,11 +55,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { files, input_input_handler };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["files"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/input-range/expected.js b/test/js/samples/input-range/expected.js
index c57ef4f73b..8331e73bad 100644
--- a/test/js/samples/input-range/expected.js
+++ b/test/js/samples/input-range/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	attr,
 	detach,
 	element,
@@ -65,11 +65,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { value, input_change_input_handler };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["value"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/input-without-blowback-guard/expected.js b/test/js/samples/input-without-blowback-guard/expected.js
index d47753396f..d97326fcea 100644
--- a/test/js/samples/input-without-blowback-guard/expected.js
+++ b/test/js/samples/input-without-blowback-guard/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	attr,
 	detach,
 	element,
@@ -59,11 +59,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { foo, input_change_handler };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["foo"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/instrumentation-script-if-no-block/expected.js b/test/js/samples/instrumentation-script-if-no-block/expected.js
index 4788fc2e09..6ab3e37f1f 100644
--- a/test/js/samples/instrumentation-script-if-no-block/expected.js
+++ b/test/js/samples/instrumentation-script-if-no-block/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -67,11 +67,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { x, foo };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/instrumentation-script-x-equals-x/expected.js b/test/js/samples/instrumentation-script-x-equals-x/expected.js
index 165c4e27b0..5cec1a3623 100644
--- a/test/js/samples/instrumentation-script-x-equals-x/expected.js
+++ b/test/js/samples/instrumentation-script-x-equals-x/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -68,11 +68,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { things, foo };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/instrumentation-template-if-no-block/expected.js b/test/js/samples/instrumentation-template-if-no-block/expected.js
index 38f7f7fcd0..1b8cbb257a 100644
--- a/test/js/samples/instrumentation-template-if-no-block/expected.js
+++ b/test/js/samples/instrumentation-template-if-no-block/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -67,11 +67,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { x, click_handler };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/instrumentation-template-x-equals-x/expected.js b/test/js/samples/instrumentation-template-x-equals-x/expected.js
index 4adc229ff7..29e0c111f9 100644
--- a/test/js/samples/instrumentation-template-x-equals-x/expected.js
+++ b/test/js/samples/instrumentation-template-x-equals-x/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -65,11 +65,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { things, click_handler };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/legacy-input-type/expected.js b/test/js/samples/legacy-input-type/expected.js
index 1b3b32f6ce..4c77259a64 100644
--- a/test/js/samples/legacy-input-type/expected.js
+++ b/test/js/samples/legacy-input-type/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	element,
 	init,
@@ -35,11 +35,11 @@ function create_fragment(ctx) {
 	};
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/media-bindings/expected.js b/test/js/samples/media-bindings/expected.js
index 00bee3234c..8a193f698b 100644
--- a/test/js/samples/media-bindings/expected.js
+++ b/test/js/samples/media-bindings/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	add_render_callback,
 	detach,
 	element,
@@ -144,11 +144,11 @@ function instance($$self, $$props, $$invalidate) {
 	};
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["buffered", "seekable", "played", "currentTime", "duration", "paused", "volume", "playbackRate"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/non-imported-component/expected.js b/test/js/samples/non-imported-component/expected.js
index 2fb8bb1798..20ac461c76 100644
--- a/test/js/samples/non-imported-component/expected.js
+++ b/test/js/samples/non-imported-component/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	detach,
 	init,
 	insert,
@@ -61,11 +61,11 @@ function create_fragment(ctx) {
 	};
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/non-mutable-reference/expected.js b/test/js/samples/non-mutable-reference/expected.js
index 1bad71a937..b6d63a387f 100644
--- a/test/js/samples/non-mutable-reference/expected.js
+++ b/test/js/samples/non-mutable-reference/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -43,11 +43,11 @@ function create_fragment(ctx) {
 
 let name = 'world';
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/reactive-values-non-topologically-ordered/expected.js b/test/js/samples/reactive-values-non-topologically-ordered/expected.js
index bac07ebc7c..a0a5363d6f 100644
--- a/test/js/samples/reactive-values-non-topologically-ordered/expected.js
+++ b/test/js/samples/reactive-values-non-topologically-ordered/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	noop,
 	safe_not_equal
@@ -39,11 +39,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { x };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["x"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/reactive-values-non-writable-dependencies/expected.js b/test/js/samples/reactive-values-non-writable-dependencies/expected.js
index b9aabdf76e..2e4507222f 100644
--- a/test/js/samples/reactive-values-non-writable-dependencies/expected.js
+++ b/test/js/samples/reactive-values-non-writable-dependencies/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	noop,
 	safe_not_equal
@@ -35,11 +35,11 @@ function instance($$self, $$props, $$invalidate) {
 	return {};
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/select-dynamic-value/expected.js b/test/js/samples/select-dynamic-value/expected.js
index 82698aafdc..5a0af01f99 100644
--- a/test/js/samples/select-dynamic-value/expected.js
+++ b/test/js/samples/select-dynamic-value/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -76,11 +76,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { current };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["current"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/setup-method/expected.js b/test/js/samples/setup-method/expected.js
index dbde1c9039..e9370d0e2b 100644
--- a/test/js/samples/setup-method/expected.js
+++ b/test/js/samples/setup-method/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	noop,
 	safe_not_equal
@@ -23,7 +23,7 @@ function foo(bar) {
 	console.log(bar);
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, ["foo"]);
@@ -34,5 +34,5 @@ class SvelteComponent extends SvelteComponent_1 {
 	}
 }
 
-export default SvelteComponent;
+export default Component;
 export { SOME_CONSTANT };
\ No newline at end of file
diff --git a/test/js/samples/ssr-no-oncreate-etc/expected.js b/test/js/samples/ssr-no-oncreate-etc/expected.js
index 45f86d3682..06cdf057e3 100644
--- a/test/js/samples/ssr-no-oncreate-etc/expected.js
+++ b/test/js/samples/ssr-no-oncreate-etc/expected.js
@@ -14,7 +14,7 @@ function swipe(node, callback) {
 	// TODO implement
 }
 
-const SvelteComponent = create_ssr_component(($$result, $$props, $$bindings, $$slots) => {
+const Component = create_ssr_component(($$result, $$props, $$bindings, $$slots) => {
 	onMount(() => {
 		console.log('onMount');
 	});
@@ -26,5 +26,5 @@ const SvelteComponent = create_ssr_component(($$result, $$props, $$bindings, $$s
 	return ``;
 });
 
-export default SvelteComponent;
+export default Component;
 export { preload };
\ No newline at end of file
diff --git a/test/js/samples/ssr-preserve-comments/expected.js b/test/js/samples/ssr-preserve-comments/expected.js
index e910b63df2..d9a63e6011 100644
--- a/test/js/samples/ssr-preserve-comments/expected.js
+++ b/test/js/samples/ssr-preserve-comments/expected.js
@@ -1,10 +1,10 @@
 /* generated by Svelte vX.Y.Z */
 import { create_ssr_component } from "svelte/internal";
 
-const SvelteComponent = create_ssr_component(($$result, $$props, $$bindings, $$slots) => {
+const Component = create_ssr_component(($$result, $$props, $$bindings, $$slots) => {
 	return `<div>content</div>
 	<!-- comment -->
 	<div>more content</div>`;
 });
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/svg-title/expected.js b/test/js/samples/svg-title/expected.js
index 49bd406987..57e3fa3050 100644
--- a/test/js/samples/svg-title/expected.js
+++ b/test/js/samples/svg-title/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	init,
@@ -39,11 +39,11 @@ function create_fragment(ctx) {
 	};
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, null, create_fragment, safe_not_equal, []);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/title/expected.js b/test/js/samples/title/expected.js
index 076582ac6f..884f39e246 100644
--- a/test/js/samples/title/expected.js
+++ b/test/js/samples/title/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	init,
 	noop,
 	safe_not_equal
@@ -37,11 +37,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { custom };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["custom"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/transition-local/expected.js b/test/js/samples/transition-local/expected.js
index 85979e9959..2df99a4c87 100644
--- a/test/js/samples/transition-local/expected.js
+++ b/test/js/samples/transition-local/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	add_render_callback,
 	create_in_transition,
 	detach,
@@ -147,11 +147,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { x, y };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["x", "y"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/use-elements-as-anchors/expected.js b/test/js/samples/use-elements-as-anchors/expected.js
index bb708284b4..b93817d416 100644
--- a/test/js/samples/use-elements-as-anchors/expected.js
+++ b/test/js/samples/use-elements-as-anchors/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	append,
 	detach,
 	element,
@@ -271,11 +271,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { a, b, c, d, e };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["a", "b", "c", "d", "e"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file
diff --git a/test/js/samples/window-binding-scroll/expected.js b/test/js/samples/window-binding-scroll/expected.js
index 5a6601b851..18f5210bea 100644
--- a/test/js/samples/window-binding-scroll/expected.js
+++ b/test/js/samples/window-binding-scroll/expected.js
@@ -1,6 +1,6 @@
 /* generated by Svelte vX.Y.Z */
 import {
-	SvelteComponent as SvelteComponent_1,
+	SvelteComponent,
 	add_render_callback,
 	append,
 	detach,
@@ -78,11 +78,11 @@ function instance($$self, $$props, $$invalidate) {
 	return { y, onwindowscroll };
 }
 
-class SvelteComponent extends SvelteComponent_1 {
+class Component extends SvelteComponent {
 	constructor(options) {
 		super();
 		init(this, options, instance, create_fragment, safe_not_equal, ["y"]);
 	}
 }
 
-export default SvelteComponent;
\ No newline at end of file
+export default Component;
\ No newline at end of file