@sveltejs/kit 1.0.0-next.190 → 1.0.0-next.194

package/assets/runtime/internal/start.js

@@ -655,28 +655,37 @@ class Renderer {
 			this._init(navigation_result);
 		}
 
-		if (opts) {
+		if (!opts) {
+			await 0;
+		} else {
 			const { hash, scroll, keepfocus } = opts;
 
 			if (!keepfocus) {
 				document.body.focus();
 			}
 
-			const deep_linked = hash && document.getElementById(hash.slice(1));
-			if (scroll) {
-				scrollTo(scroll.x, scroll.y);
-			} else if (deep_linked) {
-				// Here we use `scrollIntoView` on the element instead of `scrollTo`
-				// because it natively supports the `scroll-margin` and `scroll-behavior`
-				// CSS properties.
-				deep_linked.scrollIntoView();
-			} else {
-				scrollTo(0, 0);
+			const oldPageYOffset = pageYOffset;
+			await 0;
+			const maxPageYOffset = document.body.scrollHeight - innerHeight;
+
+			// After `await 0`, the `onMount()` function in the component executed.
+			// If there was no scrolling happening (checked via `pageYOffset`),
+			// continue on our custom scroll handling
+			if (pageYOffset === Math.min(oldPageYOffset, maxPageYOffset)) {
+				const deep_linked = hash && document.getElementById(hash.slice(1));
+				if (scroll) {
+					scrollTo(scroll.x, scroll.y);
+				} else if (deep_linked) {
+					// Here we use `scrollIntoView` on the element instead of `scrollTo`
+					// because it natively supports the `scroll-margin` and `scroll-behavior`
+					// CSS properties.
+					deep_linked.scrollIntoView();
+				} else {
+					scrollTo(0, 0);
+				}
 			}
 		}
 
-		await 0;
-
 		this.loading.promise = null;
 		this.loading.id = null;
 

package/dist/chunks/index.js

@@ -4268,6 +4268,20 @@ class Watcher extends EventEmitter {
 		});
 	}
 
