@sveltejs/kit 1.0.0-next.40 → 1.0.0-next.402

package/dist/chunks/index.js

@@ -1,3519 +1,675 @@
-import http from 'http';
-import fs from 'fs';
-import path from 'path';
-import { parse, URLSearchParams } from 'url';
-import require$$0, { EventEmitter } from 'events';
-import CheapWatch from 'cheap-watch';
-import util from 'util';
-import os from 'os';
-import https from 'https';
-import require$$1 from 'child_process';
-import require$$0$1 from 'domain';
-import 'querystring';
-import vm from 'vm';
-import vite from 'vite';
-import { c as create_manifest_data, a as create_app } from './index2.js';
-import { r as rimraf, c as copy_assets } from './utils.js';
-import { ssr } from '../ssr.js';
-import { g as get_body } from './index3.js';
-import svelte from '@svitejs/vite-plugin-svelte';
-import './standard.js';
-import '../cli.js';
-import 'sade';
-import 'crypto';
-import 'stream';
-import 'zlib';
-
-function createCommonjsModule(fn) {
-  var module = { exports: {} };
-	return fn(module, module.exports), module.exports;
+import fs__default from 'fs';
+import path__default, { join } from 'path';
+import * as url from 'url';
+
+let FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, isTTY=true;
+if (typeof process !== 'undefined') {
+	({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+	isTTY = process.stdout && process.stdout.isTTY;
+}
+
+const $ = {
+	enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== 'dumb' && (
+		FORCE_COLOR != null && FORCE_COLOR !== '0' || isTTY
+	),
+
+	// modifiers
+	reset: init(0, 0),
+	bold: init(1, 22),
+	dim: init(2, 22),
+	italic: init(3, 23),
+	underline: init(4, 24),
+	inverse: init(7, 27),
+	hidden: init(8, 28),
+	strikethrough: init(9, 29),
+
+	// colors
+	black: init(30, 39),
+	red: init(31, 39),
+	green: init(32, 39),
+	yellow: init(33, 39),
+	blue: init(34, 39),
+	magenta: init(35, 39),
+	cyan: init(36, 39),
+	white: init(37, 39),
+	gray: init(90, 39),
+	grey: init(90, 39),
+
+	// background colors
+	bgBlack: init(40, 49),
+	bgRed: init(41, 49),
+	bgGreen: init(42, 49),
+	bgYellow: init(43, 49),
+	bgBlue: init(44, 49),
+	bgMagenta: init(45, 49),
+	bgCyan: init(46, 49),
+	bgWhite: init(47, 49)
+};
+
+function run(arr, str) {
+	let i=0, tmp, beg='', end='';
+	for (; i < arr.length; i++) {
+		tmp = arr[i];
+		beg += tmp.open;
+		end += tmp.close;
+		if (!!~str.indexOf(tmp.close)) {
+			str = str.replace(tmp.rgx, tmp.close + tmp.open);
+		}
+	}
+	return beg + str + end;
+}
+
+function chain(has, keys) {
+	let ctx = { has, keys };
+
+	ctx.reset = $.reset.bind(ctx);
+	ctx.bold = $.bold.bind(ctx);
+	ctx.dim = $.dim.bind(ctx);
+	ctx.italic = $.italic.bind(ctx);
+	ctx.underline = $.underline.bind(ctx);
+	ctx.inverse = $.inverse.bind(ctx);
+	ctx.hidden = $.hidden.bind(ctx);
+	ctx.strikethrough = $.strikethrough.bind(ctx);
+
+	ctx.black = $.black.bind(ctx);
+	ctx.red = $.red.bind(ctx);
+	ctx.green = $.green.bind(ctx);
+	ctx.yellow = $.yellow.bind(ctx);
+	ctx.blue = $.blue.bind(ctx);
+	ctx.magenta = $.magenta.bind(ctx);
+	ctx.cyan = $.cyan.bind(ctx);
+	ctx.white = $.white.bind(ctx);
+	ctx.gray = $.gray.bind(ctx);
+	ctx.grey = $.grey.bind(ctx);
+
+	ctx.bgBlack = $.bgBlack.bind(ctx);
+	ctx.bgRed = $.bgRed.bind(ctx);
+	ctx.bgGreen = $.bgGreen.bind(ctx);
+	ctx.bgYellow = $.bgYellow.bind(ctx);
+	ctx.bgBlue = $.bgBlue.bind(ctx);
+	ctx.bgMagenta = $.bgMagenta.bind(ctx);
+	ctx.bgCyan = $.bgCyan.bind(ctx);
+	ctx.bgWhite = $.bgWhite.bind(ctx);
+
+	return ctx;
+}
+
+function init(open, close) {
+	let blk = {
+		open: `\x1b[${open}m`,
+		close: `\x1b[${close}m`,
+		rgx: new RegExp(`\\x1b\\[${close}m`, 'g')
+	};
+	return function (txt) {
+		if (this !== void 0 && this.has !== void 0) {
+			!!~this.has.indexOf(open) || (this.has.push(open),this.keys.push(blk));
+			return txt === void 0 ? this : $.enabled ? run(this.keys, txt+'') : txt+'';
+		}
+		return txt === void 0 ? chain([open], [blk]) : $.enabled ? run([blk], txt+'') : txt+'';
+	};
 }
 
-/*
-The MIT License (MIT)
-
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-*/
-
-var styles_1 = createCommonjsModule(function (module) {
-var styles = {};
-module['exports'] = styles;
-
-var codes = {
-  reset: [0, 0],
-
-  bold: [1, 22],
-  dim: [2, 22],
-  italic: [3, 23],
-  underline: [4, 24],
-  inverse: [7, 27],
-  hidden: [8, 28],
-  strikethrough: [9, 29],
-
-  black: [30, 39],
-  red: [31, 39],
-  green: [32, 39],
-  yellow: [33, 39],
-  blue: [34, 39],
-  magenta: [35, 39],
-  cyan: [36, 39],
-  white: [37, 39],
-  gray: [90, 39],
-  grey: [90, 39],
-
-  brightRed: [91, 39],
-  brightGreen: [92, 39],
-  brightYellow: [93, 39],
-  brightBlue: [94, 39],
-  brightMagenta: [95, 39],
-  brightCyan: [96, 39],
-  brightWhite: [97, 39],
-
-  bgBlack: [40, 49],
-  bgRed: [41, 49],
-  bgGreen: [42, 49],
-  bgYellow: [43, 49],
-  bgBlue: [44, 49],
-  bgMagenta: [45, 49],
-  bgCyan: [46, 49],
-  bgWhite: [47, 49],
-  bgGray: [100, 49],
-  bgGrey: [100, 49],
-
-  bgBrightRed: [101, 49],
-  bgBrightGreen: [102, 49],
-  bgBrightYellow: [103, 49],
-  bgBrightBlue: [104, 49],
-  bgBrightMagenta: [105, 49],
-  bgBrightCyan: [106, 49],
-  bgBrightWhite: [107, 49],
-
-  // legacy styles for colors pre v1.0.0
-  blackBG: [40, 49],
-  redBG: [41, 49],
-  greenBG: [42, 49],
-  yellowBG: [43, 49],
-  blueBG: [44, 49],
-  magentaBG: [45, 49],
-  cyanBG: [46, 49],
-  whiteBG: [47, 49],
-
-};
-
-Object.keys(codes).forEach(function(key) {
-  var val = codes[key];
-  var style = styles[key] = [];
-  style.open = '\u001b[' + val[0] + 'm';
-  style.close = '\u001b[' + val[1] + 'm';
+/** @typedef {import('./types').Validator} Validator */
+
+const directives = object({
+	'child-src': string_array(),
+	'default-src': string_array(),
+	'frame-src': string_array(),
+	'worker-src': string_array(),
+	'connect-src': string_array(),
+	'font-src': string_array(),
+	'img-src': string_array(),
+	'manifest-src': string_array(),
+	'media-src': string_array(),
+	'object-src': string_array(),
+	'prefetch-src': string_array(),
+	'script-src': string_array(),
+	'script-src-elem': string_array(),
+	'script-src-attr': string_array(),
+	'style-src': string_array(),
+	'style-src-elem': string_array(),
+	'style-src-attr': string_array(),
+	'base-uri': string_array(),
+	sandbox: string_array(),
+	'form-action': string_array(),
+	'frame-ancestors': string_array(),
+	'navigate-to': string_array(),
+	'report-uri': string_array(),
+	'report-to': string_array(),
+	'require-trusted-types-for': string_array(),
+	'trusted-types': string_array(),
+	'upgrade-insecure-requests': boolean(false),
+	'require-sri-for': string_array(),
+	'block-all-mixed-content': boolean(false),
+	'plugin-types': string_array(),
+	referrer: string_array()
 });
-});
-
-/*
-MIT License
-
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-var hasFlag = function(flag, argv) {
-  argv = argv || process.argv;
-
-  var terminatorPos = argv.indexOf('--');
-  var prefix = /^-{1,2}/.test(flag) ? '' : '--';
-  var pos = argv.indexOf(prefix + flag);
-
-  return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
-};
 
-/*
-The MIT License (MIT)
-
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+/** @type {Validator} */
+const options = object(
+	{
+		extensions: validate(['.svelte'], (input, keypath) => {
+			if (!Array.isArray(input) || !input.every((page) => typeof page === 'string')) {
+				throw new Error(`${keypath} must be an array of strings`);
+			}
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+			input.forEach((extension) => {
+				if (extension[0] !== '.') {
+					throw new Error(`Each member of ${keypath} must start with '.' — saw '${extension}'`);
+				}
 
-*/
+				if (!/^(\.[a-z0-9]+)+$/i.test(extension)) {
+					throw new Error(`File extensions must be alphanumeric — saw '${extension}'`);
+				}
+			});
 
+			return input;
+		}),
 
+		kit: object({
+			adapter: validate(null, (input, keypath) => {
+				if (typeof input !== 'object' || !input.adapt) {
+					let message = `${keypath} should be an object with an "adapt" method`;
 
+					if (Array.isArray(input) || typeof input === 'string') {
+						// for the early adapter adopters
+						message += ', rather than the name of an adapter';
+					}
 
-var env = process.env;
+					throw new Error(`${message}. See https://kit.svelte.dev/docs/adapters`);
+				}
 
-var forceColor = void 0;
-if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) {
-  forceColor = false;
-} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true')
-           || hasFlag('color=always')) {
-  forceColor = true;
-}
-if ('FORCE_COLOR' in env) {
-  forceColor = env.FORCE_COLOR.length === 0
-    || parseInt(env.FORCE_COLOR, 10) !== 0;
-}
+				return input;
+			}),
 
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-
-  return {
-    level: level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3,
-  };
-}
+			alias: validate({}, (input, keypath) => {
+				if (typeof input !== 'object') {
+					throw new Error(`${keypath} should be an object`);
+				}
 
-function supportsColor(stream) {
-  if (forceColor === false) {
-    return 0;
-  }
-
-  if (hasFlag('color=16m') || hasFlag('color=full')
-      || hasFlag('color=truecolor')) {
-    return 3;
-  }
-
-  if (hasFlag('color=256')) {
-    return 2;
-  }
-
-  if (stream && !stream.isTTY && forceColor !== true) {
-    return 0;
-  }
-
-  var min = forceColor ? 1 : 0;
-
-  if (process.platform === 'win32') {
-    // Node.js 7.5.0 is the first version of Node.js to include a patch to
-    // libuv that enables 256 color output on Windows. Anything earlier and it
-    // won't work. However, here we target Node.js 8 at minimum as it is an LTS
-    // release, and Node.js 7 is not. Windows 10 build 10586 is the first
-    // Windows release that supports 256 colors. Windows 10 build 14931 is the
-    // first release that supports 16m/TrueColor.
-    var osRelease = os.release().split('.');
-    if (Number(process.versions.node.split('.')[0]) >= 8
-        && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-
-    return 1;
-  }
-
-  if ('CI' in env) {
-    if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(function(sign) {
-      return sign in env;
-    }) || env.CI_NAME === 'codeship') {
-      return 1;
-    }
-
-    return min;
-  }
-
-  if ('TEAMCITY_VERSION' in env) {
-    return (/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0
-    );
-  }
-
-  if ('TERM_PROGRAM' in env) {
-    var version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
-
-    switch (env.TERM_PROGRAM) {
-      case 'iTerm.app':
-        return version >= 3 ? 3 : 2;
-      case 'Hyper':
-        return 3;
-      case 'Apple_Terminal':
-        return 2;
-      // No default
-    }
-  }
-
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-
-  if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-
-  if ('COLORTERM' in env) {
-    return 1;
-  }
-
-  if (env.TERM === 'dumb') {
-    return min;
-  }
-
-  return min;
-}
+				for (const key in input) {
+					assert_string(input[key], `${keypath}.${key}`);
+				}
 
-function getSupportLevel(stream) {
-  var level = supportsColor(stream);
-  return translateLevel(level);
-}
+				return input;
+			}),
 
-var supportsColors = {
-  supportsColor: getSupportLevel,
-  stdout: getSupportLevel(process.stdout),
-  stderr: getSupportLevel(process.stderr),
-};
+			// TODO: remove this for the 1.0 release
+			amp: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://kit.svelte.dev/docs/seo#amp for details on how to support AMP`
+			),
 
-var trap = createCommonjsModule(function (module) {
-module['exports'] = function runTheTrap(text, options) {
-  var result = '';
-  text = text || 'Run the trap, drop the bass';
-  text = text.split('');
-  var trap = {
-    a: ['\u0040', '\u0104', '\u023a', '\u0245', '\u0394', '\u039b', '\u0414'],
-    b: ['\u00df', '\u0181', '\u0243', '\u026e', '\u03b2', '\u0e3f'],
-    c: ['\u00a9', '\u023b', '\u03fe'],
-    d: ['\u00d0', '\u018a', '\u0500', '\u0501', '\u0502', '\u0503'],
-    e: ['\u00cb', '\u0115', '\u018e', '\u0258', '\u03a3', '\u03be', '\u04bc',
-      '\u0a6c'],
-    f: ['\u04fa'],
-    g: ['\u0262'],
-    h: ['\u0126', '\u0195', '\u04a2', '\u04ba', '\u04c7', '\u050a'],
-    i: ['\u0f0f'],
-    j: ['\u0134'],
-    k: ['\u0138', '\u04a0', '\u04c3', '\u051e'],
-    l: ['\u0139'],
-    m: ['\u028d', '\u04cd', '\u04ce', '\u0520', '\u0521', '\u0d69'],
-    n: ['\u00d1', '\u014b', '\u019d', '\u0376', '\u03a0', '\u048a'],
-    o: ['\u00d8', '\u00f5', '\u00f8', '\u01fe', '\u0298', '\u047a', '\u05dd',
-      '\u06dd', '\u0e4f'],
-    p: ['\u01f7', '\u048e'],
-    q: ['\u09cd'],
-    r: ['\u00ae', '\u01a6', '\u0210', '\u024c', '\u0280', '\u042f'],
-    s: ['\u00a7', '\u03de', '\u03df', '\u03e8'],
-    t: ['\u0141', '\u0166', '\u0373'],
-    u: ['\u01b1', '\u054d'],
-    v: ['\u05d8'],
-    w: ['\u0428', '\u0460', '\u047c', '\u0d70'],
-    x: ['\u04b2', '\u04fe', '\u04fc', '\u04fd'],
-    y: ['\u00a5', '\u04b0', '\u04cb'],
-    z: ['\u01b5', '\u0240'],
-  };
-  text.forEach(function(c) {
-    c = c.toLowerCase();
-    var chars = trap[c] || [' '];
-    var rand = Math.floor(Math.random() * chars.length);
-    if (typeof trap[c] !== 'undefined') {
-      result += trap[c][rand];
-    } else {
-      result += c;
-    }
-  });
-  return result;
-};
-});
+			appDir: validate('_app', (input, keypath) => {
+				assert_string(input, keypath);
 
-var zalgo = createCommonjsModule(function (module) {
-// please no
-module['exports'] = function zalgo(text, options) {
-  text = text || '   he is here   ';
-  var soul = {
-    'up': [
-      '̍', '̎', '̄', '̅',
-      '̿', '̑', '̆', '̐',
-      '͒', '͗', '͑', '̇',
-      '̈', '̊', '͂', '̓',
-      '̈', '͊', '͋', '͌',
-      '̃', '̂', '̌', '͐',
-      '̀', '́', '̋', '̏',
-      '̒', '̓', '̔', '̽',
-      '̉', 'ͣ', 'ͤ', 'ͥ',
-      'ͦ', 'ͧ', 'ͨ', 'ͩ',
-      'ͪ', 'ͫ', 'ͬ', 'ͭ',
-      'ͮ', 'ͯ', '̾', '͛',
-      '͆', '̚',
-    ],
-    'down': [
-      '̖', '̗', '̘', '̙',
-      '̜', '̝', '̞', '̟',
-      '̠', '̤', '̥', '̦',
-      '̩', '̪', '̫', '̬',
-      '̭', '̮', '̯', '̰',
-      '̱', '̲', '̳', '̹',
-      '̺', '̻', '̼', 'ͅ',
-      '͇', '͈', '͉', '͍',
-      '͎', '͓', '͔', '͕',
-      '͖', '͙', '͚', '̣',
-    ],
-    'mid': [
-      '̕', '̛', '̀', '́',
-      '͘', '̡', '̢', '̧',
-      '̨', '̴', '̵', '̶',
-      '͜', '͝', '͞',
-      '͟', '͠', '͢', '̸',
-      '̷', '͡', ' ҉',
-    ],
-  };
-  var all = [].concat(soul.up, soul.down, soul.mid);
-
-  function randomNumber(range) {
-    var r = Math.floor(Math.random() * range);
-    return r;
-  }
-
-  function isChar(character) {
-    var bool = false;
-    all.filter(function(i) {
-      bool = (i === character);
-    });
-    return bool;
-  }
-
-
-  function heComes(text, options) {
-    var result = '';
-    var counts;
-    var l;
-    options = options || {};
-    options['up'] =
-      typeof options['up'] !== 'undefined' ? options['up'] : true;
-    options['mid'] =
-      typeof options['mid'] !== 'undefined' ? options['mid'] : true;
-    options['down'] =
-      typeof options['down'] !== 'undefined' ? options['down'] : true;
-    options['size'] =
-      typeof options['size'] !== 'undefined' ? options['size'] : 'maxi';
-    text = text.split('');
-    for (l in text) {
-      if (isChar(l)) {
-        continue;
-      }
-      result = result + text[l];
-      counts = {'up': 0, 'down': 0, 'mid': 0};
-      switch (options.size) {
-        case 'mini':
-          counts.up = randomNumber(8);
-          counts.mid = randomNumber(2);
-          counts.down = randomNumber(8);
-          break;
-        case 'maxi':
-          counts.up = randomNumber(16) + 3;
-          counts.mid = randomNumber(4) + 1;
-          counts.down = randomNumber(64) + 3;
-          break;
-        default:
-          counts.up = randomNumber(8) + 1;
-          counts.mid = randomNumber(6) / 2;
-          counts.down = randomNumber(8) + 1;
-          break;
-      }
-
-      var arr = ['up', 'mid', 'down'];
-      for (var d in arr) {
-        var index = arr[d];
-        for (var i = 0; i <= counts[index]; i++) {
-          if (options[index]) {
-            result = result + soul[index][randomNumber(soul[index].length)];
-          }
-        }
-      }
-    }
-    return result;
-  }
-  // don't summon him
-  return heComes(text, options);
-};
-});
+				if (input) {
+					if (input.startsWith('/') || input.endsWith('/')) {
+						throw new Error(
+							"config.kit.appDir cannot start or end with '/'. See https://kit.svelte.dev/docs/configuration"
+						);
+					}
+				} else {
+					throw new Error(`${keypath} cannot be empty`);
+				}
 
-var america = createCommonjsModule(function (module) {
-module['exports'] = function(colors) {
-  return function(letter, i, exploded) {
-    if (letter === ' ') return letter;
-    switch (i%3) {
-      case 0: return colors.red(letter);
-      case 1: return colors.white(letter);
-      case 2: return colors.blue(letter);
-    }
-  };
-};
-});
+				return input;
+			}),
 
-var zebra = createCommonjsModule(function (module) {
-module['exports'] = function(colors) {
-  return function(letter, i, exploded) {
-    return i % 2 === 0 ? letter : colors.inverse(letter);
-  };
-};
-});
+			browser: object({
+				hydrate: boolean(true),
+				router: boolean(true)
+			}),
 
-var rainbow = createCommonjsModule(function (module) {
-module['exports'] = function(colors) {
-  // RoY G BiV
-  var rainbowColors = ['red', 'yellow', 'green', 'blue', 'magenta'];
-  return function(letter, i, exploded) {
-    if (letter === ' ') {
-      return letter;
-    } else {
-      return colors[rainbowColors[i++ % rainbowColors.length]](letter);
-    }
-  };
-};
-});
+			csp: object({
+				mode: list(['auto', 'hash', 'nonce']),
+				directives,
+				reportOnly: directives
+			}),
 
-var random = createCommonjsModule(function (module) {
-module['exports'] = function(colors) {
-  var available = ['underline', 'inverse', 'grey', 'yellow', 'red', 'green',
-    'blue', 'white', 'cyan', 'magenta', 'brightYellow', 'brightRed',
-    'brightGreen', 'brightBlue', 'brightWhite', 'brightCyan', 'brightMagenta'];
-  return function(letter, i, exploded) {
-    return letter === ' ' ? letter :
-      colors[
-          available[Math.round(Math.random() * (available.length - 2))]
-      ](letter);
-  };
-};
-});
+			// TODO: remove this for the 1.0 release
+			endpointExtensions: error(
+				(keypath) => `${keypath} has been renamed to config.kit.moduleExtensions`
+			),
 
-/*
+			env: object({
+				publicPrefix: string('PUBLIC_')
+			}),
 
-The MIT License (MIT)
+			files: object({
+				assets: string('static'),
+				hooks: string(join('src', 'hooks')),
+				lib: string(join('src', 'lib')),
+				params: string(join('src', 'params')),
+				routes: string(join('src', 'routes')),
+				serviceWorker: string(join('src', 'service-worker')),
+				template: string(join('src', 'app.html'))
+			}),
 
-Original Library
-  - Copyright (c) Marak Squires
+			// TODO: remove this for the 1.0 release
+			headers: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://github.com/sveltejs/kit/pull/3384 for details`
+			),
 
-Additional functionality
- - Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+			// TODO: remove this for the 1.0 release
+			host: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://github.com/sveltejs/kit/pull/3384 for details`
+			),
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+			// TODO remove for 1.0
+			hydrate: error((keypath) => `${keypath} has been moved to config.kit.browser.hydrate`),
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+			inlineStyleThreshold: number(0),
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+			methodOverride: object({
+				parameter: string('_method'),
+				allowed: validate([], (input, keypath) => {
+					if (!Array.isArray(input) || !input.every((method) => typeof method === 'string')) {
+						throw new Error(`${keypath} must be an array of strings`);
+					}
 
-*/
+					if (input.map((i) => i.toUpperCase()).includes('GET')) {
+						throw new Error(`${keypath} cannot contain "GET"`);
+					}
 
-var colors_1 = createCommonjsModule(function (module) {
-var colors = {};
-module['exports'] = colors;
+					return input;
+				})
+			}),
 
-colors.themes = {};
+			moduleExtensions: string_array(['.js', '.ts']),
 
+			outDir: string('.svelte-kit'),
 
-var ansiStyles = colors.styles = styles_1;
-var defineProps = Object.defineProperties;
-var newLineRegex = new RegExp(/[\r\n]+/g);
+			package: object({
+				dir: string('package'),
+				// excludes all .d.ts and filename starting with _
+				exports: fun((filepath) => !/^_|\/_|\.d\.ts$/.test(filepath)),
+				files: fun(() => true),
+				emitTypes: boolean(true)
+			}),
 
-colors.supportsColor = supportsColors.supportsColor;
+			paths: object({
+				base: validate('', (input, keypath) => {
+					assert_string(input, keypath);
 
-if (typeof colors.enabled === 'undefined') {
-  colors.enabled = colors.supportsColor() !== false;
-}
+					if (input !== '' && (input.endsWith('/') || !input.startsWith('/'))) {
+						throw new Error(
+							`${keypath} option must either be the empty string or a root-relative path that starts but doesn't end with '/'. See https://kit.svelte.dev/docs/configuration#paths`
+						);
+					}
 
-colors.enable = function() {
-  colors.enabled = true;
-};
+					return input;
+				}),
+				assets: validate('', (input, keypath) => {
+					assert_string(input, keypath);
 
-colors.disable = function() {
-  colors.enabled = false;
-};
+					if (input) {
+						if (!/^[a-z]+:\/\//.test(input)) {
+							throw new Error(
+								`${keypath} option must be an absolute path, if specified. See https://kit.svelte.dev/docs/configuration#paths`
+							);
+						}
 
-colors.stripColors = colors.strip = function(str) {
-  return ('' + str).replace(/\x1B\[\d+m/g, '');
-};
+						if (input.endsWith('/')) {
+							throw new Error(
+								`${keypath} option must not end with '/'. See https://kit.svelte.dev/docs/configuration#paths`
+							);
+						}
+					}
 
-// eslint-disable-next-line no-unused-vars
-colors.stylize = function stylize(str, style) {
-  if (!colors.enabled) {
-    return str+'';
-  }
+					return input;
+				})
+			}),
 
-  var styleMap = ansiStyles[style];
+			prerender: object({
+				concurrency: number(1),
+				crawl: boolean(true),
+				createIndexFiles: error(
+					(keypath) =>
+						`${keypath} has been removed — it is now controlled by the trailingSlash option. See https://kit.svelte.dev/docs/configuration#trailingslash`
+				),
+				default: boolean(false),
+				enabled: boolean(true),
+				entries: validate(['*'], (input, keypath) => {
+					if (!Array.isArray(input) || !input.every((page) => typeof page === 'string')) {
+						throw new Error(`${keypath} must be an array of strings`);
+					}
 
-  // Stylize should work for non-ANSI styles, too
-  if(!styleMap && style in colors){
-    // Style maps like trap operate as functions on strings;
-    // they don't have properties like open or close.
-    return colors[style](str);
-  }
+					input.forEach((page) => {
+						if (page !== '*' && page[0] !== '/') {
+							throw new Error(
+								`Each member of ${keypath} must be either '*' or an absolute path beginning with '/' — saw '${page}'`
+							);
+						}
+					});
+
+					return input;
+				}),
+
+				// TODO: remove this for the 1.0 release
+				force: validate(undefined, (input, keypath) => {
+					if (typeof input !== 'undefined') {
+						const newSetting = input ? 'continue' : 'fail';
+						const needsSetting = newSetting === 'continue';
+						throw new Error(
+							`${keypath} has been removed in favor of \`onError\`. In your case, set \`onError\` to "${newSetting}"${
+								needsSetting ? '' : ' (or leave it undefined)'
+							} to get the same behavior as you would with \`force: ${JSON.stringify(input)}\``
+						);
+					}
+				}),
 
-  return styleMap.open + str + styleMap.close;
-};
+				onError: validate('fail', (input, keypath) => {
+					if (typeof input === 'function') return input;
+					if (['continue', 'fail'].includes(input)) return input;
+					throw new Error(
+						`${keypath} should be either a custom function or one of "continue" or "fail"`
+					);
+				}),
 
-var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
-var escapeStringRegexp = function(str) {
-  if (typeof str !== 'string') {
-    throw new TypeError('Expected a string');
-  }
-  return str.replace(matchOperatorsRe, '\\$&');
-};
+				origin: validate('http://sveltekit-prerender', (input, keypath) => {
+					assert_string(input, keypath);
 
-function build(_styles) {
-  var builder = function builder() {
-    return applyStyle.apply(builder, arguments);
-  };
-  builder._styles = _styles;
-  // __proto__ is used because we must return a function, but there is
-  // no way to create a function with a different prototype.
-  builder.__proto__ = proto;
-  return builder;
-}
+					let origin;
 
-var styles = (function() {
-  var ret = {};
-  ansiStyles.grey = ansiStyles.gray;
-  Object.keys(ansiStyles).forEach(function(key) {
-    ansiStyles[key].closeRe =
-      new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
-    ret[key] = {
-      get: function() {
-        return build(this._styles.concat(key));
-      },
-    };
-  });
-  return ret;
-})();
-
-var proto = defineProps(function colors() {}, styles);
-
-function applyStyle() {
-  var args = Array.prototype.slice.call(arguments);
-
-  var str = args.map(function(arg) {
-    // Use weak equality check so we can colorize null/undefined in safe mode
-    if (arg != null && arg.constructor === String) {
-      return arg;
-    } else {
-      return util.inspect(arg);
-    }
-  }).join(' ');
-
-  if (!colors.enabled || !str) {
-    return str;
-  }
-
-  var newLinesPresent = str.indexOf('\n') != -1;
-
-  var nestedStyles = this._styles;
-
-  var i = nestedStyles.length;
-  while (i--) {
-    var code = ansiStyles[nestedStyles[i]];
-    str = code.open + str.replace(code.closeRe, code.open) + code.close;
-    if (newLinesPresent) {
-      str = str.replace(newLineRegex, function(match) {
-        return code.close + match + code.open;
-      });
-    }
-  }
-
-  return str;
-}
+					try {
+						origin = new URL(input).origin;
+					} catch (e) {
+						throw new Error(`${keypath} must be a valid origin`);
+					}
 
-colors.setTheme = function(theme) {
-  if (typeof theme === 'string') {
-    console.log('colors.setTheme now only accepts an object, not a string.  ' +
-      'If you are trying to set a theme from a file, it is now your (the ' +
-      'caller\'s) responsibility to require the file.  The old syntax ' +
-      'looked like colors.setTheme(__dirname + ' +
-      '\'/../themes/generic-logging.js\'); The new syntax looks like '+
-      'colors.setTheme(require(__dirname + ' +
-      '\'/../themes/generic-logging.js\'));');
-    return;
-  }
-  for (var style in theme) {
-    (function(style) {
-      colors[style] = function(str) {
-        if (typeof theme[style] === 'object') {
-          var out = str;
-          for (var i in theme[style]) {
-            out = colors[theme[style][i]](out);
-          }
-          return out;
-        }
-        return colors[theme[style]](str);
-      };
-    })(style);
-  }
-};
+					if (input !== origin) {
+						throw new Error(`${keypath} must be a valid origin (${origin} rather than ${input})`);
+					}
 
-function init() {
-  var ret = {};
-  Object.keys(styles).forEach(function(name) {
-    ret[name] = {
-      get: function() {
-        return build([name]);
-      },
-    };
-  });
-  return ret;
-}
+					return origin;
+				}),
 
-var sequencer = function sequencer(map, str) {
-  var exploded = str.split('');
-  exploded = exploded.map(map);
-  return exploded.join('');
-};
+				// TODO: remove this for the 1.0 release
+				pages: error((keypath) => `${keypath} has been renamed to \`entries\`.`)
+			}),
 
-// custom formatter methods
-colors.trap = trap;
-colors.zalgo = zalgo;
-
-// maps
-colors.maps = {};
-colors.maps.america = america(colors);
-colors.maps.zebra = zebra(colors);
-colors.maps.rainbow = rainbow(colors);
-colors.maps.random = random(colors);
-
-for (var map in colors.maps) {
-  (function(map) {
-    colors[map] = function(str) {
-      return sequencer(colors.maps[map], str);
-    };
-  })(map);
-}
+			// TODO: remove this for the 1.0 release
+			protocol: error(
+				(keypath) =>
+					`${keypath} has been removed. See https://github.com/sveltejs/kit/pull/3384 for details`
+			),
 
-defineProps(colors, init());
-});
+			// TODO remove for 1.0
+			router: error((keypath) => `${keypath} has been moved to config.kit.browser.router`),
 
-var safe = createCommonjsModule(function (module) {
-//
-// Remark: Requiring this file will use the "safe" colors API,
-// which will not touch String.prototype.
-//
-//   var colors = require('colors/safe');
-//   colors.red("foo")
-//
-//
-
-module['exports'] = colors_1;
-});
+			routes: fun((filepath) => !/(?:(?:^_|\/_)|(?:^\.|\/\.)(?!well-known))/.test(filepath)),
 
-/**
- * Module dependencies.
- */
+			serviceWorker: object({
+				register: boolean(true),
+				files: fun((filename) => !/\.DS_Store/.test(filename))
+			}),
 
-var commander = createCommonjsModule(function (module, exports) {
-var EventEmitter = require$$0.EventEmitter;
-var spawn = require$$1.spawn;
+			// TODO remove this for 1.0
+			ssr: error(
+				(keypath) =>
+					`${keypath} has been removed — use the handle hook instead: https://kit.svelte.dev/docs/hooks#handle`
+			),
 
-var dirname = path.dirname;
-var basename = path.basename;
+			// TODO remove this for 1.0
+			target: error((keypath) => `${keypath} is no longer required, and should be removed`),
 
+			trailingSlash: list(['never', 'always', 'ignore']),
 
-/**
- * Inherit `Command` from `EventEmitter.prototype`.
- */
+			version: object({
+				name: string(Date.now().toString()),
+				pollInterval: number(0)
+			}),
 
-util.inherits(Command, EventEmitter);
+			// TODO remove this for 1.0
+			vite: error((keypath) => `${keypath} has been removed — use vite.config.js instead`)
+		})
+	},
+	true
+);
 
 /**
- * Expose the root command.
+ * @param {Record<string, Validator>} children
+ * @param {boolean} [allow_unknown]
+ * @returns {Validator}
  */
