start adding site to main repo

.netlify/state.json

@@ -0,0 +1,3 @@
+{
+	"siteId": "a6a3cfed-c34e-42f7-9616-07ad2eedb15f"
+}

site/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+node_modules
+yarn-error.log
+/cypress/screenshots/
+/__sapper__/

site/README.md

@@ -0,0 +1,88 @@
+# sapper-template
+
+The default [Sapper](https://github.com/sveltejs/sapper) template, with branches for Rollup and webpack. To clone it and get started:
+
+```bash
+# for Rollup
+npx degit sveltejs/sapper-template#rollup my-app
+# for webpack
+npx degit sveltejs/sapper-template#webpack my-app
+cd my-app
+npm install # or yarn!
+npm run dev
+```
+
+Open up [localhost:3000](http://localhost:3000) and start clicking around.
+
+Consult [sapper.svelte.technology](https://sapper.svelte.technology) for help getting started.
+
+
+## Structure
+
+Sapper expects to find two directories in the root of your project —  `src` and `static`.
+
+
+### src
+
+The [src](src) directory contains the entry points for your app — `client.js`, `server.js` and (optionally) a `service-worker.js` — along with a `template.html` file and a `routes` directory.
+
+
+#### src/routes
+
+This is the heart of your Sapper app. There are two kinds of routes — *pages*, and *server routes*.
+
+**Pages** are Svelte components written in `.html` files. When a user first visits the application, they will be served a server-rendered version of the route in question, plus some JavaScript that 'hydrates' the page and initialises a client-side router. From that point forward, navigating to other pages is handled entirely on the client for a fast, app-like feel. (Sapper will preload and cache the code for these subsequent pages, so that navigation is instantaneous.)
+
+**Server routes** are modules written in `.js` files, that export functions corresponding to HTTP methods. Each function receives Express `request` and `response` objects as arguments, plus a `next` function. This is useful for creating a JSON API, for example.
+
+There are three simple rules for naming the files that define your routes:
+
+* A file called `src/routes/about.html` corresponds to the `/about` route. A file called `src/routes/blog/[slug].html` corresponds to the `/blog/:slug` route, in which case `params.slug` is available to the route
+* The file `src/routes/index.html` (or `src/routes/index.js`) corresponds to the root of your app. `src/routes/about/index.html` is treated the same as `src/routes/about.html`.
+* Files and directories with a leading underscore do *not* create routes. This allows you to colocate helper modules and components with the routes that depend on them — for example you could have a file called `src/routes/_helpers/datetime.js` and it would *not* create a `/_helpers/datetime` route
+
+
+### static
+
+The [static](static) directory contains any static assets that should be available. These are served using [sirv](https://github.com/lukeed/sirv).
+
+In your [service-worker.js](app/service-worker.js) file, you can import these as `files` from the generated manifest...
+
+```js
+import { files } from '../__sapper__/service-worker.js';
+```
+
+...so that you can cache them (though you can choose not to, for example if you don't want to cache very large files).
+
+
+## Bundler config
+
+Sapper uses Rollup or webpack to provide code-splitting and dynamic imports, as well as compiling your Svelte components. With webpack, it also provides hot module reloading. As long as you don't do anything daft, you can edit the configuration files to add whatever plugins you'd like.
+
+
+## Production mode and deployment
+
+To start a production version of your app, run `npm run build && npm start`. This will disable live reloading, and activate the appropriate bundler plugins.
+
+You can deploy your application to any environment that supports Node 8 or above. As an example, to deploy to [Now](https://zeit.co/now), run these commands:
+
+```bash
+npm install -g now
+now
+```
+
+
+## Using external components with webpack
+
+When using Svelte components installed from npm, such as [@sveltejs/svelte-virtual-list](https://github.com/sveltejs/svelte-virtual-list), Svelte needs the original component source (rather than any precompiled JavaScript that ships with the component). This allows the component to be rendered server-side, and also keeps your client-side app smaller.
+
+Because of that, it's essential that webpack doesn't treat the package as an *external dependency*. You can either modify the `externals` option in [webpack/server.config.js](webpack/server.config.js), or simply install the package to `devDependencies` rather than `dependencies`, which will cause it to get bundled (and therefore compiled) with your app:
+
+```bash
+yarn add -D @sveltejs/svelte-virtual-list
+```
+
+
+## Bugs and feedback
+
+Sapper is in early development, and may have the odd rough edge here and there. Please be vocal over on the [Sapper issue tracker](https://github.com/sveltejs/sapper/issues).

site/appveyor.yml

@@ -0,0 +1,18 @@
+version: "{build}"
+
+shallow_clone: true
+
+init:
+  - git config --global core.autocrlf false
+
+build: off
+
+environment:
+  matrix:
+    # node.js
+    - nodejs_version: stable
+
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - npm install cypress
+  - npm install

site/config.js

@@ -0,0 +1,3 @@
+export const SLUG_PRESERVE_UNICODE = false;
+export const SLUG_SEPARATOR = '_';
+export const SLUG_LANG = 'en';

site/content/docs/00-introduction.md

@@ -0,0 +1,52 @@
+---
+title: Introduction
+---
+
+### Before we begin
+
+> Sapper is in early development, and some things may change before we hit version 1.0. This document is a work-in-progress. If you get stuck, reach out for help in the [Discord chatroom](https://discord.gg/yy75DKs).
+>
+> See the [migration guides](migrating) for help upgrading from older versions.
+
+### What is Sapper?
+
+Sapper is a framework for building extremely high-performance web apps. You're looking at one right now! There are two basic concepts:
+
+* Each page of your app is a [Svelte](https://svelte.dev) component
+* You create pages by adding files to the `src/routes` directory of your project. These will be server-rendered so that a user's first visit to your app is as fast as possible, then a client-side app takes over
+
+Building an app with all the modern best practices — code-splitting, offline support, server-rendered views with client-side hydration — is fiendishly complicated. Sapper does all the boring stuff for you so that you can get on with the creative part.
+
+You don't need to know Svelte to understand the rest of this guide, but it will help. In short, it's a UI framework that compiles your components to highly optimized vanilla JavaScript. Read the [introductory blog post](https://svelte.dev/blog/svelte-3-rethinking-reactivity) and the [tutorial](https://svelte.dev/tutorial) to learn more.
+
+
+### Why the name?
+
+In war, the soldiers who build bridges, repair roads, clear minefields and conduct demolitions — all under combat conditions — are known as *sappers*.
+
+For web developers, the stakes are generally lower than for combat engineers. But we face our own hostile environment: underpowered devices, poor network connections, and the complexity inherent in front-end engineering. Sapper, which is short for <b>S</b>velte <b>app</b> mak<b>er</b>, is your courageous and dutiful ally.
+
+
+### Comparison with Next.js
+
+[Next.js](https://github.com/zeit/next.js) is a React framework from [Zeit](https://zeit.co), and is the inspiration for Sapper. There are a few notable differences, however:
+
+* Sapper is powered by Svelte instead of React, so it's faster and your apps are smaller
+* Instead of route masking, we encode route parameters in filenames (see the [routing](docs#routing) section below)
+* As well as *pages*, you can create *server routes* in your `src/routes` directory. This makes it very easy to, for example, add a JSON API such as the one powering this very page (try visiting [/docs.json](/docs.json))
+* Links are just `<a>` elements, rather than framework-specific `<Link>` components. That means, for example, that [this link right here](/), despite being inside a blob of markdown, works with the router as you'd expect
+
+
+### Getting started
+
+The easiest way to start building a Sapper app is to clone the [sapper-template](https://github.com/sveltejs/sapper-template) repo with [degit](https://github.com/Rich-Harris/degit):
+
+```bash
+npx degit sveltejs/sapper-template#rollup my-app
+# or: npx degit sveltejs/sapper-template#webpack my-app
+cd my-app
+npm install
+npm run dev
+```
+
+This will scaffold a new project in the `my-app` directory, install its dependencies, and start a server on [localhost:3000](http://localhost:3000). Try editing the files to get a feel for how everything works – you may not need to bother reading the rest of this guide!

site/content/docs/01-structure.md

@@ -0,0 +1,112 @@
+---
+title: Sapper app structure
+---
+
+This section is a reference for the curious. We recommend you play around with the project template first, and come back here when you've got a feel for how things fit together.
+
+If you take a look inside the [sapper-template](https://github.com/sveltejs/sapper-template) repo, you'll see some files that Sapper expects to find:
+
+```bash
+├ package.json
+├ src
+│ ├ routes
+│ │ ├ # your routes here
+│ │ ├ _error.svelte
+│ │ └ index.svelte
+│ ├ client.js
+│ ├ server.js
+│ ├ service-worker.js
+│ └ template.html
+├ static
+│ ├ # your files here
+└ rollup.config.js / webpack.config.js
+```
+
+When you first run Sapper, it will create an additional `__sapper__` directory containing generated files.
+
+You'll notice a few extra files and a `cypress` directory which relates to [testing](docs#testing) — we don't need to worry about those right now.
+
+> You *can* create these files from scratch, but it's much better to use the template. See [getting started](docs#getting-started) for instructions on how to easily clone it
+
+
+### package.json
+
+Your package.json contains your app's dependencies and defines a number of scripts:
+
+* `npm run dev` — start the app in development mode, and watch source files for changes
+* `npm run build` — build the app in production mode
+* `npm run export` — bake out a static version, if applicable (see [exporting](docs#exporting))
+* `npm start` — start the app in production mode after you've built it
+* `npm test` — run the tests (see [testing](docs#testing))
+
+
+### src
+
+This contains the three *entry points* for your app — `src/client.js`, `src/server.js` and (optionally) `src/service-worker.js` — along with a `src/template.html` file.
+
+#### src/client.js
+
+This *must* import, and call, the `start` function from the generated `@sapper/app` module:
+
+```js
+import * as sapper from '@sapper/app';
+
+sapper.start({
+	target: document.querySelector('#sapper')
+});
+```
+
+In many cases, that's the entirety of your entry module, though you can do as much or as little here as you wish. See the [client API](docs#client-api) section for more information on functions you can import.
+
+
+#### src/server.js
+
+This is a normal Express (or [Polka](https://github.com/lukeed/polka), etc) app, with three requirements:
+
+* it should serve the contents of the `static` folder, using for example [sirv](https://github.com/lukeed/sirv)
+* it should call `app.use(sapper.middleware())` at the end, where `sapper` is imported from `@sapper/server`
+* it must listen on `process.env.PORT`
+
+Beyond that, you can write the server however you like.
+
+
+#### src/service-worker.js
+
+Service workers act as proxy servers that give you fine-grained control over how to respond to network requests. For example, when the browser requests `/goats.jpg`, the service worker can respond with a file it previously cached, or it can pass the request on to the server, or it could even respond with something completely different, such as a picture of llamas.
+
+Among other things, this makes it possible to build applications that work offline.
+
+Because every app needs a slightly different service worker (sometimes it's appropriate to always serve from the cache, sometimes that should only be a last resort in case of no connectivity), Sapper doesn't attempt to control the service worker. Instead, you write the logic in `service-worker.js`. You can import any of the following from `@sapper/service-worker`:
+
+* `files` — an array of files found in the `static` directory
+* `shell` — the client-side JavaScript generated by the bundler (Rollup or webpack)
+* `routes` — an array of `{ pattern: RegExp }` objects you can use to determine whether a Sapper-controlled page is being requested
+* `timestamp` — the time the service worker was generated (useful for generating unique cache names)
+
+
+#### src/template.html
+
+This file is a template for responses from the server. Sapper will inject content that replaces the following tags:
+
+* `%sapper.base%` — a `<base>` element (see [base URLs](docs#base-urls))
+* `%sapper.styles%` — critical CSS for the page being requested
+* `%sapper.head%` — HTML representing page-specific `<head>` contents, like `<title>`
+* `%sapper.html%` — HTML representing the body of the page being rendered
+* `%sapper.scripts%` — script tags for the client-side app
+
+
+### src/routes
+
+This is the meat of your app — the pages and server routes. See the section on [routing](docs#routing) for the juicy details.
+
+
+### static
+
+This is a place to put any files that your app uses — fonts, images and so on. For example `static/favicon.png` will be served as `/favicon.png`.
+
+Sapper doesn't serve these files — you'd typically use [sirv](https://github.com/lukeed/sirv) or [serve-static](https://github.com/expressjs/serve-static) for that — but it will read the contents of the `static` folder so that you can easily generate a cache manifest for offline support (see [service-worker.js](docs#templates-service-worker-js)).
+
+
+### rollup.config.js / webpack.config.js
+
+Sapper can use [Rollup](https://rollupjs.org/) or [webpack](https://webpack.js.org/) to bundle your app. You probably won't need to change the config, but if you want to (for example to add new loaders or plugins), you can.