+	allowed_directories() {
+		return [
+			...new Set([
+				this.config.kit.files.assets,
+				this.config.kit.files.lib,
+				this.config.kit.files.routes,
+				path__default.resolve(this.cwd, 'src'),
+				path__default.resolve(this.cwd, '.svelte-kit'),
+				path__default.resolve(this.cwd, 'node_modules'),
+				path__default.resolve(vite.searchForWorkspaceRoot(this.cwd), 'node_modules')
+			])
+		];
+	}
+
 	async init_server() {
 		if (!this.manifest) throw new Error('Must call init() before init_server()');
 
@@ -4277,7 +4291,8 @@ class Watcher extends EventEmitter {
 		const default_config = {
 			server: {
 				fs: {
-					strict: true
+					strict: true,
+					allow: this.allowed_directories()
 				},
 				strictPort: true
 			}

package/dist/chunks/index2.js

@@ -198,7 +198,8 @@ function generate_app(manifest_data) {
 	const max_depth = Math.max(
 		...manifest_data.routes.map((route) =>
 			route.type === 'page' ? route.a.filter(Boolean).length : 0
-		)
+		),
+		1
 	);
 
 	const levels = [];

package/dist/chunks/index3.js

@@ -466,12 +466,6 @@ var glob = sync;
 /** @param {any} value */
 const s = (value) => JSON.stringify(value);
 
-/** @typedef {Record<string, {
- *   file: string;
- *   css: string[];
- *   imports: string[];
- * }>} ClientManifest */
-
 /**
  * @param {import('types/config').ValidatedConfig} config
  * @param {{
@@ -562,7 +556,6 @@ async function build_client({
 	process.env.VITE_SVELTEKIT_AMP = config.kit.amp ? 'true' : '';
 
 	const client_out_dir = `${output_dir}/client/${config.kit.appDir}`;
-	const client_manifest_file = `${client_out_dir}/manifest.json`;
 
 	/** @type {Record<string, string>} */
 	const input = {
@@ -637,7 +630,8 @@ async function build_client({
 
 	await vite.build(merged_config);
 
-	/** @type {ClientManifest} */
+	const client_manifest_file = `${client_out_dir}/manifest.json`;
+	/** @type {import('vite').Manifest} */
 	const client_manifest = JSON.parse(fs__default.readFileSync(client_manifest_file, 'utf-8'));
 	fs__default.renameSync(client_manifest_file, `${output_dir}/manifest.json`); // inspectable but not shipped
 
@@ -655,7 +649,7 @@ async function build_client({
  *   client_entry_file: string;
  *   service_worker_entry_file: string | null;
  * }} options
- * @param {ClientManifest} client_manifest
+ * @param {import('vite').Manifest} client_manifest
  * @param {string} runtime
  */
 async function build_server(
@@ -894,7 +888,12 @@ async function build_server(
 
 	const default_config = {
 		build: {
-			target: 'es2020'
+			target: 'es2020',
+			rollupOptions: {
+				output: {
+					inlineDynamicImports: true
+				}
+			}
 		},
 		server: {
 			fs: {
@@ -923,8 +922,7 @@ async function build_server(
 					format: 'esm',
 					entryFileNames: '[name].js',
 					chunkFileNames: 'chunks/[name]-[hash].js',
-					assetFileNames: 'assets/[name]-[hash][extname]',
-					inlineDynamicImports: true
+					assetFileNames: 'assets/[name]-[hash][extname]'
 				},
 				preserveEntrySignatures: 'strict'
 			}
@@ -961,7 +959,7 @@ async function build_server(
  *   client_entry_file: string;
  *   service_worker_entry_file: string | null;
  * }} options
- * @param {ClientManifest} client_manifest
+ * @param {import('vite').Manifest} client_manifest
  */
 async function build_service_worker(
 	{ cwd, assets_base, config, manifest, build_dir, output_dir, service_worker_entry_file },

package/dist/chunks/index4.js

@@ -348,15 +348,15 @@ function get_utils({ cwd, config, build_data, log }) {
 		copy,
 
 		copy_client_files(dest) {
-			copy(`${cwd}/${SVELTE_KIT}/output/client`, dest, (file) => file[0] !== '.');
+			return copy(`${cwd}/${SVELTE_KIT}/output/client`, dest, (file) => file[0] !== '.');
 		},
 
 		copy_server_files(dest) {
-			copy(`${cwd}/${SVELTE_KIT}/output/server`, dest, (file) => file[0] !== '.');
+			return copy(`${cwd}/${SVELTE_KIT}/output/server`, dest, (file) => file[0] !== '.');
 		},
 
 		copy_static_files(dest) {
-			copy(config.kit.files.assets, dest);
+			return copy(config.kit.files.assets, dest);
 		},
 
 		async prerender({ all = false, dest, fallback }) {

package/dist/chunks/index5.js

@@ -153,20 +153,26 @@ function send(req, res, file, stats, headers) {
 	fs.createReadStream(file, opts).pipe(res);
 }
 
-function isEncoding(name, type, headers) {
-	headers['Content-Encoding'] = type;
-	headers['Content-Type'] = lite.getType(name.replace(/\.([^.]*)$/, '')) || '';
-}
+const ENCODING = {
+	'.br': 'br',
+	'.gz': 'gzip',
+};
 
 function toHeaders(name, stats, isEtag) {
+	let enc = ENCODING[name.slice(-3)];
+
+	let ctype = lite.getType(name.slice(0, enc && -3)) || '';
+	if (ctype === 'text/html') ctype += ';charset=utf-8';
+
 	let headers = {
 		'Content-Length': stats.size,
-		'Content-Type': lite.getType(name) || '',
+		'Content-Type': ctype,
 		'Last-Modified': stats.mtime.toUTCString(),
 	};
+
+	if (enc) headers['Content-Encoding'] = enc;
 	if (isEtag) headers['ETag'] = `W/"${stats.size}-${stats.mtime.getTime()}"`;
-	if (/\.br$/.test(name)) isEncoding(name, 'br', headers);
-	if (/\.gz$/.test(name)) isEncoding(name, 'gzip', headers);
+
 	return headers;
 }
 

package/dist/cli.js

@@ -1,8 +1,8 @@
 import fs__default, { existsSync } from 'fs';
 import sade from 'sade';
+import path__default, { relative } from 'path';
 import { exec as exec$1 } from 'child_process';
 import { createConnection, createServer } from 'net';
-import path__default from 'path';
 import * as url from 'url';
 import { fileURLToPath } from 'url';
 import { networkInterfaces, release } from 'os';
@@ -817,7 +817,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.190');
+const prog = sade('svelte-kit').version('1.0.0-next.194');
 
 prog
 	.command('dev')
@@ -851,10 +851,20 @@ prog
 				watcher.vite.httpServer.address()
 			);
 
-			https = https || !!config.kit.vite().server?.https;
-			open = open || !!config.kit.vite().server?.open;
+			const vite_config = config.kit.vite();
 
-			welcome({ port: address_info.port, host: address_info.address, https, open });
+			https = https || !!vite_config.server?.https;
+			open = open || !!vite_config.server?.open;
+
+			welcome({
+				port: address_info.port,
+				host: address_info.address,
+				https,
+				open,
+				loose: vite_config.server?.fs?.strict === false,
+				allow: watcher.allowed_directories(),
+				cwd: watcher.cwd
+			});
 		} catch (error) {
 			handle_error(error);
 		}
@@ -964,12 +974,15 @@ async function check_port(port) {
  *   host: string;
  *   https: boolean;
  *   port: number;
+ *   loose?: boolean;
+ *   allow?: string[];
+ *   cwd?: string;
  * }} param0
  */
-function welcome({ port, host, https, open }) {
+function welcome({ port, host, https, open, loose, allow, cwd }) {
 	if (open) launch(port, https);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.190'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.194'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';
@@ -987,6 +1000,11 @@ function welcome({ port, host, https, open }) {
 
 				if (exposed) {
 					console.log(`  ${$.gray('network:')} ${protocol}//${$.bold(`${details.address}:${port}`)}`);
+					if (loose) {
+						console.log(`\n  ${$.yellow('Serving with vite.server.fs.strict: false. Note that all files on your machine will be accessible to anyone on your network.')}`);
+					} else if (allow?.length && cwd) {
+						console.log(`\n  ${$.yellow('Note that all files in the following directories will be accessible to anyone on your network: ' + allow.map(a => relative(cwd, a)).join(', '))}`);
+					}
 				} else {
 					console.log(`  ${$.gray('network: not exposed')}`);
 				}

package/dist/install-fetch.js

@@ -4238,38 +4238,54 @@ var ponyfill_es2018 = {exports: {}};
 const POOL_SIZE$1 = 65536;
 
 if (!globalThis.ReadableStream) {
+  // `node:stream/web` got introduced in v16.5.0 as experimental
+  // and it's preferred over the polyfilled version. So we also
+  // suppress the warning that gets emitted by NodeJS for using it.
   try {
-    Object.assign(globalThis, require('stream/web'));
+    const process = require('node:process');
+    const { emitWarning } = process;
+    try {
+      process.emitWarning = () => {};
+      Object.assign(globalThis, require('node:stream/web'));
+      process.emitWarning = emitWarning;
+    } catch (error) {
+      process.emitWarning = emitWarning;
+      throw error
+    }
   } catch (error) {
-		// TODO: Remove when only supporting node >= 16.5.0
+    // fallback to polyfill implementation
     Object.assign(globalThis, ponyfill_es2018.exports);
   }
 }
 
 try {
-  const {Blob} = require('buffer');
+  // Don't use node: prefix for this, require+node: is not supported until node v14.14
+  // Only `import()` can use prefix in 12.20 and later
+  const { Blob } = require('buffer');
   if (Blob && !Blob.prototype.stream) {
-		Blob.prototype.stream = function name(params) {
-			let position = 0;
-			const blob = this;
-
-			return new ReadableStream({
-				type: 'bytes',
-				async pull(ctrl) {
-					const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE$1));
-					const buffer = await chunk.arrayBuffer();
-					position += buffer.byteLength;
-					ctrl.enqueue(new Uint8Array(buffer));
-
-					if (position === blob.size) {
-						ctrl.close();
-					}
-				}
-			})
-		};
-	}
+    Blob.prototype.stream = function name (params) {
+      let position = 0;
+      const blob = this;
+
+      return new ReadableStream({
+        type: 'bytes',
+        async pull (ctrl) {
+          const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE$1));
+          const buffer = await chunk.arrayBuffer();
+          position += buffer.byteLength;
+          ctrl.enqueue(new Uint8Array(buffer));
+
+          if (position === blob.size) {
+            ctrl.close();
+          }
+        }
+      })
+    };
+  }
 } catch (error) {}
 
+/*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+
 /** @typedef {import('buffer').Blob} NodeBlob} */
 
 // 64 KiB (same size chrome slice theirs blob into Uint8array's)
@@ -4277,223 +4293,238 @@ const POOL_SIZE = 65536;
 
 /** @param {(Blob | NodeBlob | Uint8Array)[]} parts */
 async function * toIterator (parts, clone = true) {
-	for (let part of parts) {
-		if ('stream' in part) {
-			yield * part.stream();
-		} else if (ArrayBuffer.isView(part)) {
-			if (clone) {
-				let position = part.byteOffset;
-				let end = part.byteOffset + part.byteLength;
-				while (position !== end) {
-					const size = Math.min(end - position, POOL_SIZE);
-					const chunk = part.buffer.slice(position, position + size);
-					position += chunk.byteLength;
-					yield new Uint8Array(chunk);
-				}
-			} else {
-				yield part;
-			}
-		} else {
-			/* c8 ignore start */
-			// For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)
-			let position = 0;
-			while (position !== part.size) {
-				const chunk = part.slice(position, Math.min(part.size, position + POOL_SIZE));
-				const buffer = await chunk.arrayBuffer();
-				position += buffer.byteLength;
-				yield new Uint8Array(buffer);
-			}
-			/* c8 ignore end */
-		}
-	}
+  for (const part of parts) {
+    if ('stream' in part) {
+      yield * part.stream();
+    } else if (ArrayBuffer.isView(part)) {
+      if (clone) {
+        let position = part.byteOffset;
+        const end = part.byteOffset + part.byteLength;
+        while (position !== end) {
+          const size = Math.min(end - position, POOL_SIZE);
+          const chunk = part.buffer.slice(position, position + size);
+          position += chunk.byteLength;
+          yield new Uint8Array(chunk);
+        }
+      } else {
+        yield part;
+      }
+    } else {
+      /* c8 ignore start */
+      // For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)
+      let position = 0;
+      while (position !== part.size) {
+        const chunk = part.slice(position, Math.min(part.size, position + POOL_SIZE));
+        const buffer = await chunk.arrayBuffer();
+        position += buffer.byteLength;
+        yield new Uint8Array(buffer);
+      }
+      /* c8 ignore end */
+    }
+  }
 }
 
 const _Blob = class Blob {
+  /** @type {Array.<(Blob|Uint8Array)>} */
+  #parts = []
+  #type = ''
+  #size = 0
 
-	/** @type {Array.<(Blob|Uint8Array)>} */
-	#parts = [];
-	#type = '';
-	#size = 0;
-
-	/**
-	 * The Blob() constructor returns a new Blob object. The content
-	 * of the blob consists of the concatenation of the values given
-	 * in the parameter array.
-	 *
-	 * @param {*} blobParts
-	 * @param {{ type?: string }} [options]
-	 */
-	constructor(blobParts = [], options = {}) {
-		let size = 0;
-
-		const parts = blobParts.map(element => {
-			let part;
-			if (ArrayBuffer.isView(element)) {
-				part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
-			} else if (element instanceof ArrayBuffer) {
-				part = new Uint8Array(element.slice(0));
-			} else if (element instanceof Blob) {
-				part = element;
-			} else {
-				part = new TextEncoder().encode(element);
-			}
-
-			size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
-			return part;
-		});
+  /**
+   * The Blob() constructor returns a new Blob object. The content
+   * of the blob consists of the concatenation of the values given
+   * in the parameter array.
+   *
+   * @param {*} blobParts
+   * @param {{ type?: string }} [options]
+   */
+  constructor (blobParts = [], options = {}) {
+    if (typeof blobParts !== 'object' || blobParts === null) {
+      throw new TypeError('Failed to construct \'Blob\': The provided value cannot be converted to a sequence.')
+    }
 
-		const type = options.type === undefined ? '' : String(options.type);
+    if (typeof blobParts[Symbol.iterator] !== 'function') {
+      throw new TypeError('Failed to construct \'Blob\': The object must have a callable @@iterator property.')
+    }
 
-		this.#type = /[^\u0020-\u007E]/.test(type) ? '' : type;
-		this.#size = size;
-		this.#parts = parts;
-	}
+    if (typeof options !== 'object' && typeof options !== 'function') {
+      throw new TypeError('Failed to construct \'Blob\': parameter 2 cannot convert to dictionary.')
+    }
 
-	/**
-	 * The Blob interface's size property returns the
-	 * size of the Blob in bytes.
-	 */
-	get size() {
-		return this.#size;
-	}
+    if (options === null) options = {};
 
-	/**
-	 * The type property of a Blob object returns the MIME type of the file.
-	 */
-	get type() {
-		return this.#type;
-	}
+    const encoder = new TextEncoder();
+    for (const element of blobParts) {
+      let part;
+      if (ArrayBuffer.isView(element)) {
+        part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
+      } else if (element instanceof ArrayBuffer) {
+        part = new Uint8Array(element.slice(0));
+      } else if (element instanceof Blob) {
+        part = element;
+      } else {
+        part = encoder.encode(element);
+      }
 
-	/**
-	 * The text() method in the Blob interface returns a Promise
-	 * that resolves with a string containing the contents of
-	 * the blob, interpreted as UTF-8.
-	 *
-	 * @return {Promise<string>}
-	 */
-	async text() {
-		// More optimized than using this.arrayBuffer()
-		// that requires twice as much ram
-		const decoder = new TextDecoder();
-		let str = '';
-		for await (let part of toIterator(this.#parts, false)) {
-			str += decoder.decode(part, { stream: true });
-		}
-		// Remaining
-		str += decoder.decode();
-		return str;
-	}
-
-	/**
-	 * The arrayBuffer() method in the Blob interface returns a
-	 * Promise that resolves with the contents of the blob as
-	 * binary data contained in an ArrayBuffer.
-	 *
-	 * @return {Promise<ArrayBuffer>}
-	 */
-	async arrayBuffer() {
-		// Easier way... Just a unnecessary overhead
-		// const view = new Uint8Array(this.size);
-		// await this.stream().getReader({mode: 'byob'}).read(view);
-		// return view.buffer;
-
-		const data = new Uint8Array(this.size);
-		let offset = 0;
-		for await (const chunk of toIterator(this.#parts, false)) {
-			data.set(chunk, offset);
-			offset += chunk.length;
-		}
+      this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
+      this.#parts.push(part);
+    }
 
-		return data.buffer;
-	}
+    const type = options.type === undefined ? '' : String(options.type);
 
-	stream() {
-		const it = toIterator(this.#parts, true);
+    this.#type = /^[\x20-\x7E]*$/.test(type) ? type : '';
+  }
 
-		return new ReadableStream({
-			type: 'bytes',
-			async pull(ctrl) {
-				const chunk = await it.next();
-				chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
-			}
-		})
-	}
+  /**
+   * The Blob interface's size property returns the
+   * size of the Blob in bytes.
+   */
+  get size () {
+    return this.#size
+  }
 
-	/**
-	 * The Blob interface's slice() method creates and returns a
-	 * new Blob object which contains data from a subset of the
-	 * blob on which it's called.
-	 *
-	 * @param {number} [start]
-	 * @param {number} [end]
-	 * @param {string} [type]
-	 */
-	slice(start = 0, end = this.size, type = '') {
-		const {size} = this;
+  /**
+   * The type property of a Blob object returns the MIME type of the file.
+   */
+  get type () {
+    return this.#type
+  }
 
-		let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
-		let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+  /**
+   * The text() method in the Blob interface returns a Promise
+   * that resolves with a string containing the contents of
+   * the blob, interpreted as UTF-8.
+   *
+   * @return {Promise<string>}
+   */
+  async text () {
+    // More optimized than using this.arrayBuffer()
+    // that requires twice as much ram
+    const decoder = new TextDecoder();
+    let str = '';
+    for await (const part of toIterator(this.#parts, false)) {
+      str += decoder.decode(part, { stream: true });
+    }
+    // Remaining
+    str += decoder.decode();
+    return str
+  }
 
-		const span = Math.max(relativeEnd - relativeStart, 0);
-		const parts = this.#parts;
-		const blobParts = [];
-		let added = 0;
+  /**
+   * The arrayBuffer() method in the Blob interface returns a
+   * Promise that resolves with the contents of the blob as
+   * binary data contained in an ArrayBuffer.
+   *
+   * @return {Promise<ArrayBuffer>}
+   */
+  async arrayBuffer () {
+    // Easier way... Just a unnecessary overhead
+    // const view = new Uint8Array(this.size);
+    // await this.stream().getReader({mode: 'byob'}).read(view);
+    // return view.buffer;
+
+    const data = new Uint8Array(this.size);
+    let offset = 0;
+    for await (const chunk of toIterator(this.#parts, false)) {
+      data.set(chunk, offset);
+      offset += chunk.length;
+    }
+
+    return data.buffer
+  }
 
-		for (const part of parts) {
-			// don't add the overflow to new blobParts
-			if (added >= span) {
-				break;
-			}
+  stream () {
+    const it = toIterator(this.#parts, true);
 
-			const size = ArrayBuffer.isView(part) ? part.byteLength : part.size;
-			if (relativeStart && size <= relativeStart) {
-				// Skip the beginning and change the relative
-				// start & end position as we skip the unwanted parts
-				relativeStart -= size;
-				relativeEnd -= size;
-			} else {
-				let chunk;
-				if (ArrayBuffer.isView(part)) {
-					chunk = part.subarray(relativeStart, Math.min(size, relativeEnd));
-					added += chunk.byteLength;
-				} else {
-					chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
-					added += chunk.size;
-				}
-				blobParts.push(chunk);
-				relativeStart = 0; // All next sequential parts should start at 0
-			}
-		}
+    return new globalThis.ReadableStream({
+      type: 'bytes',
+      async pull (ctrl) {
+        const chunk = await it.next();
+        chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
+      },
 
-		const blob = new Blob([], {type: String(type).toLowerCase()});
-		blob.#size = span;
-		blob.#parts = blobParts;
+      async cancel () {
+        await it.return();
+      }
+    })
+  }
 
-		return blob;
-	}
+  /**
+   * The Blob interface's slice() method creates and returns a
+   * new Blob object which contains data from a subset of the
+   * blob on which it's called.
+   *
+   * @param {number} [start]
+   * @param {number} [end]
+   * @param {string} [type]
+   */
+  slice (start = 0, end = this.size, type = '') {
+    const { size } = this;
+
+    let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+    let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+
+    const span = Math.max(relativeEnd - relativeStart, 0);
+    const parts = this.#parts;
+    const blobParts = [];
+    let added = 0;
+
+    for (const part of parts) {
+      // don't add the overflow to new blobParts
+      if (added >= span) {
+        break
+      }
+
+      const size = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+      if (relativeStart && size <= relativeStart) {
+        // Skip the beginning and change the relative
+        // start & end position as we skip the unwanted parts
+        relativeStart -= size;
+        relativeEnd -= size;
+      } else {
+        let chunk;
+        if (ArrayBuffer.isView(part)) {
+          chunk = part.subarray(relativeStart, Math.min(size, relativeEnd));
+          added += chunk.byteLength;
+        } else {
+          chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
+          added += chunk.size;
+        }
+        relativeEnd -= size;
+        blobParts.push(chunk);
+        relativeStart = 0; // All next sequential parts should start at 0
+      }
+    }
+
+    const blob = new Blob([], { type: String(type).toLowerCase() });
+    blob.#size = span;
+    blob.#parts = blobParts;
+
+    return blob
+  }
 
-	get [Symbol.toStringTag]() {
-		return 'Blob';
-	}
+  get [Symbol.toStringTag] () {
+    return 'Blob'
+  }
 
-	static [Symbol.hasInstance](object) {
-		return (
-			object &&
-			typeof object === 'object' &&
-			typeof object.constructor === 'function' &&
-			(
-				typeof object.stream === 'function' ||
-				typeof object.arrayBuffer === 'function'
-			) &&
-			/^(Blob|File)$/.test(object[Symbol.toStringTag])
-		);
-	}
+  static [Symbol.hasInstance] (object) {
+    return (
+      object &&
+      typeof object === 'object' &&
+      typeof object.constructor === 'function' &&
+      (
+        typeof object.stream === 'function' ||
+        typeof object.arrayBuffer === 'function'
+      ) &&
+      /^(Blob|File)$/.test(object[Symbol.toStringTag])
+    )
+  }
 };
 
 Object.defineProperties(_Blob.prototype, {
-	size: {enumerable: true},
-	type: {enumerable: true},
-	slice: {enumerable: true}
+  size: { enumerable: true },
+  type: { enumerable: true },
+  slice: { enumerable: true }
 });
 
 /** @type {typeof globalThis.Blob} */

package/dist/ssr.js

@@ -1260,8 +1260,7 @@ async function respond$1(opts) {
 		// otherwise bail out at this point
 		return {
 			status: 204,
-			headers: {},
-			body: ''
+			headers: {}
 		};
 	}
 
@@ -1753,8 +1752,7 @@ async function respond(incoming, options, state = {}) {
 								if (request.headers['if-none-match'] === etag) {
 									return {
 										status: 304,
-										headers: {},
-										body: ''
+										headers: {}
 									};
 								}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.190",
+  "version": "1.0.0-next.194",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -12,7 +12,7 @@
     "@sveltejs/vite-plugin-svelte": "^1.0.0-next.30",
     "cheap-watch": "^1.0.4",
     "sade": "^1.7.4",
-    "vite": "^2.6.11"
+    "vite": "^2.6.12"
   },
   "devDependencies": {
     "@rollup/plugin-replace": "^3.0.0",

package/types/ambient-modules.d.ts

@@ -161,7 +161,7 @@ declare module '@sveltejs/kit/ssr' {
 	type State = import('@sveltejs/kit/types/internal').SSRRenderState;
 
 	export interface Respond {
-		(incoming: IncomingRequest, options: Options, state?: State): Response;
+		(incoming: IncomingRequest, options: Options, state?: State): Promise<Response>;
 	}
 	export const respond: Respond;
 }

package/types/config.d.ts

@@ -6,10 +6,27 @@ export interface AdapterUtils {
 	log: Logger;
 	rimraf(dir: string): void;
 	mkdirp(dir: string): void;
-	copy_client_files(dest: string): void;
-	copy_server_files(dest: string): void;
-	copy_static_files(dest: string): void;
-	copy(from: string, to: string, filter?: (basename: string) => boolean): void;
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	copy_client_files(dest: string): string[];
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	copy_server_files(dest: string): string[];
+	/**
+	 * @param dest the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	copy_static_files(dest: string): string[];
+	/**
+	 * @param from the source folder from which files should be copied
+	 * @param to the destination folder to which files should be copied
+	 * @returns an array of paths corresponding to the files that have been created by the copy
+	 */
+	copy(from: string, to: string, filter?: (basename: string) => boolean): string[];
 	prerender(options: { all?: boolean; dest: string; fallback?: string }): Promise<void>;
 }
 

package/types/internal.d.ts

@@ -121,9 +121,13 @@ export interface Hooks {
 
 export interface SSRNode {
 	module: SSRComponent;
-	entry: string; // client-side module corresponding to this component
+	/** client-side module URL for this component */
+	entry: string;
+	/** external CSS files */
 	css: string[];
+	/** external JS files */
 	js: string[];
+	/** inlined styles */
 	styles: string[];
 }