+function object(children, allow_unknown = false) {
+	return (input, keypath) => {
+		/** @type {Record<string, any>} */
+		const output = {};
 
-exports = module.exports = new Command();
-
-/**
- * Expose `Command`.
- */
+		if ((input && typeof input !== 'object') || Array.isArray(input)) {
+			throw new Error(`${keypath} should be an object`);
+		}
 
-exports.Command = Command;
+		for (const key in input) {
+			if (!(key in children)) {
+				if (allow_unknown) {
+					output[key] = input[key];
+				} else {
+					let message = `Unexpected option ${keypath}.${key}`;
 
-/**
- * Expose `Option`.
- */
+					// special case
+					if (keypath === 'config.kit' && key in options) {
+						message += ` (did you mean config.${key}?)`;
+					}
 
-exports.Option = Option;
+					throw new Error(message);
+				}
+			}
+		}
 
-/**
- * Initialize a new `Option` with the given `flags` and `description`.
- *
- * @param {String} flags
- * @param {String} description
- * @api public
- */
+		for (const key in children) {
+			const validator = children[key];
+			output[key] = validator(input && input[key], `${keypath}.${key}`);
+		}
 
-function Option(flags, description) {
-  this.flags = flags;
-  this.required = ~flags.indexOf('<');
-  this.optional = ~flags.indexOf('[');
-  this.bool = !~flags.indexOf('-no-');
-  flags = flags.split(/[ ,|]+/);
-  if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift();
-  this.long = flags.shift();
-  this.description = description || '';
+		return output;
+	};
 }
 
 /**
- * Return option name.
- *
- * @return {String}
- * @api private
- */
-
-Option.prototype.name = function() {
-  return this.long
-    .replace('--', '')
-    .replace('no-', '');
-};
-
-/**
- * Return option name, in a camelcase format that can be used
- * as a object attribute key.
- *
- * @return {String}
- * @api private
- */
-
-Option.prototype.attributeName = function() {
-  return camelcase(this.name());
-};
-
-/**
- * Check if `arg` matches the short or long flag.
- *
- * @param {String} arg
- * @return {Boolean}
- * @api private
+ * @param {any} fallback
+ * @param {(value: any, keypath: string) => any} fn
+ * @returns {Validator}
  */
-
-Option.prototype.is = function(arg) {
-  return this.short === arg || this.long === arg;
-};
-
-/**
- * Initialize a new `Command`.
- *
- * @param {String} name
- * @api public
- */
-
-function Command(name) {
-  this.commands = [];
-  this.options = [];
-  this._execs = {};
-  this._allowUnknownOption = false;
-  this._args = [];
-  this._name = name || '';
+function validate(fallback, fn) {
+	return (input, keypath) => {
+		return input === undefined ? fallback : fn(input, keypath);
+	};
 }
 
 /**
- * Add command `name`.
- *
- * The `.action()` callback is invoked when the
- * command `name` is specified via __ARGV__,
- * and the remaining arguments are applied to the
- * function for access.
- *
- * When the `name` is "*" an un-matched command
- * will be passed as the first arg, followed by
- * the rest of __ARGV__ remaining.
- *
- * Examples:
- *
- *      program
- *        .version('0.0.1')
- *        .option('-C, --chdir <path>', 'change the working directory')
- *        .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
- *        .option('-T, --no-tests', 'ignore test hook')
- *
- *      program
- *        .command('setup')
- *        .description('run remote setup commands')
- *        .action(function() {
- *          console.log('setup');
- *        });
- *
- *      program
- *        .command('exec <cmd>')
- *        .description('run the given remote command')
- *        .action(function(cmd) {
- *          console.log('exec "%s"', cmd);
- *        });
- *
- *      program
- *        .command('teardown <dir> [otherDirs...]')
- *        .description('run teardown commands')
- *        .action(function(dir, otherDirs) {
- *          console.log('dir "%s"', dir);
- *          if (otherDirs) {
- *            otherDirs.forEach(function (oDir) {
- *              console.log('dir "%s"', oDir);
- *            });
- *          }
- *        });
- *
- *      program
- *        .command('*')
- *        .description('deploy the given env')
- *        .action(function(env) {
- *          console.log('deploying "%s"', env);
- *        });
- *
- *      program.parse(process.argv);
-  *
- * @param {String} name
- * @param {String} [desc] for git-style sub-commands
- * @return {Command} the new command
- * @api public
- */
-
-Command.prototype.command = function(name, desc, opts) {
-  if (typeof desc === 'object' && desc !== null) {
-    opts = desc;
-    desc = null;
-  }
-  opts = opts || {};
-  var args = name.split(/ +/);
-  var cmd = new Command(args.shift());
-
-  if (desc) {
-    cmd.description(desc);
-    this.executables = true;
-    this._execs[cmd._name] = true;
-    if (opts.isDefault) this.defaultExecutable = cmd._name;
-  }
-  cmd._noHelp = !!opts.noHelp;
-  this.commands.push(cmd);
-  cmd.parseExpectedArgs(args);
-  cmd.parent = this;
-
-  if (desc) return this;
-  return cmd;
-};
-
-/**
- * Define argument syntax for the top-level command.
- *
- * @api public
- */
-
-Command.prototype.arguments = function(desc) {
-  return this.parseExpectedArgs(desc.split(/ +/));
-};
-
-/**
- * Add an implicit `help [cmd]` subcommand
- * which invokes `--help` for the given command.
- *
- * @api private
- */
-
-Command.prototype.addImplicitHelpCommand = function() {
-  this.command('help [cmd]', 'display help for [cmd]');
-};
-
-/**
- * Parse expected `args`.
- *
- * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
- *
- * @param {Array} args
- * @return {Command} for chaining
- * @api public
- */
-
-Command.prototype.parseExpectedArgs = function(args) {
-  if (!args.length) return;
-  var self = this;
-  args.forEach(function(arg) {
-    var argDetails = {
-      required: false,
-      name: '',
-      variadic: false
-    };
-
-    switch (arg[0]) {
-      case '<':
-        argDetails.required = true;
-        argDetails.name = arg.slice(1, -1);
-        break;
-      case '[':
-        argDetails.name = arg.slice(1, -1);
-        break;
-    }
-
-    if (argDetails.name.length > 3 && argDetails.name.slice(-3) === '...') {
-      argDetails.variadic = true;
-      argDetails.name = argDetails.name.slice(0, -3);
-    }
-    if (argDetails.name) {
-      self._args.push(argDetails);
-    }
-  });
-  return this;
-};
-
-/**
- * Register callback `fn` for the command.
- *
- * Examples:
- *
- *      program
- *        .command('help')
- *        .description('display verbose help')
- *        .action(function() {
- *           // output help here
- *        });
- *
- * @param {Function} fn
- * @return {Command} for chaining
- * @api public
- */
-
-Command.prototype.action = function(fn) {
-  var self = this;
-  var listener = function(args, unknown) {
-    // Parse any so-far unknown options
-    args = args || [];
-    unknown = unknown || [];
-
-    var parsed = self.parseOptions(unknown);
-
-    // Output help if necessary
-    outputHelpIfNecessary(self, parsed.unknown);
-
-    // If there are still any unknown options, then we simply
-    // die, unless someone asked for help, in which case we give it
-    // to them, and then we die.
-    if (parsed.unknown.length > 0) {
-      self.unknownOption(parsed.unknown[0]);
-    }
-
-    // Leftover arguments need to be pushed back. Fixes issue #56
-    if (parsed.args.length) args = parsed.args.concat(args);
-
-    self._args.forEach(function(arg, i) {
-      if (arg.required && args[i] == null) {
-        self.missingArgument(arg.name);
-      } else if (arg.variadic) {
-        if (i !== self._args.length - 1) {
-          self.variadicArgNotLast(arg.name);
-        }
-
-        args[i] = args.splice(i);
-      }
-    });
-
-    // Always append ourselves to the end of the arguments,
-    // to make sure we match the number of arguments the user
-    // expects
-    if (self._args.length) {
-      args[self._args.length] = self;
-    } else {
-      args.push(self);
-    }
-
-    fn.apply(self, args);
-  };
-  var parent = this.parent || this;
-  var name = parent === this ? '*' : this._name;
-  parent.on('command:' + name, listener);
-  if (this._alias) parent.on('command:' + this._alias, listener);
-  return this;
-};
-
-/**
- * Define option with `flags`, `description` and optional
- * coercion `fn`.
- *
- * The `flags` string should contain both the short and long flags,
- * separated by comma, a pipe or space. The following are all valid
- * all will output this way when `--help` is used.
- *
- *    "-p, --pepper"
- *    "-p|--pepper"
- *    "-p --pepper"
- *
- * Examples:
- *
- *     // simple boolean defaulting to false
- *     program.option('-p, --pepper', 'add pepper');
- *
- *     --pepper
- *     program.pepper
- *     // => Boolean
- *
- *     // simple boolean defaulting to true
- *     program.option('-C, --no-cheese', 'remove cheese');
- *
- *     program.cheese
- *     // => true
- *
- *     --no-cheese
- *     program.cheese
- *     // => false
- *
- *     // required argument
- *     program.option('-C, --chdir <path>', 'change the working directory');
- *
- *     --chdir /tmp
- *     program.chdir
- *     // => "/tmp"
- *
- *     // optional argument
- *     program.option('-c, --cheese [type]', 'add cheese [marble]');
- *
- * @param {String} flags
- * @param {String} description
- * @param {Function|*} [fn] or default
- * @param {*} [defaultValue]
- * @return {Command} for chaining
- * @api public
- */
-
-Command.prototype.option = function(flags, description, fn, defaultValue) {
-  var self = this,
-    option = new Option(flags, description),
-    oname = option.name(),
-    name = option.attributeName();
-
-  // default as 3rd arg
-  if (typeof fn !== 'function') {
-    if (fn instanceof RegExp) {
-      var regex = fn;
-      fn = function(val, def) {
-        var m = regex.exec(val);
-        return m ? m[0] : def;
-      };
-    } else {
-      defaultValue = fn;
-      fn = null;
-    }
-  }
-
-  // preassign default value only for --no-*, [optional], or <required>
-  if (!option.bool || option.optional || option.required) {
-    // when --no-* we make sure default is true
-    if (!option.bool) defaultValue = true;
-    // preassign only if we have a default
-    if (defaultValue !== undefined) {
-      self[name] = defaultValue;
-      option.defaultValue = defaultValue;
-    }
-  }
-
-  // register the option
-  this.options.push(option);
-
-  // when it's passed assign the value
-  // and conditionally invoke the callback
-  this.on('option:' + oname, function(val) {
-    // coercion
-    if (val !== null && fn) {
-      val = fn(val, self[name] === undefined ? defaultValue : self[name]);
-    }
-
-    // unassigned or bool
-    if (typeof self[name] === 'boolean' || typeof self[name] === 'undefined') {
-      // if no value, bool true, and we have a default, then use it!
-      if (val == null) {
-        self[name] = option.bool
-          ? defaultValue || true
-          : false;
-      } else {
-        self[name] = val;
-      }
-    } else if (val !== null) {
-      // reassign
-      self[name] = val;
-    }
-  });
-
-  return this;
-};
-
-/**
- * Allow unknown options on the command line.
- *
- * @param {Boolean} arg if `true` or omitted, no error will be thrown
- * for unknown options.
- * @api public
- */
-Command.prototype.allowUnknownOption = function(arg) {
-  this._allowUnknownOption = arguments.length === 0 || arg;
-  return this;
-};
-
-/**
- * Parse `argv`, settings options and invoking commands when defined.
- *
- * @param {Array} argv
- * @return {Command} for chaining
- * @api public
- */
-
-Command.prototype.parse = function(argv) {
-  // implicit help
-  if (this.executables) this.addImplicitHelpCommand();
-
-  // store raw args
-  this.rawArgs = argv;
-
-  // guess name
-  this._name = this._name || basename(argv[1], '.js');
-
-  // github-style sub-commands with no sub-command
-  if (this.executables && argv.length < 3 && !this.defaultExecutable) {
-    // this user needs help
-    argv.push('--help');
-  }
-
-  // process argv
-  var parsed = this.parseOptions(this.normalize(argv.slice(2)));
-  var args = this.args = parsed.args;
-
-  var result = this.parseArgs(this.args, parsed.unknown);
-
-  // executable sub-commands
-  var name = result.args[0];
-
-  var aliasCommand = null;
-  // check alias of sub commands
-  if (name) {
-    aliasCommand = this.commands.filter(function(command) {
-      return command.alias() === name;
-    })[0];
-  }
-
-  if (this._execs[name] && typeof this._execs[name] !== 'function') {
-    return this.executeSubCommand(argv, args, parsed.unknown);
-  } else if (aliasCommand) {
-    // is alias of a subCommand
-    args[0] = aliasCommand._name;
-    return this.executeSubCommand(argv, args, parsed.unknown);
-  } else if (this.defaultExecutable) {
-    // use the default subcommand
-    args.unshift(this.defaultExecutable);
-    return this.executeSubCommand(argv, args, parsed.unknown);
-  }
-
-  return result;
-};
-
-/**
- * Execute a sub-command executable.
- *
- * @param {Array} argv
- * @param {Array} args
- * @param {Array} unknown
- * @api private
- */
-
-Command.prototype.executeSubCommand = function(argv, args, unknown) {
-  args = args.concat(unknown);
-
-  if (!args.length) this.help();
-  if (args[0] === 'help' && args.length === 1) this.help();
-
-  // <cmd> --help
-  if (args[0] === 'help') {
-    args[0] = args[1];
-    args[1] = '--help';
-  }
-
-  // executable
-  var f = argv[1];
-  // name of the subcommand, link `pm-install`
-  var bin = basename(f, '.js') + '-' + args[0];
-
-  // In case of globally installed, get the base dir where executable
-  //  subcommand file should be located at
-  var baseDir,
-    link = fs.lstatSync(f).isSymbolicLink() ? fs.readlinkSync(f) : f;
-
-  // when symbolink is relative path
-  if (link !== f && link.charAt(0) !== '/') {
-    link = path.join(dirname(f), link);
-  }
-  baseDir = dirname(link);
-
-  // prefer local `./<bin>` to bin in the $PATH
-  var localBin = path.join(baseDir, bin);
-
-  // whether bin file is a js script with explicit `.js` extension
-  var isExplicitJS = false;
-  if (exists(localBin + '.js')) {
-    bin = localBin + '.js';
-    isExplicitJS = true;
-  } else if (exists(localBin)) {
-    bin = localBin;
-  }
-
-  args = args.slice(1);
-
-  var proc;
-  if (process.platform !== 'win32') {
-    if (isExplicitJS) {
-      args.unshift(bin);
-      // add executable arguments to spawn
-      args = (process.execArgv || []).concat(args);
-
-      proc = spawn(process.argv[0], args, { stdio: 'inherit', customFds: [0, 1, 2] });
-    } else {
-      proc = spawn(bin, args, { stdio: 'inherit', customFds: [0, 1, 2] });
-    }
-  } else {
-    args.unshift(bin);
-    proc = spawn(process.execPath, args, { stdio: 'inherit' });
-  }
-
-  var signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];
-  signals.forEach(function(signal) {
-    process.on(signal, function() {
-      if (proc.killed === false && proc.exitCode === null) {
-        proc.kill(signal);
-      }
-    });
-  });
-  proc.on('close', process.exit.bind(process));
-  proc.on('error', function(err) {
-    if (err.code === 'ENOENT') {
-      console.error('\n  %s(1) does not exist, try --help\n', bin);
-    } else if (err.code === 'EACCES') {
-      console.error('\n  %s(1) not executable. try chmod or run with root\n', bin);
-    }
-    process.exit(1);
-  });
-
-  // Store the reference to the child process
-  this.runningCommand = proc;
-};
-
-/**
- * Normalize `args`, splitting joined short flags. For example
- * the arg "-abc" is equivalent to "-a -b -c".
- * This also normalizes equal sign and splits "--abc=def" into "--abc def".
- *
- * @param {Array} args
- * @return {Array}
- * @api private
- */
-
-Command.prototype.normalize = function(args) {
-  var ret = [],
-    arg,
-    lastOpt,
-    index;
-
-  for (var i = 0, len = args.length; i < len; ++i) {
-    arg = args[i];
-    if (i > 0) {
-      lastOpt = this.optionFor(args[i - 1]);
-    }
-
-    if (arg === '--') {
-      // Honor option terminator
-      ret = ret.concat(args.slice(i));
-      break;
-    } else if (lastOpt && lastOpt.required) {
-      ret.push(arg);
-    } else if (arg.length > 1 && arg[0] === '-' && arg[1] !== '-') {
-      arg.slice(1).split('').forEach(function(c) {
-        ret.push('-' + c);
-      });
-    } else if (/^--/.test(arg) && ~(index = arg.indexOf('='))) {
-      ret.push(arg.slice(0, index), arg.slice(index + 1));
-    } else {
-      ret.push(arg);
-    }
-  }
-
-  return ret;
-};
-
-/**
- * Parse command `args`.
- *
- * When listener(s) are available those
- * callbacks are invoked, otherwise the "*"
- * event is emitted and those actions are invoked.
- *
- * @param {Array} args
- * @return {Command} for chaining
- * @api private
- */
-
-Command.prototype.parseArgs = function(args, unknown) {
-  var name;
-
-  if (args.length) {
-    name = args[0];
-    if (this.listeners('command:' + name).length) {
-      this.emit('command:' + args.shift(), args, unknown);
-    } else {
-      this.emit('command:*', args);
-    }
-  } else {
-    outputHelpIfNecessary(this, unknown);
-
-    // If there were no args and we have unknown options,
-    // then they are extraneous and we need to error.
-    if (unknown.length > 0) {
-      this.unknownOption(unknown[0]);
-    }
-  }
-
-  return this;
-};
-
-/**
- * Return an option matching `arg` if any.
- *
- * @param {String} arg
- * @return {Option}
- * @api private
- */
-
-Command.prototype.optionFor = function(arg) {
-  for (var i = 0, len = this.options.length; i < len; ++i) {
-    if (this.options[i].is(arg)) {
-      return this.options[i];
-    }
-  }
-};
-
-/**
- * Parse options from `argv` returning `argv`
- * void of these options.
- *
- * @param {Array} argv
- * @return {Array}
- * @api public
- */
-
-Command.prototype.parseOptions = function(argv) {
-  var args = [],
-    len = argv.length,
-    literal,
-    option,
-    arg;
-
-  var unknownOptions = [];
-
-  // parse options
-  for (var i = 0; i < len; ++i) {
-    arg = argv[i];
-
-    // literal args after --
-    if (literal) {
-      args.push(arg);
-      continue;
-    }
-
-    if (arg === '--') {
-      literal = true;
-      continue;
-    }
-
-    // find matching Option
-    option = this.optionFor(arg);
-
-    // option is defined
-    if (option) {
-      // requires arg
-      if (option.required) {
-        arg = argv[++i];
-        if (arg == null) return this.optionMissingArgument(option);
-        this.emit('option:' + option.name(), arg);
-      // optional arg
-      } else if (option.optional) {
-        arg = argv[i + 1];
-        if (arg == null || (arg[0] === '-' && arg !== '-')) {
-          arg = null;
-        } else {
-          ++i;
-        }
-        this.emit('option:' + option.name(), arg);
-      // bool
-      } else {
-        this.emit('option:' + option.name());
-      }
-      continue;
-    }
-
-    // looks like an option
-    if (arg.length > 1 && arg[0] === '-') {
-      unknownOptions.push(arg);
-
-      // If the next argument looks like it might be
-      // an argument for this option, we pass it on.
-      // If it isn't, then it'll simply be ignored
-      if ((i + 1) < argv.length && argv[i + 1][0] !== '-') {
-        unknownOptions.push(argv[++i]);
-      }
-      continue;
-    }
-
-    // arg
-    args.push(arg);
-  }
-
-  return { args: args, unknown: unknownOptions };
-};
-
-/**
- * Return an object containing options as key-value pairs
- *
- * @return {Object}
- * @api public
- */
-Command.prototype.opts = function() {
-  var result = {},
-    len = this.options.length;
-
-  for (var i = 0; i < len; i++) {
-    var key = this.options[i].attributeName();
-    result[key] = key === this._versionOptionName ? this._version : this[key];
-  }
-  return result;
-};
-
-/**
- * Argument `name` is missing.
- *
- * @param {String} name
- * @api private
- */
-
-Command.prototype.missingArgument = function(name) {
-  console.error();
-  console.error("  error: missing required argument `%s'", name);
-  console.error();
-  process.exit(1);
-};
-
-/**
- * `Option` is missing an argument, but received `flag` or nothing.
- *
- * @param {String} option
- * @param {String} flag
- * @api private
- */
-
-Command.prototype.optionMissingArgument = function(option, flag) {
-  console.error();
-  if (flag) {
-    console.error("  error: option `%s' argument missing, got `%s'", option.flags, flag);
-  } else {
-    console.error("  error: option `%s' argument missing", option.flags);
-  }
-  console.error();
-  process.exit(1);
-};
-
-/**
- * Unknown option `flag`.
- *
- * @param {String} flag
- * @api private
- */
-
-Command.prototype.unknownOption = function(flag) {
-  if (this._allowUnknownOption) return;
-  console.error();
-  console.error("  error: unknown option `%s'", flag);
-  console.error();
-  process.exit(1);
-};
-
-/**
- * Variadic argument with `name` is not the last argument as required.
- *
- * @param {String} name
- * @api private
- */
-
-Command.prototype.variadicArgNotLast = function(name) {
-  console.error();
-  console.error("  error: variadic arguments must be last `%s'", name);
-  console.error();
-  process.exit(1);
-};
-
-/**
- * Set the program version to `str`.
- *
- * This method auto-registers the "-V, --version" flag
- * which will print the version number when passed.
- *
- * @param {String} str
- * @param {String} [flags]
- * @return {Command} for chaining
- * @api public
- */
-
-Command.prototype.version = function(str, flags) {
-  if (arguments.length === 0) return this._version;
-  this._version = str;
-  flags = flags || '-V, --version';
-  var versionOption = new Option(flags, 'output the version number');
-  this._versionOptionName = versionOption.long.substr(2) || 'version';
-  this.options.push(versionOption);
-  this.on('option:' + this._versionOptionName, function() {
-    process.stdout.write(str + '\n');
-    process.exit(0);
-  });
-  return this;
-};
-
-/**
- * Set the description to `str`.
- *
- * @param {String} str
- * @param {Object} argsDescription
- * @return {String|Command}
- * @api public
- */
-
-Command.prototype.description = function(str, argsDescription) {
-  if (arguments.length === 0) return this._description;
-  this._description = str;
-  this._argsDescription = argsDescription;
-  return this;
-};
-
-/**
- * Set an alias for the command
- *
- * @param {String} alias
- * @return {String|Command}
- * @api public
- */
-
-Command.prototype.alias = function(alias) {
-  var command = this;
-  if (this.commands.length !== 0) {
-    command = this.commands[this.commands.length - 1];
-  }
-
-  if (arguments.length === 0) return command._alias;
-
-  if (alias === command._name) throw new Error('Command alias can\'t be the same as its name');
-
-  command._alias = alias;
-  return this;
-};
-
-/**
- * Set / get the command usage `str`.
- *
- * @param {String} str
- * @return {String|Command}
- * @api public
- */
-
-Command.prototype.usage = function(str) {
-  var args = this._args.map(function(arg) {
-    return humanReadableArgName(arg);
-  });
-
-  var usage = '[options]' +
-    (this.commands.length ? ' [command]' : '') +
-    (this._args.length ? ' ' + args.join(' ') : '');
-
-  if (arguments.length === 0) return this._usage || usage;
-  this._usage = str;
-
-  return this;
-};
-
-/**
- * Get or set the name of the command
- *
- * @param {String} str
- * @return {String|Command}
- * @api public
- */
-
-Command.prototype.name = function(str) {
-  if (arguments.length === 0) return this._name;
-  this._name = str;
-  return this;
-};
-
-/**
- * Return prepared commands.
- *
- * @return {Array}
- * @api private
- */
-
-Command.prototype.prepareCommands = function() {
-  return this.commands.filter(function(cmd) {
-    return !cmd._noHelp;
-  }).map(function(cmd) {
-    var args = cmd._args.map(function(arg) {
-      return humanReadableArgName(arg);
-    }).join(' ');
-
-    return [
-      cmd._name +
-        (cmd._alias ? '|' + cmd._alias : '') +
-        (cmd.options.length ? ' [options]' : '') +
-        (args ? ' ' + args : ''),
-      cmd._description
-    ];
-  });
-};
-
-/**
- * Return the largest command length.
- *
- * @return {Number}
- * @api private
- */
-
-Command.prototype.largestCommandLength = function() {
-  var commands = this.prepareCommands();
-  return commands.reduce(function(max, command) {
-    return Math.max(max, command[0].length);
-  }, 0);
-};
-
-/**
- * Return the largest option length.
- *
- * @return {Number}
- * @api private
- */
-
-Command.prototype.largestOptionLength = function() {
-  var options = [].slice.call(this.options);
-  options.push({
-    flags: '-h, --help'
-  });
-  return options.reduce(function(max, option) {
-    return Math.max(max, option.flags.length);
-  }, 0);
-};
-
-/**
- * Return the largest arg length.
- *
- * @return {Number}
- * @api private
- */
-
-Command.prototype.largestArgLength = function() {
-  return this._args.reduce(function(max, arg) {
-    return Math.max(max, arg.name.length);
-  }, 0);
-};
-
-/**
- * Return the pad width.
- *
- * @return {Number}
- * @api private
- */
-
-Command.prototype.padWidth = function() {
-  var width = this.largestOptionLength();
-  if (this._argsDescription && this._args.length) {
-    if (this.largestArgLength() > width) {
-      width = this.largestArgLength();
-    }
-  }
-
-  if (this.commands && this.commands.length) {
-    if (this.largestCommandLength() > width) {
-      width = this.largestCommandLength();
-    }
-  }
-
-  return width;
-};
-
-/**
- * Return help for options.
- *
- * @return {String}
- * @api private
- */
-
-Command.prototype.optionHelp = function() {
-  var width = this.padWidth();
-
-  // Append the help information
-  return this.options.map(function(option) {
-    return pad(option.flags, width) + '  ' + option.description +
-      ((option.bool && option.defaultValue !== undefined) ? ' (default: ' + option.defaultValue + ')' : '');
-  }).concat([pad('-h, --help', width) + '  ' + 'output usage information'])
-    .join('\n');
-};
-
-/**
- * Return command help documentation.
- *
- * @return {String}
- * @api private
- */
-
-Command.prototype.commandHelp = function() {
-  if (!this.commands.length) return '';
-
-  var commands = this.prepareCommands();
-  var width = this.padWidth();
-
-  return [
-    '  Commands:',
-    '',
-    commands.map(function(cmd) {
-      var desc = cmd[1] ? '  ' + cmd[1] : '';
-      return (desc ? pad(cmd[0], width) : cmd[0]) + desc;
-    }).join('\n').replace(/^/gm, '    '),
-    ''
-  ].join('\n');
-};
-
-/**
- * Return program help documentation.
- *
- * @return {String}
- * @api private
+ * @param {string | null} fallback
+ * @param {boolean} allow_empty
+ * @returns {Validator}
  */
+function string(fallback, allow_empty = true) {
+	return validate(fallback, (input, keypath) => {
+		assert_string(input, keypath);
 
-Command.prototype.helpInformation = function() {
-  var desc = [];
-  if (this._description) {
-    desc = [
-      '  ' + this._description,
-      ''
-    ];
-
-    var argsDescription = this._argsDescription;
-    if (argsDescription && this._args.length) {
-      var width = this.padWidth();
-      desc.push('  Arguments:');
-      desc.push('');
-      this._args.forEach(function(arg) {
-        desc.push('    ' + pad(arg.name, width) + '  ' + argsDescription[arg.name]);
-      });
-      desc.push('');
-    }
-  }
-
-  var cmdName = this._name;
-  if (this._alias) {
-    cmdName = cmdName + '|' + this._alias;
-  }
-  var usage = [
-    '',
-    '  Usage: ' + cmdName + ' ' + this.usage(),
-    ''
-  ];
-
-  var cmds = [];
-  var commandHelp = this.commandHelp();
-  if (commandHelp) cmds = [commandHelp];
-
-  var options = [
-    '  Options:',
-    '',
-    '' + this.optionHelp().replace(/^/gm, '    '),
-    ''
-  ];
-
-  return usage
-    .concat(desc)
-    .concat(options)
-    .concat(cmds)
-    .join('\n');
-};
-
-/**
- * Output help information for this command
- *
- * @api public
- */
+		if (!allow_empty && input === '') {
+			throw new Error(`${keypath} cannot be empty`);
+		}
 
-Command.prototype.outputHelp = function(cb) {
-  if (!cb) {
-    cb = function(passthru) {
-      return passthru;
-    };
-  }
-  process.stdout.write(cb(this.helpInformation()));
-  this.emit('--help');
-};
+		return input;
+	});
+}
 
 /**
- * Output help information and exit.
- *
- * @api public
+ * @param {string[] | undefined} [fallback]
+ * @returns {Validator}
  */
+function string_array(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (input === undefined) return input;
 
-Command.prototype.help = function(cb) {
-  this.outputHelp(cb);
-  process.exit();
-};
-
-/**
- * Camel-case the given `flag`
- *
- * @param {String} flag
- * @return {String}
- * @api private
- */
+		if (!Array.isArray(input) || input.some((value) => typeof value !== 'string')) {
+			throw new Error(`${keypath} must be an array of strings, if specified`);
+		}
 
-function camelcase(flag) {
-  return flag.split('-').reduce(function(str, word) {
-    return str + word[0].toUpperCase() + word.slice(1);
-  });
+		return input;
+	});
 }
 
 /**
- * Pad `str` to `width`.
- *
- * @param {String} str
- * @param {Number} width
- * @return {String}
- * @api private
+ * @param {number} fallback
+ * @returns {Validator}
  */
-
-function pad(str, width) {
-  var len = Math.max(0, width - str.length);
-  return str + Array(len + 1).join(' ');
+function number(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (typeof input !== 'number') {
+			throw new Error(`${keypath} should be a number, if specified`);
+		}
+		return input;
+	});
 }
 
 /**
- * Output help information if necessary
- *
- * @param {Command} command to output help for
- * @param {Array} array of options to search for -h or --help
- * @api private
+ * @param {boolean} fallback
+ * @returns {Validator}
  */
-
-function outputHelpIfNecessary(cmd, options) {
-  options = options || [];
-  for (var i = 0; i < options.length; i++) {
-    if (options[i] === '--help' || options[i] === '-h') {
-      cmd.outputHelp();
-      process.exit(0);
-    }
-  }
+function boolean(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (typeof input !== 'boolean') {
+			throw new Error(`${keypath} should be true or false, if specified`);
+		}
+		return input;
+	});
 }
 
 /**
- * Takes an argument an returns its human readable equivalent for help usage.
- *
- * @param {Object} arg
- * @return {String}
- * @api private
+ * @param {string[]} options
+ * @returns {Validator}
  */
+function list(options, fallback = options[0]) {
+	return validate(fallback, (input, keypath) => {
+		if (!options.includes(input)) {
+			// prettier-ignore
+			const msg = options.length > 2
+				? `${keypath} should be one of ${options.slice(0, -1).map(input => `"${input}"`).join(', ')} or "${options[options.length - 1]}"`
+				: `${keypath} should be either "${options[0]}" or "${options[1]}"`;
 
-function humanReadableArgName(arg) {
-  var nameOutput = arg.name + (arg.variadic === true ? '...' : '');
-
-  return arg.required
-    ? '<' + nameOutput + '>'
-    : '[' + nameOutput + ']';
-}
-
-// for versions before node v0.8 when there weren't `fs.existsSync`
-function exists(file) {
-  try {
-    if (fs.statSync(file).isFile()) {
-      return true;
-    }
-  } catch (e) {
-    return false;
-  }
-}
-});
-
-var domain; // The domain module is executed on demand
-var hasSetImmediate = typeof setImmediate === "function";
-
-// Use the fastest means possible to execute a task in its own turn, with
-// priority over other events including network IO events in Node.js.
-//
-// An exception thrown by a task will permanently interrupt the processing of
-// subsequent tasks. The higher level `asap` function ensures that if an
-// exception is thrown by a task, that the task queue will continue flushing as
-// soon as possible, but if you use `rawAsap` directly, you are responsible to
-// either ensure that no exceptions are thrown from your task, or to manually
-// call `rawAsap.requestFlush` if an exception is thrown.
-var raw = rawAsap;
-function rawAsap(task) {
-    if (!queue.length) {
-        requestFlush();
-        flushing = true;
-    }
-    // Avoids a function call
-    queue[queue.length] = task;
-}
-
-var queue = [];
-// Once a flush has been requested, no further calls to `requestFlush` are
-// necessary until the next `flush` completes.
-var flushing = false;
-// The position of the next task to execute in the task queue. This is
-// preserved between calls to `flush` so that it can be resumed if
-// a task throws an exception.
-var index = 0;
-// If a task schedules additional tasks recursively, the task queue can grow
-// unbounded. To prevent memory excaustion, the task queue will periodically
-// truncate already-completed tasks.
-var capacity = 1024;
-
-// The flush function processes all tasks that have been scheduled with
-// `rawAsap` unless and until one of those tasks throws an exception.
-// If a task throws an exception, `flush` ensures that its state will remain
-// consistent and will resume where it left off when called again.
-// However, `flush` does not make any arrangements to be called again if an
-// exception is thrown.
-function flush() {
-    while (index < queue.length) {
-        var currentIndex = index;
-        // Advance the index before calling the task. This ensures that we will
-        // begin flushing on the next task the task throws an error.
-        index = index + 1;
-        queue[currentIndex].call();
-        // Prevent leaking memory for long chains of recursive calls to `asap`.
-        // If we call `asap` within tasks scheduled by `asap`, the queue will
-        // grow, but to avoid an O(n) walk for every task we execute, we don't
-        // shift tasks off the queue after they have been executed.
-        // Instead, we periodically shift 1024 tasks off the queue.
-        if (index > capacity) {
-            // Manually shift all values starting at the index back to the
-            // beginning of the queue.
-            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
-                queue[scan] = queue[scan + index];
-            }
-            queue.length -= index;
-            index = 0;
-        }
-    }
-    queue.length = 0;
-    index = 0;
-    flushing = false;
-}
-
-rawAsap.requestFlush = requestFlush;
-function requestFlush() {
-    // Ensure flushing is not bound to any domain.
-    // It is not sufficient to exit the domain, because domains exist on a stack.
-    // To execute code outside of any domain, the following dance is necessary.
-    var parentDomain = process.domain;
-    if (parentDomain) {
-        if (!domain) {
-            // Lazy execute the domain module.
-            // Only employed if the user elects to use domains.
-            domain = require$$0$1;
-        }
-        domain.active = process.domain = null;
-    }
-
-    // `setImmediate` is slower that `process.nextTick`, but `process.nextTick`
-    // cannot handle recursion.
-    // `requestFlush` will only be called recursively from `asap.js`, to resume
-    // flushing after an error is thrown into a domain.
-    // Conveniently, `setImmediate` was introduced in the same version
-    // `process.nextTick` started throwing recursion errors.
-    if (flushing && hasSetImmediate) {
-        setImmediate(flush);
-    } else {
-        process.nextTick(flush);
-    }
-
-    if (parentDomain) {
-        domain.active = process.domain = parentDomain;
-    }
-}
-
-function noop() {}
-
-// States:
-//
-// 0 - pending
-// 1 - fulfilled with _value
-// 2 - rejected with _value
-// 3 - adopted the state of another promise, _value
-//
-// once the state is no longer pending (0) it is immutable
-
-// All `_` prefixed properties will be reduced to `_{random number}`
-// at build time to obfuscate them and discourage their use.
-// We don't use symbols or Object.defineProperty to fully hide them
-// because the performance isn't good enough.
-
-
-// to avoid using try/catch inside critical functions, we
-// extract them to here.
-var LAST_ERROR = null;
-var IS_ERROR = {};
-function getThen(obj) {
-  try {
-    return obj.then;
-  } catch (ex) {
-    LAST_ERROR = ex;
-    return IS_ERROR;
-  }
-}
-
-function tryCallOne(fn, a) {
-  try {
-    return fn(a);
-  } catch (ex) {
-    LAST_ERROR = ex;
-    return IS_ERROR;
-  }
-}
-function tryCallTwo(fn, a, b) {
-  try {
-    fn(a, b);
-  } catch (ex) {
-    LAST_ERROR = ex;
-    return IS_ERROR;
-  }
-}
-
-var core = Promise$1;
-
-function Promise$1(fn) {
-  if (typeof this !== 'object') {
-    throw new TypeError('Promises must be constructed via new');
-  }
-  if (typeof fn !== 'function') {
-    throw new TypeError('Promise constructor\'s argument is not a function');
-  }
-  this._75 = 0;
-  this._83 = 0;
-  this._18 = null;
-  this._38 = null;
-  if (fn === noop) return;
-  doResolve(fn, this);
-}
-Promise$1._47 = null;
-Promise$1._71 = null;
-Promise$1._44 = noop;
-
-Promise$1.prototype.then = function(onFulfilled, onRejected) {
-  if (this.constructor !== Promise$1) {
-    return safeThen(this, onFulfilled, onRejected);
-  }
-  var res = new Promise$1(noop);
-  handle(this, new Handler(onFulfilled, onRejected, res));
-  return res;
-};
-
-function safeThen(self, onFulfilled, onRejected) {
-  return new self.constructor(function (resolve, reject) {
-    var res = new Promise$1(noop);
-    res.then(resolve, reject);
-    handle(self, new Handler(onFulfilled, onRejected, res));
-  });
-}
-function handle(self, deferred) {
-  while (self._83 === 3) {
-    self = self._18;
-  }
-  if (Promise$1._47) {
-    Promise$1._47(self);
-  }
-  if (self._83 === 0) {
-    if (self._75 === 0) {
-      self._75 = 1;
-      self._38 = deferred;
-      return;
-    }
-    if (self._75 === 1) {
-      self._75 = 2;
-      self._38 = [self._38, deferred];
-      return;
-    }
-    self._38.push(deferred);
-    return;
-  }
-  handleResolved(self, deferred);
-}
-
-function handleResolved(self, deferred) {
-  raw(function() {
-    var cb = self._83 === 1 ? deferred.onFulfilled : deferred.onRejected;
-    if (cb === null) {
-      if (self._83 === 1) {
-        resolve(deferred.promise, self._18);
-      } else {
-        reject(deferred.promise, self._18);
-      }
-      return;
-    }
-    var ret = tryCallOne(cb, self._18);
-    if (ret === IS_ERROR) {
-      reject(deferred.promise, LAST_ERROR);
-    } else {
-      resolve(deferred.promise, ret);
-    }
-  });
-}
-function resolve(self, newValue) {
-  // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
-  if (newValue === self) {
-    return reject(
-      self,
-      new TypeError('A promise cannot be resolved with itself.')
-    );
-  }
-  if (
-    newValue &&
-    (typeof newValue === 'object' || typeof newValue === 'function')
-  ) {
-    var then = getThen(newValue);
-    if (then === IS_ERROR) {
-      return reject(self, LAST_ERROR);
-    }
-    if (
-      then === self.then &&
-      newValue instanceof Promise$1
-    ) {
-      self._83 = 3;
-      self._18 = newValue;
-      finale(self);
-      return;
-    } else if (typeof then === 'function') {
-      doResolve(then.bind(newValue), self);
-      return;
-    }
-  }
-  self._83 = 1;
-  self._18 = newValue;
-  finale(self);
-}
-
-function reject(self, newValue) {
-  self._83 = 2;
-  self._18 = newValue;
-  if (Promise$1._71) {
-    Promise$1._71(self, newValue);
-  }
-  finale(self);
-}
-function finale(self) {
-  if (self._75 === 1) {
-    handle(self, self._38);
-    self._38 = null;
-  }
-  if (self._75 === 2) {
-    for (var i = 0; i < self._38.length; i++) {
-      handle(self, self._38[i]);
-    }
-    self._38 = null;
-  }
-}
-
-function Handler(onFulfilled, onRejected, promise){
-  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
-  this.onRejected = typeof onRejected === 'function' ? onRejected : null;
-  this.promise = promise;
+			throw new Error(msg);
+		}
+		return input;
+	});
 }
 
 /**
- * Take a potentially misbehaving resolver function and make sure
- * onFulfilled and onRejected are only called once.
- *
- * Makes no guarantees about asynchrony.
+ * @param {(filename: string) => boolean} fallback
+ * @returns {Validator}
  */
-function doResolve(fn, promise) {
-  var done = false;
-  var res = tryCallTwo(fn, function (value) {
-    if (done) return;
-    done = true;
-    resolve(promise, value);
-  }, function (reason) {
-    if (done) return;
-    done = true;
-    reject(promise, reason);
-  });
-  if (!done && res === IS_ERROR) {
-    done = true;
-    reject(promise, LAST_ERROR);
-  }
+function fun(fallback) {
+	return validate(fallback, (input, keypath) => {
+		if (typeof input !== 'function') {
+			throw new Error(`${keypath} should be a function, if specified`);
+		}
+		return input;
+	});
 }
 
-core.prototype.done = function (onFulfilled, onRejected) {
-  var self = arguments.length ? this.then.apply(this, arguments) : this;
-  self.then(null, function (err) {
-    setTimeout(function () {
-      throw err;
-    }, 0);
-  });
-};
-
-core.prototype['finally'] = function (f) {
-  return this.then(function (value) {
-    return core.resolve(f()).then(function () {
-      return value;
-    });
-  }, function (err) {
-    return core.resolve(f()).then(function () {
-      throw err;
-    });
-  });
-};
-
-/* Static Functions */
-
-var TRUE = valuePromise(true);
-var FALSE = valuePromise(false);
-var NULL = valuePromise(null);
-var UNDEFINED = valuePromise(undefined);
-var ZERO = valuePromise(0);
-var EMPTYSTRING = valuePromise('');
-
-function valuePromise(value) {
-  var p = new core(core._44);
-  p._83 = 1;
-  p._18 = value;
-  return p;
-}
-core.resolve = function (value) {
-  if (value instanceof core) return value;
-
-  if (value === null) return NULL;
-  if (value === undefined) return UNDEFINED;
-  if (value === true) return TRUE;
-  if (value === false) return FALSE;
-  if (value === 0) return ZERO;
-  if (value === '') return EMPTYSTRING;
-
-  if (typeof value === 'object' || typeof value === 'function') {
-    try {
-      var then = value.then;
-      if (typeof then === 'function') {
-        return new core(then.bind(value));
-      }
-    } catch (ex) {
-      return new core(function (resolve, reject) {
-        reject(ex);
-      });
-    }
-  }
-  return valuePromise(value);
-};
-
-core.all = function (arr) {
-  var args = Array.prototype.slice.call(arr);
-
-  return new core(function (resolve, reject) {
-    if (args.length === 0) return resolve([]);
-    var remaining = args.length;
-    function res(i, val) {
-      if (val && (typeof val === 'object' || typeof val === 'function')) {
-        if (val instanceof core && val.then === core.prototype.then) {
-          while (val._83 === 3) {
-            val = val._18;
-          }
-          if (val._83 === 1) return res(i, val._18);
-          if (val._83 === 2) reject(val._18);
-          val.then(function (val) {
-            res(i, val);
-          }, reject);
-          return;
-        } else {
-          var then = val.then;
-          if (typeof then === 'function') {
-            var p = new core(then.bind(val));
-            p.then(function (val) {
-              res(i, val);
-            }, reject);
-            return;
-          }
-        }
-      }
-      args[i] = val;
-      if (--remaining === 0) {
-        resolve(args);
-      }
-    }
-    for (var i = 0; i < args.length; i++) {
-      res(i, args[i]);
-    }
-  });
-};
-
-core.reject = function (value) {
-  return new core(function (resolve, reject) {
-    reject(value);
-  });
-};
-
-core.race = function (values) {
-  return new core(function (resolve, reject) {
-    values.forEach(function(value){
-      core.resolve(value).then(resolve, reject);
-    });
-  });
-};
-
-/* Prototype Methods */
-
-core.prototype['catch'] = function (onRejected) {
-  return this.then(null, onRejected);
-};
-
-var freeTasks = [];
-
 /**
- * Calls a task as soon as possible after returning, in its own event, with
- * priority over IO events. An exception thrown in a task can be handled by
- * `process.on("uncaughtException") or `domain.on("error")`, but will otherwise
- * crash the process. If the error is handled, all subsequent tasks will
- * resume.
- *
- * @param {{call}} task A callable object, typically a function that takes no
- * arguments.
+ * @param {string} input
+ * @param {string} keypath
  */
-var asap_1 = asap;
-function asap(task) {
-    var rawTask;
-    if (freeTasks.length) {
-        rawTask = freeTasks.pop();
-    } else {
-        rawTask = new RawTask();
-    }
-    rawTask.task = task;
-    rawTask.domain = process.domain;
-    raw(rawTask);
+function assert_string(input, keypath) {
+	if (typeof input !== 'string') {
+		throw new Error(`${keypath} should be a string, if specified`);
+	}
 }
 
-function RawTask() {
-    this.task = null;
-    this.domain = null;
+/** @param {(keypath?: string) => string} fn */
+function error(fn) {
+	return validate(undefined, (input, keypath) => {
+		if (input !== undefined) {
+			throw new Error(fn(keypath));
+		}
+	});
 }
 
-RawTask.prototype.call = function () {
-    if (this.domain) {
-        this.domain.enter();
-    }
-    var threw = true;
-    try {
-        this.task.call();
-        threw = false;
-        // If the task throws an exception (presumably) Node.js restores the
-        // domain stack for the next event.
-        if (this.domain) {
-            this.domain.exit();
-        }
-    } finally {
-        // We use try/finally and a threw flag to avoid messing up stack traces
-        // when we catch and release errors.
-        if (threw) {
-            // In Node.js, uncaught exceptions are considered fatal errors.
-            // Re-throw them to interrupt flushing!
-            // Ensure that flushing continues if an uncaught exception is
-            // suppressed listening process.on("uncaughtException") or
-            // domain.on("error").
-            raw.requestFlush();
-        }
-        // If the task threw an error, we do not want to exit the domain here.
-        // Exiting the domain would prevent the domain from catching the error.
-        this.task = null;
-        this.domain = null;
-        freeTasks.push(this);
-    }
-};
-
-/* Static Functions */
-
-core.denodeify = function (fn, argumentCount) {
-  if (
-    typeof argumentCount === 'number' && argumentCount !== Infinity
-  ) {
-    return denodeifyWithCount(fn, argumentCount);
-  } else {
-    return denodeifyWithoutCount(fn);
-  }
-};
-
-var callbackFn = (
-  'function (err, res) {' +
-  'if (err) { rj(err); } else { rs(res); }' +
-  '}'
-);
-function denodeifyWithCount(fn, argumentCount) {
-  var args = [];
-  for (var i = 0; i < argumentCount; i++) {
-    args.push('a' + i);
-  }
-  var body = [
-    'return function (' + args.join(',') + ') {',
-    'var self = this;',
-    'return new Promise(function (rs, rj) {',
-    'var res = fn.call(',
-    ['self'].concat(args).concat([callbackFn]).join(','),
-    ');',
-    'if (res &&',
-    '(typeof res === "object" || typeof res === "function") &&',
-    'typeof res.then === "function"',
-    ') {rs(res);}',
-    '});',
-    '};'
-  ].join('');
-  return Function(['Promise', 'fn'], body)(core, fn);
-}
-function denodeifyWithoutCount(fn) {
-  var fnLength = Math.max(fn.length - 1, 3);
-  var args = [];
-  for (var i = 0; i < fnLength; i++) {
-    args.push('a' + i);
-  }
-  var body = [
-    'return function (' + args.join(',') + ') {',
-    'var self = this;',
-    'var args;',
-    'var argLength = arguments.length;',
-    'if (arguments.length > ' + fnLength + ') {',
-    'args = new Array(arguments.length + 1);',
-    'for (var i = 0; i < arguments.length; i++) {',
-    'args[i] = arguments[i];',
-    '}',
-    '}',
-    'return new Promise(function (rs, rj) {',
-    'var cb = ' + callbackFn + ';',
-    'var res;',
-    'switch (argLength) {',
-    args.concat(['extra']).map(function (_, index) {
-      return (
-        'case ' + (index) + ':' +
-        'res = fn.call(' + ['self'].concat(args.slice(0, index)).concat('cb').join(',') + ');' +
-        'break;'
-      );
-    }).join(''),
-    'default:',
-    'args[argLength] = cb;',
-    'res = fn.apply(self, args);',
-    '}',
-    
-    'if (res &&',
-    '(typeof res === "object" || typeof res === "function") &&',
-    'typeof res.then === "function"',
-    ') {rs(res);}',
-    '});',
-    '};'
-  ].join('');
-
-  return Function(
-    ['Promise', 'fn'],
-    body
-  )(core, fn);
-}
-
-core.nodeify = function (fn) {
-  return function () {
-    var args = Array.prototype.slice.call(arguments);
-    var callback =
-      typeof args[args.length - 1] === 'function' ? args.pop() : null;
-    var ctx = this;
-    try {
-      return fn.apply(this, arguments).nodeify(callback, ctx);
-    } catch (ex) {
-      if (callback === null || typeof callback == 'undefined') {
-        return new core(function (resolve, reject) {
-          reject(ex);
-        });
-      } else {
-        asap_1(function () {
-          callback.call(ctx, ex);
-        });
-      }
-    }
-  }
-};
-
-core.prototype.nodeify = function (callback, ctx) {
-  if (typeof callback != 'function') return this;
-
-  this.then(function (value) {
-    asap_1(function () {
-      callback.call(ctx, null, value);
-    });
-  }, function (err) {
-    asap_1(function () {
-      callback.call(ctx, err);
-    });
-  });
-};
-
-core.enableSynchronous = function () {
-  core.prototype.isPending = function() {
-    return this.getState() == 0;
-  };
-
-  core.prototype.isFulfilled = function() {
-    return this.getState() == 1;
-  };
-
-  core.prototype.isRejected = function() {
-    return this.getState() == 2;
-  };
-
-  core.prototype.getValue = function () {
-    if (this._83 === 3) {
-      return this._18.getValue();
-    }
-
-    if (!this.isFulfilled()) {
-      throw new Error('Cannot get a value of an unfulfilled promise.');
-    }
-
-    return this._18;
-  };
-
-  core.prototype.getReason = function () {
-    if (this._83 === 3) {
-      return this._18.getReason();
-    }
-
-    if (!this.isRejected()) {
-      throw new Error('Cannot get a rejection reason of a non-rejected promise.');
-    }
-
-    return this._18;
-  };
-
-  core.prototype.getState = function () {
-    if (this._83 === 3) {
-      return this._18.getState();
-    }
-    if (this._83 === -1 || this._83 === -2) {
-      return 0;
-    }
-
-    return this._83;
-  };
-};
-
-core.disableSynchronous = function() {
-  core.prototype.isPending = undefined;
-  core.prototype.isFulfilled = undefined;
-  core.prototype.isRejected = undefined;
-  core.prototype.getValue = undefined;
-  core.prototype.getReason = undefined;
-  core.prototype.getState = undefined;
-};
-
-var lib = core;
-
-var promise = lib;
-
 /**
- * @license
- * Copyright 2016 The AMP HTML Authors. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS-IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the license.
+ * Loads the template (src/app.html by default) and validates that it has the
+ * required content.
+ * @param {string} cwd
+ * @param {import('types').ValidatedConfig} config
  */
+function load_template(cwd, config) {
+	const { template } = config.kit.files;
+	const relative = path__default.relative(cwd, template);
 
+	if (fs__default.existsSync(template)) {
+		const contents = fs__default.readFileSync(template, 'utf8');
 
+		// TODO remove this for 1.0
+		const match = /%svelte\.([a-z]+)%/.exec(contents);
+		if (match) {
+			throw new Error(
+				`%svelte.${match[1]}% in ${relative} should be replaced with %sveltekit.${match[1]}%`
+			);
+		}
 
+		const expected_tags = ['%sveltekit.head%', '%sveltekit.body%'];
+		expected_tags.forEach((tag) => {
+			if (contents.indexOf(tag) === -1) {
+				throw new Error(`${relative} is missing ${tag}`);
+			}
+		});
+	} else {
+		throw new Error(`${relative} does not exist`);
+	}
 
-
-
-
-
-
-
-
-
-
-const DEFAULT_USER_AGENT = 'amphtml-validator';
-
-/**
- * Determines if str begins with prefix.
- * @param {string} str
- * @param {string} prefix
- * @return {boolean}
- */
-function hasPrefix(str, prefix) {
-  return str.indexOf(prefix) == 0;
-}
-
-/**
- * Convenience function to detect whether an argument is a URL. If not,
- * it may be a local file.
- * @param {string} url
- * @return {boolean}
- */
-function isHttpOrHttpsUrl(url) {
-  return hasPrefix(url, 'http://') || hasPrefix(url, 'https://');
-}
-
-/**
- * Creates a promise which reads from a file.
- * @param {string} name
- * @return {Promise<string>}
- */
-function readFromFile(name) {
-  return new promise(function(resolve, reject) {
-    fs.readFile(name, 'utf8', function(err, data) {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(data.trim());
-      }
-    });
-  });
+	return fs__default.readFileSync(template, 'utf-8');
 }
 
 /**
- * Creates a promise which reads from a stream.
- * @param {string} name
- * @param {!stream.Readable} readable
- * @return {Promise<string>}
+ * Loads and validates svelte.config.js
+ * @param {{ cwd?: string }} options
+ * @returns {Promise<import('types').ValidatedConfig>}
  */
-function readFromReadable(name, readable) {
-  return new promise(function(resolve, reject) {
-    const chunks = [];
-    readable.setEncoding('utf8');
-    readable.on('data', function(chunk) {
-      chunks.push(chunk);
-    });
-    readable.on('end', function() {
-      resolve(chunks.join(''));
-    });
-    readable.on('error', function(error) {
-      reject(new Error('Could not read from ' + name + ' - ' + error.message));
-    });
-  });
-}
+async function load_config({ cwd = process.cwd() } = {}) {
+	const config_file = path__default.join(cwd, 'svelte.config.js');
 
-/**
- * Creates a promise which reads from standard input. Even though it would
- * be easy to make a function that just returns the data, we return a promise
- * for consistency with readFromUrl and readFromFile.
- * @return {Promise<string>}
- */
-function readFromStdin() {
-  return readFromReadable('stdin', process.stdin).then(function(data) {
-    process.stdin.resume();
-    return data;
-  });
-}
+	if (!fs__default.existsSync(config_file)) {
+		return process_config({}, { cwd });
+	}
 
-/**
- * Creates a promise which reads from a URL or more precisely, fetches
- * the contents located at the URL by using the 'http' or 'https' module.
- * Any HTTP status other than 200 is interpreted as an error.
- * @param {string} url
- * @param {string} userAgent
- * @return {Promise<string>}
- */
-function readFromUrl(url, userAgent) {
-  return new promise(function(resolve, reject) {
-    const clientModule = hasPrefix(url, 'http://') ? http : https;
-    const req = clientModule.request(url, function(response) {
-      if (response.statusCode !== 200) {
-        // https://nodejs.org/api/http.html says: "[...] However, if
-        // you add a 'response' event handler, then you must consume
-        // the data from the response object, either by calling
-        // response.read() whenever there is a 'readable' event, or by
-        // adding a 'data' handler, or by calling the .resume()
-        // method."
-        response.resume();
-        reject(new Error(
-            'Unable to fetch ' + url + ' - HTTP Status ' +
-                   response.statusCode));
-      } else {
-        resolve(response);
-      }
-    });
-    req.setHeader('User-Agent', userAgent);
-    req.on('error', function(error) { // E.g., DNS resolution errors.
-      reject(
-          new Error('Unable to fetch ' + url + ' - ' + error.message));
-    });
-    req.end();
-  })
-      .then(readFromReadable.bind(null, url));
-}
+	const config = await import(`${url.pathToFileURL(config_file).href}?ts=${Date.now()}`);
 
-/**
- * ValidationResult is the record computed by the validator for each
- * document. It contains an overall status (PASS/FAIL) and the list of
- * errors, if any. This class corresponds to the ValidationResult
- * message in validator.proto in this directory.
- * @export
- * @constructor
- */
-function ValidationResult() {
-  /**
-   * Possible values are 'UNKNOWN', 'PASS', and 'FAIL'.
-   * @type {string}
-   */
-  this.status = 'UNKNOWN';
-  /** @type {!Array<!ValidationError>} */
-  this.errors = [];
+	return process_config(config.default, { cwd });
 }
 
 /**
- * Each validation error describes a specific problem in a validated
- * document. This class corresponds to the ValidationError message in
- * validator.proto in this directory.
- * @export
- * @constructor
+ * @param {import('types').Config} config
+ * @returns {import('types').ValidatedConfig}
  */
-function ValidationError() {
-  /**
-   * The severity of the error - possible values are 'UNKNOWN_SEVERITY',
-   * 'ERROR', and 'WARNING'.
-   */
-  this.severity = 'UNKNOWN_SEVERITY';
-  /**
-   * The line number at which the error was seen (1 is the first line).
-   */
-  this.line = 1;
-  /**
-   * The column number at which the error was seen (0 is the first column).
-   */
-  this.col = 0;
-  /**
-   * A human-readable error message for the validation error.
-   * If you find yourself trying to write a parser against this string
-   * to scrape out some detail, consider looking at the code and params
-   * fields below.
-   * @type {string}
-   */
-  this.message = '';
-  /**
-   * The spec URL is often added by the validator to provide additional
-   * context for the error. In a user interface this would be shown
-   * as a "Learn more" link.
-   * @type {string}
-   */
-  this.specUrl = null;
-  /**
-   * This field is only useful when scripting against the validator,
-   * it should not be displayed in a user interface as it adds nothing
-   * for humans to read over the message field (see above).
-   * Possible values are the codes listed in ValidationError.Code - see
-   * validator.proto. Examples: 'UNKNOWN_CODE', 'MANDATORY_TAG_MISSING',
-   * 'TAG_REQUIRED_BY_MISSING'. For each of these codes there is a
-   * format string in validator-main.protoascii (look for error_formats),
-   * which is used to assemble the message from the strings in params.
-   * @type {string}
-   */
-  this.code = 'UNKNOWN_CODE';
-  /**
-   * This field is only useful when scripting against the validator,
-   * it should not be displayed in a user interface as it adds nothing
-   * for humans to read over the message field (see above).
-   * @type {!Array<string>}
-   */
-  this.params = [];
-}
+function process_config(config, { cwd = process.cwd() } = {}) {
+	const validated = validate_config(config);
 
-/**
- * The validator instance is a proxy object to a precompiled
- * validator.js script - in practice the script was either downloaded
- * from 'https://cdn.ampproject.org/v0/validator.js' or read from a
- * local file.
- * @param {string} scriptContents
- * @throws {!Error}
- * @constructor
- */
-function Validator(scriptContents) {
-  // The 'sandbox' is a Javascript object (dictionary) which holds
-  // the results of evaluating the validatorJs / scriptContents, so
-  // basically, it holds functions, prototypes, etc. As a
-  // side-effect of evaluating, the VM will compile this code and
-  // it's worth holding onto it. Hence, this validate function is
-  // reached via 2 codepaths - either the sandbox came from the
-  // cache, precompiledByValidatorJs - or we just varructed it
-  // after downloading and evaluating the script. The API is fancier
-  // here, vm.Script / vm.createContext / vm.runInContext and all
-  // that, but it's quite similar to a Javascript eval.
-  this.sandbox = vm.createContext();
-  try {
-    new vm.Script(scriptContents).runInContext(this.sandbox);
-  } catch (error) {
-    throw new Error('Could not instantiate validator.js - ' + error.message);
-  }
-}
-
-/**
- * Validates the provided inputString; the htmlFormat can be 'AMP' or
- * 'AMP4ADS'; it defaults to 'AMP' if not specified.
- * @param {string} inputString
- * @param {string=} htmlFormat
- * @return {!ValidationResult}
- * @export
- */
-Validator.prototype.validateString = function(inputString, htmlFormat) {
-  const internalResult =
-      this.sandbox.amp.validator.validateString(inputString, htmlFormat);
-  const result = new ValidationResult();
-  result.status = internalResult.status;
-  for (let ii = 0; ii < internalResult.errors.length; ii++) {
-    const internalError = internalResult.errors[ii];
-    const error = new ValidationError();
-    error.severity = internalError.severity;
-    error.line = internalError.line;
-    error.col = internalError.col;
-    error.message =
-        this.sandbox.amp.validator.renderErrorMessage(internalError);
-    error.specUrl = internalError.specUrl;
-    error.code = internalError.code;
-    error.params = internalError.params;
-    result.errors.push(error);
-  }
-  return result;
-};
+	validated.kit.outDir = path__default.resolve(cwd, validated.kit.outDir);
 
-/**
- * A global static map used by the getInstance function to avoid loading
- * AMP Validators more than once.
- * @type {!Object<string, Validator>}
- */
-const instanceByValidatorJs = {};
-
-/**
- * Provided a URL or a filename from which to fetch the validator.js
- * file, fetches, instantiates, and caches the validator instance
- * asynchronously.  If you prefer to implement your own fetching /
- * caching logic, you may want to consider newInstance() instead,
- * which is synchronous and much simpler.
- *
- * @param {string=} opt_validatorJs
- * @param {string=} opt_userAgent
- * @return {!Promise<Validator>}
- * @export
- */
-function getInstance(opt_validatorJs, opt_userAgent) {
-  const validatorJs =
-      opt_validatorJs || 'https://cdn.ampproject.org/v0/validator.js';
-  const userAgent = opt_userAgent || DEFAULT_USER_AGENT;
-  if (instanceByValidatorJs.hasOwnProperty(validatorJs)) {
-    return promise.resolve(instanceByValidatorJs[validatorJs]);
-  }
-  const validatorJsPromise = isHttpOrHttpsUrl(validatorJs) ?
-    readFromUrl(validatorJs, userAgent) :
-    readFromFile(validatorJs);
-  return validatorJsPromise.then(function(scriptContents) {
-    let instance;
-    try {
-      instance = new Validator(scriptContents);
-    } catch (error) {
-      // It may be useful to cache errors and exceptions encountered
-      // here, but for now we don't do this for e.g. http errors when
-      // fetching the validator, so we shouldn't do it for syntax
-      // errors etc. either (which lead to the varructor throwing an error).
-      throw error;
-    }
-    instanceByValidatorJs[validatorJs] = instance;
-    return instance;
-  });
-}
-var getInstance_1 = getInstance;
-
-/**
- * Provided the contents of the validator.js file, e.g. as downloaded from
- * 'https://cdn.ampproject.org/v0/validator.js', returns a new validator
- * instance. The tradeoff between this function and getInstance() is that this
- * function is synchronous but requires the contents of the validator.js
- * file as a parameter, while getInstance is asynchronous, fetches files
- * from disk or the web, and caches them.
- *
- * @param {string} validatorJsContents
- * @return {!Validator}
- * @export
- */
-function newInstance(validatorJsContents) {
-  return new Validator(validatorJsContents);
-}
-var newInstance_1 = newInstance;
-
-// A note on emitting output to the console and process exit status:
-// Node.js prior to 0.11.8 did not support process.exitCode
-// (https://nodejs.org/api/process.html#process_process_exitcode), which
-// makes it difficult to emit output and errors from multiple callbacks
-// and set the appropriate exit code. We use the following workaround:
-// process.<<stream>>(<<some output>>, function() { process.exit(<<code>>); });
-// This will flush the appropriate stream (stdout or stderr) and then
-// exit with the provided code. For now, this makes the CLI work with
-// Node.js versions as old as v0.10.25.
+	for (const key in validated.kit.files) {
+		// @ts-expect-error this is typescript at its stupidest
+		validated.kit.files[key] = path__default.resolve(cwd, validated.kit.files[key]);
+	}
 
-/**
- * Logs a validation result to the console using process.stdout and
- * process.stderr as is appropriate.
- * @param {string} filename
- * @param {!ValidationResult} validationResult
- * @param {boolean} color
- */
-function logValidationResult(filename, validationResult, color) {
-  if (validationResult.status === 'PASS') {
-    process.stdout.write(
-        filename + ': ' + (color ? safe.green('PASS') : 'PASS') + '\n');
-  }
-  for (let ii = 0; ii < validationResult.errors.length; ii++) {
-    const error = validationResult.errors[ii];
-    let msg = filename + ':' + error.line + ':' + error.col + ' ';
-    if (color) {
-      msg += (error.severity === 'ERROR' ? safe.red : safe.magenta)(
-          error.message);
-    } else {
-      msg += error.message;
-    }
-    if (error.specUrl) {
-      msg += ' (see ' + error.specUrl + ')';
-    }
-    // TODO(powdercloud): Should we distinguish error.severity === 'WARNING' ?
-    process.stderr.write(msg + '\n');
-  }
+	return validated;
 }
 
 /**
- * Main entry point into the command line tool.
+ * @param {import('types').Config} config
+ * @returns {import('types').ValidatedConfig}
  */
-function main() {
-  commander
-      .usage(
-          '[options] <fileOrUrlOrMinus...>\n\n' +
-          '  Validates the files or urls provided as arguments. If "-" is\n' +
-          '  specified, reads from stdin instead.')
-      .option(
-          '--validator_js <fileOrUrl>',
-          'The Validator Javascript.\n' +
-              '  Latest published version by default, or\n' +
-              '  dist/validator_minified.js (built with build.py)\n' +
-              '  for development.',
-          'https://cdn.ampproject.org/v0/validator.js')
-      .option(
-          '--user-agent <userAgent>', 'User agent string to use in requests.',
-          DEFAULT_USER_AGENT)
-      .option(
-          '--html_format <AMP|AMP4ADS|AMP4EMAIL>',
-          'The input format to be validated.\n' +
-              '  AMP by default.',
-          'AMP')
-      .option(
-          '--format <color|text|json>',
-          'How to format the output.\n' +
-              '  "color" displays errors/warnings/success in\n' +
-              '          red/orange/green.\n' +
-              '  "text"  avoids color (e.g., useful in terminals not\n' +
-              '          supporting color).\n' +
-              '  "json"  emits json corresponding to the ValidationResult\n' +
-              '          message in validator.proto.',
-          'color')
-      .parse(process.argv);
-  if (commander.args.length === 0) {
-    commander.outputHelp();
-    process.exit(1);
-  }
-  if (commander.html_format !== 'AMP' && commander.html_format !== 'AMP4ADS' &&
-      commander.html_format !== 'AMP4EMAIL') {
-    process.stderr.write(
-        '--html_format must be set to "AMP", "AMP4ADS", or "AMP4EMAIL".\n',
-        function() {
-          process.exit(1);
-        });
-  }
-  if (commander.format !== 'color' && commander.format !== 'text' &&
-      commander.format !== 'json') {
-    process.stderr.write(
-        '--format must be set to "color", "text", or "json".\n', function() {
-          process.exit(1);
-        });
-  }
-  const inputs = [];
-  for (let ii = 0; ii < commander.args.length; ii++) {
-    const item = commander.args[ii];
-    if (item === '-') {
-      inputs.push(readFromStdin());
-    } else if (isHttpOrHttpsUrl(item)) {
-      inputs.push(readFromUrl(item, commander.userAgent));
-    } else {
-      inputs.push(readFromFile(item));
-    }
-  }
-  getInstance(commander.validator_js, commander.userAgent)
-      .then(function(validator) {
-        promise.all(inputs)
-            .then(function(resolvedInputs) {
-              const jsonOut = {};
-              let hasError = false;
-              for (let ii = 0; ii < resolvedInputs.length; ii++) {
-                const validationResult = validator.validateString(
-                    resolvedInputs[ii], commander.html_format);
-                if (commander.format === 'json') {
-                  jsonOut[commander.args[ii]] = validationResult;
-                } else {
-                  logValidationResult(
-                      commander.args[ii], validationResult,
-                      commander.format === 'color' ? true : false);
-                }
-                if (validationResult.status !== 'PASS') {
-                  hasError = true;
-                }
-              }
-              if (commander.format === 'json') {
-                process.stdout.write(
-                    JSON.stringify(jsonOut) + '\n', function() {
-                      process.exit(hasError ? 1 : 0);
-                    });
-              } else if (hasError) {
-                process.stderr.write('', function() {
-                  process.exit(1);
-                });
-              } else {
-                process.stdout.write('', function() {
-                  process.exit(0);
-                });
-              }
-            })
-            .catch(function(error) {
-              process.stderr.write(
-                  (commander.format == 'color' ? safe.red(error.message) :
-                    error.message) +
-                      '\n',
-                  function() {
-                    process.exit(1);
-                  });
-            });
-      })
-      .catch(function(error) {
-        process.stderr.write(
-            (commander.format == 'color' ? safe.red(error.message) :
-              error.message) +
-                '\n',
-            function() {
-              process.exit(1);
-            });
-      });
-}
-
-var main_1 = main;
-
-var amphtmlValidator = {
-	getInstance: getInstance_1,
-	newInstance: newInstance_1,
-	main: main_1
-};
-
-/** @typedef {{ cwd?: string, port: number, config: import('../../types').ValidatedConfig }} Options */
-
-/** @param {Options} opts */
-function dev(opts) {
-	return new Watcher(opts).init();
-}
-
-class Watcher extends EventEmitter {
-	/** @param {Options} opts */
-	constructor({ cwd = process.cwd(), port, config }) {
-		super();
-
-		this.cwd = cwd;
-		this.dir = path.resolve(cwd, '.svelte/dev');
-
-		this.port = port;
-		this.config = config;
-
-		process.env.NODE_ENV = 'development';
-
-		process.on('exit', () => {
-			this.close();
-		});
-	}
-
-	async init() {
-		rimraf(this.dir);
-		copy_assets(this.dir);
-		process.env.VITE_SVELTEKIT_AMP = this.config.kit.amp ? 'true' : '';
-
-		await this.init_filewatcher();
-		await this.init_server();
-
-		this.update();
-
-		return this;
-	}
-
-	async init_filewatcher() {
-		this.cheapwatch = new CheapWatch({
-			dir: this.config.kit.files.routes,
-			/** @type {({ path }: { path: string }) => boolean} */
-			filter: ({ path }) => path.split('/').every((part) => !part.startsWith('_'))
-		});
-
-		await this.cheapwatch.init();
-
-		// not sure why TS doesn't understand that CheapWatch extends EventEmitter
-		this.cheapwatch.on('+', ({ isNew }) => {
-			if (isNew) this.update();
-		});
-
-		this.cheapwatch.on('-', () => {
-			this.update();
-		});
+function validate_config(config) {
+	if (typeof config !== 'object') {
+		throw new Error(
+			'svelte.config.js must have a configuration object as its default export. See https://kit.svelte.dev/docs/configuration'
+		);
 	}
 
-	async init_server() {
-		/**
-		 * @type {vite.ViteDevServer}
-		 */
-		this.viteDevServer = await vite.createServer({
-			root: this.cwd,
-			resolve: {
-				alias: {
-					$app: path.resolve(`${this.dir}/runtime/app`)
-				}
-			},
-			plugins: [
-				svelte({
-					emitCss: true,
-					compilerOptions: {
-						dev: true,
-						hydratable: true
-					},
-					hot: true,
-					extensions: this.config.extensions
-				})
-			],
-			publicDir: this.config.kit.files.assets,
-			server: {
-				middlewareMode: true
-			}
-		});
-
-		const validator = this.config.kit.amp && (await amphtmlValidator.getInstance());
-
-		this.server = http.createServer((req, res) => {
-			this.viteDevServer.middlewares(req, res, async () => {
-				try {
-					const parsed = parse(req.url);
-
-					if (req.url === '/favicon.ico') return;
-
-					// handle dynamic requests - i.e. pages and endpoints
-					const template = fs.readFileSync(this.config.kit.files.template, 'utf-8');
-
-					const setup = await this.viteDevServer
-						.ssrLoadModule(`/${this.config.kit.files.setup}`)
-						.catch(() => ({}));
-
-					let root;
-
-					try {
-						root = (await this.viteDevServer.ssrLoadModule(`/${this.dir}/generated/root.svelte`))
-							.default;
-					} catch (e) {
-						res.statusCode = 500;
-						res.end(e.stack);
-						return;
-					}
-
-					const body = await get_body(req);
-
-					const rendered = await ssr(
-						{
-							headers: req.headers,
-							method: req.method,
-							path: parsed.pathname,
-							query: new URLSearchParams(parsed.query),
-							body
-						},
-						{
-							paths: this.config.kit.paths,
-							template: ({ head, body }) => {
-								let rendered = template
-									.replace('%svelte.head%', () => head)
-									.replace('%svelte.body%', () => body);
-
-								if (this.config.kit.amp) {
-									const result = validator.validateString(rendered);
-
-									if (result.status !== 'PASS') {
-										const lines = rendered.split('\n');
-
-										/** @param {string} str */
-										const escape = (str) =>
-											str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-										rendered = `<!doctype html>
-											<head>
-												<meta charset="utf-8" />
-												<meta name="viewport" content="width=device-width, initial-scale=1" />
-												<style>
-													body {
-														font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-														color: #333;
-													}
-
-													pre {
-														background: #f4f4f4;
-														padding: 1em;
-														overflow-x: auto;
-													}
-												</style>
-											</head>
-											<h1>AMP validation failed</h1>
-
-											${result.errors
-												.map(
-													(error) => `
-												<h2>${error.severity}</h2>
-												<p>Line ${error.line}, column ${error.col}: ${error.message} (<a href="${error.specUrl}">${
-														error.code
-													}</a>)</p>
-												<pre>${escape(lines[error.line - 1])}</pre>
-											`
-												)
-												.join('\n\n')}
-										`;
-									}
-								}
-
-								return rendered;
-							},
-							manifest: this.manifest,
-							target: this.config.kit.target,
-							entry: '/.svelte/dev/runtime/internal/start.js',
-							dev: true,
-							amp: this.config.kit.amp,
-							root,
-							setup,
-							only_prerender: false,
-							start_global: this.config.kit.startGlobal,
-							host: this.config.kit.host,
-							host_header: this.config.kit.hostHeader,
-							get_stack: (error) => {
-								this.viteDevServer.ssrFixStacktrace(error);
-								return error.stack;
-							},
-							get_static_file: (file) =>
-								fs.readFileSync(path.join(this.config.kit.files.assets, file)),
-							get_amp_css: (url) => '' // TODO: implement this
-						}
-					);
-
-					if (rendered) {
-						res.writeHead(rendered.status, rendered.headers);
-						res.end(rendered.body);
-					} else {
-						res.statusCode = 404;
-						res.end('Not found');
-					}
-				} catch (e) {
-					this.viteDevServer.ssrFixStacktrace(e);
-					res.end(e.stack);
-				}
-			});
-		});
-
-		this.server.listen(this.port);
-	}
-
-	update() {
-		const manifest_data = create_manifest_data({
-			config: this.config,
-			output: this.dir,
-			cwd: this.cwd
-		});
-
-		create_app({
-			manifest_data,
-			output: this.dir,
-			cwd: this.cwd
-		});
-
-		const common_css_deps = new Set();
-
-		/**
-		 * @param {string} file
-		 */
-		const load = async (file) => {
-			const url = path.resolve(this.cwd, file);
-
-			const mod = await this.viteDevServer.ssrLoadModule(url);
-			const node = await this.viteDevServer.moduleGraph.getModuleByUrl(url);
-
-			const deps = new Set();
-			find_deps(node, deps);
-
-			const css = new Set();
-			for (const dep of deps) {
-				// TODO what about .scss files, etc?
-				if (dep.file.endsWith('.css')) {
-					try {
-						const mod = await this.viteDevServer.ssrLoadModule(dep.url);
-						css.add(mod.default);
-					} catch {
-						// this can happen with dynamically imported modules, I think
-						// because the Vite module graph doesn't distinguish between
-						// static and dynamic imports? TODO investigate, submit fix
-					}
-				}
-			}
-
-			return { mod, css };
-		};
-
-		/**
-		 * @param {import('vite').ModuleNode} node
-		 * @param {Set<import('vite').ModuleNode>} deps
-		 */
-		const find_deps = (node, deps) => {
-			for (const dep of node.importedModules) {
-				if (!deps.has(dep)) {
-					deps.add(dep);
-					find_deps(dep, deps);
-				}
-			}
-		};
-
-		this.manifest = {
-			assets: manifest_data.assets,
-			layout: async () => {
-				const { mod, css } = await load(manifest_data.layout);
-				css.forEach((mod) => {
-					common_css_deps.add(mod);
-				});
-				return mod;
-			},
-			error: async () => {
-				const { mod, css } = await load(manifest_data.error);
-				css.forEach((mod) => {
-					common_css_deps.add(mod);
-				});
-				return mod;
-			},
-			pages: manifest_data.pages.map((data) => {
-				// This is a bit of a hack, but it means we can inject the correct <style>
-				// contents without needing to do any analysis before loading
-				const css_deps = new Set();
-
-				return {
-					pattern: data.pattern,
-					params: get_params(data.params),
-					parts: data.parts.map((file) => async () => {
-						const { mod, css } = await load(file);
-
-						css.forEach((mod) => {
-							css_deps.add(mod);
-						});
-
-						return mod;
-					}),
-					get style() {
-						return [...common_css_deps, ...css_deps].join('\n');
-					},
-					css: [],
-					js: []
-				};
-			}),
-			endpoints: manifest_data.endpoints.map((data) => ({
-				pattern: data.pattern,
-				params: get_params(data.params),
-				load: async () => {
-					const url = path.resolve(this.cwd, data.file);
-					return await this.viteDevServer.ssrLoadModule(url);
-				}
-			}))
-		};
-	}
-
-	close() {
-		if (this.closed) return;
-		this.closed = true;
-
-		this.viteDevServer.close();
-		this.server.close();
-		this.cheapwatch.close();
-	}
-}
-
-/** @param {string[]} array */
-function get_params(array) {
-	// given an array of params like `['x', 'y', 'z']` for
-	// src/routes/[x]/[y]/[z]/svelte, create a function
-	// that turns a RegExpExecArray into ({ x, y, z })
-
-	/** @param {RegExpExecArray} match */
-	const fn = (match) => {
-		/** @type {Record<string, string | string[]>} */
-		const params = {};
-		array.forEach((key, i) => {
-			if (key.startsWith('...')) {
-				params[key.slice(3)] = decodeURIComponent(match[i + 1]).split('/');
-			} else {
-				params[key] = decodeURIComponent(match[i + 1]);
-			}
-		});
-		return params;
-	};
-
-	return fn;
+	return options(config, 'config');
 }
 
-export { dev };
+export { $, load_template as a, load_config as l };