@sveltejs/kit 1.0.0-next.43 → 1.0.0-next.430

package/dist/ssr.js

@@ -1,2581 +0,0 @@
-import { randomBytes, createHash } from 'crypto';
-import http from 'http';
-import https from 'https';
-import zlib from 'zlib';
-import Stream, { PassThrough, pipeline } from 'stream';
-import { types } from 'util';
-import { format, parse, resolve, URLSearchParams as URLSearchParams$1 } from 'url';
-
-var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
-var unsafeChars = /[<>\b\f\n\r\t\0\u2028\u2029]/g;
-var reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
-var escaped = {
-    '<': '\\u003C',
-    '>': '\\u003E',
-    '/': '\\u002F',
-    '\\': '\\\\',
-    '\b': '\\b',
-    '\f': '\\f',
-    '\n': '\\n',
-    '\r': '\\r',
-    '\t': '\\t',
-    '\0': '\\0',
-    '\u2028': '\\u2028',
-    '\u2029': '\\u2029'
-};
-var objectProtoOwnPropertyNames = Object.getOwnPropertyNames(Object.prototype).sort().join('\0');
-function devalue(value) {
-    var counts = new Map();
-    function walk(thing) {
-        if (typeof thing === 'function') {
-            throw new Error("Cannot stringify a function");
-        }
-        if (counts.has(thing)) {
-            counts.set(thing, counts.get(thing) + 1);
-            return;
-        }
-        counts.set(thing, 1);
-        if (!isPrimitive(thing)) {
-            var type = getType(thing);
-            switch (type) {
-                case 'Number':
-                case 'String':
-                case 'Boolean':
-                case 'Date':
-                case 'RegExp':
-                    return;
-                case 'Array':
-                    thing.forEach(walk);
-                    break;
-                case 'Set':
-                case 'Map':
-                    Array.from(thing).forEach(walk);
-                    break;
-                default:
-                    var proto = Object.getPrototypeOf(thing);
-                    if (proto !== Object.prototype &&
-                        proto !== null &&
-                        Object.getOwnPropertyNames(proto).sort().join('\0') !== objectProtoOwnPropertyNames) {
-                        throw new Error("Cannot stringify arbitrary non-POJOs");
-                    }
-                    if (Object.getOwnPropertySymbols(thing).length > 0) {
-                        throw new Error("Cannot stringify POJOs with symbolic keys");
-                    }
-                    Object.keys(thing).forEach(function (key) { return walk(thing[key]); });
-            }
-        }
-    }
-    walk(value);
-    var names = new Map();
-    Array.from(counts)
-        .filter(function (entry) { return entry[1] > 1; })
-        .sort(function (a, b) { return b[1] - a[1]; })
-        .forEach(function (entry, i) {
-        names.set(entry[0], getName(i));
-    });
-    function stringify(thing) {
-        if (names.has(thing)) {
-            return names.get(thing);
-        }
-        if (isPrimitive(thing)) {
-            return stringifyPrimitive(thing);
-        }
-        var type = getType(thing);
-        switch (type) {
-            case 'Number':
-            case 'String':
-            case 'Boolean':
-                return "Object(" + stringify(thing.valueOf()) + ")";
-            case 'RegExp':
-                return "new RegExp(" + stringifyString(thing.source) + ", \"" + thing.flags + "\")";
-            case 'Date':
-                return "new Date(" + thing.getTime() + ")";
-            case 'Array':
-                var members = thing.map(function (v, i) { return i in thing ? stringify(v) : ''; });
-                var tail = thing.length === 0 || (thing.length - 1 in thing) ? '' : ',';
-                return "[" + members.join(',') + tail + "]";
-            case 'Set':
-            case 'Map':
-                return "new " + type + "([" + Array.from(thing).map(stringify).join(',') + "])";
-            default:
-                var obj = "{" + Object.keys(thing).map(function (key) { return safeKey(key) + ":" + stringify(thing[key]); }).join(',') + "}";
-                var proto = Object.getPrototypeOf(thing);
-                if (proto === null) {
-                    return Object.keys(thing).length > 0
-                        ? "Object.assign(Object.create(null)," + obj + ")"
-                        : "Object.create(null)";
-                }
-                return obj;
-        }
-    }
-    var str = stringify(value);
-    if (names.size) {
-        var params_1 = [];
-        var statements_1 = [];
-        var values_1 = [];
-        names.forEach(function (name, thing) {
-            params_1.push(name);
-            if (isPrimitive(thing)) {
-                values_1.push(stringifyPrimitive(thing));
-                return;
-            }
-            var type = getType(thing);
-            switch (type) {
-                case 'Number':
-                case 'String':
-                case 'Boolean':
-                    values_1.push("Object(" + stringify(thing.valueOf()) + ")");
-                    break;
-                case 'RegExp':
-                    values_1.push(thing.toString());
-                    break;
-                case 'Date':
-                    values_1.push("new Date(" + thing.getTime() + ")");
-                    break;
-                case 'Array':
-                    values_1.push("Array(" + thing.length + ")");
-                    thing.forEach(function (v, i) {
-                        statements_1.push(name + "[" + i + "]=" + stringify(v));
-                    });
-                    break;
-                case 'Set':
-                    values_1.push("new Set");
-                    statements_1.push(name + "." + Array.from(thing).map(function (v) { return "add(" + stringify(v) + ")"; }).join('.'));
-                    break;
-                case 'Map':
-                    values_1.push("new Map");
-                    statements_1.push(name + "." + Array.from(thing).map(function (_a) {
-                        var k = _a[0], v = _a[1];
-                        return "set(" + stringify(k) + ", " + stringify(v) + ")";
-                    }).join('.'));
-                    break;
-                default:
-                    values_1.push(Object.getPrototypeOf(thing) === null ? 'Object.create(null)' : '{}');
-                    Object.keys(thing).forEach(function (key) {
-                        statements_1.push("" + name + safeProp(key) + "=" + stringify(thing[key]));
-                    });
-            }
-        });
-        statements_1.push("return " + str);
-        return "(function(" + params_1.join(',') + "){" + statements_1.join(';') + "}(" + values_1.join(',') + "))";
-    }
-    else {
-        return str;
-    }
-}
-function getName(num) {
-    var name = '';
-    do {
-        name = chars[num % chars.length] + name;
-        num = ~~(num / chars.length) - 1;
-    } while (num >= 0);
-    return reserved.test(name) ? name + "_" : name;
-}
-function isPrimitive(thing) {
-    return Object(thing) !== thing;
-}
-function stringifyPrimitive(thing) {
-    if (typeof thing === 'string')
-        return stringifyString(thing);
-    if (thing === void 0)
-        return 'void 0';
-    if (thing === 0 && 1 / thing < 0)
-        return '-0';
-    var str = String(thing);
-    if (typeof thing === 'number')
-        return str.replace(/^(-)?0\./, '$1.');
-    return str;
-}
-function getType(thing) {
-    return Object.prototype.toString.call(thing).slice(8, -1);
-}
-function escapeUnsafeChar(c) {
-    return escaped[c] || c;
-}
-function escapeUnsafeChars(str) {
-    return str.replace(unsafeChars, escapeUnsafeChar);
-}
-function safeKey(key) {
-    return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escapeUnsafeChars(JSON.stringify(key));
-}
-function safeProp(key) {
-    return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? "." + key : "[" + escapeUnsafeChars(JSON.stringify(key)) + "]";
-}
-function stringifyString(str) {
-    var result = '"';
-    for (var i = 0; i < str.length; i += 1) {
-        var char = str.charAt(i);
-        var code = char.charCodeAt(0);
-        if (char === '"') {
-            result += '\\"';
-        }
-        else if (char in escaped) {
-            result += escaped[char];
-        }
-        else if (code >= 0xd800 && code <= 0xdfff) {
-            var next = str.charCodeAt(i + 1);
-            // If this is the beginning of a [high, low] surrogate pair,
-            // add the next two characters, otherwise escape
-            if (code <= 0xdbff && (next >= 0xdc00 && next <= 0xdfff)) {
-                result += char + str[++i];
-            }
-            else {
-                result += "\\u" + code.toString(16).toUpperCase();
-            }
-        }
-        else {
-            result += char;
-        }
-    }
-    result += '"';
-    return result;
-}
-
-/**
- * Returns a `Buffer` instance from the given data URI `uri`.
- *
- * @param {String} uri Data URI to turn into a Buffer instance
- * @return {Buffer} Buffer instance from Data URI
- * @api public
- */
-function dataUriToBuffer(uri) {
-    if (!/^data:/i.test(uri)) {
-        throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
-    }
-    // strip newlines
-    uri = uri.replace(/\r?\n/g, '');
-    // split the URI up into the "metadata" and the "data" portions
-    const firstComma = uri.indexOf(',');
-    if (firstComma === -1 || firstComma <= 4) {
-        throw new TypeError('malformed data: URI');
-    }
-    // remove the "data:" scheme and parse the metadata
-    const meta = uri.substring(5, firstComma).split(';');
-    let charset = '';
-    let base64 = false;
-    const type = meta[0] || 'text/plain';
-    let typeFull = type;
-    for (let i = 1; i < meta.length; i++) {
-        if (meta[i] === 'base64') {
-            base64 = true;
-        }
-        else {
-            typeFull += `;${meta[i]}`;
-            if (meta[i].indexOf('charset=') === 0) {
-                charset = meta[i].substring(8);
-            }
-        }
-    }
-    // defaults to US-ASCII only if type is not provided
-    if (!meta[0] && !charset.length) {
-        typeFull += ';charset=US-ASCII';
-        charset = 'US-ASCII';
-    }
-    // get the encoded data portion and decode URI-encoded chars
-    const encoding = base64 ? 'base64' : 'ascii';
-    const data = unescape(uri.substring(firstComma + 1));
-    const buffer = Buffer.from(data, encoding);
-    // set `.type` and `.typeFull` properties to MIME type
-    buffer.type = type;
-    buffer.typeFull = typeFull;
-    // set the `.charset` property
-    buffer.charset = charset;
-    return buffer;
-}
-var src = dataUriToBuffer;
-
-const {Readable} = Stream;
-
-/**
- * @type {WeakMap<Blob, {type: string, size: number, parts: (Blob | Buffer)[] }>}
- */
-const wm = new WeakMap();
-
-async function * read(parts) {
-	for (const part of parts) {
-		if ('stream' in part) {
-			yield * part.stream();
-		} else {
-			yield part;
-		}
-	}
-}
-
-class Blob {
-	/**
-	 * 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 {(ArrayBufferLike | ArrayBufferView | Blob | Buffer | string)[]} blobParts
-	 * @param {{ type?: string }} [options]
-	 */
-	constructor(blobParts = [], options = {type: ''}) {
-		let size = 0;
-
-		const parts = blobParts.map(element => {
-			let buffer;
-			if (element instanceof Buffer) {
-				buffer = element;
-			} else if (ArrayBuffer.isView(element)) {
-				buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
-			} else if (element instanceof ArrayBuffer) {
-				buffer = Buffer.from(element);
-			} else if (element instanceof Blob) {
-				buffer = element;
-			} else {
-				buffer = Buffer.from(typeof element === 'string' ? element : String(element));
-			}
-
-			size += buffer.length || buffer.size || 0;
-			return buffer;
-		});
-
-		const type = options.type === undefined ? '' : String(options.type).toLowerCase();
-
-		wm.set(this, {
-			type: /[^\u0020-\u007E]/.test(type) ? '' : type,
-			size,
-			parts
-		});
-	}
-
-	/**
-	 * The Blob interface's size property returns the
-	 * size of the Blob in bytes.
-	 */
-	get size() {
-		return wm.get(this).size;
-	}
-
-	/**
-	 * The type property of a Blob object returns the MIME type of the file.
-	 */
-	get type() {
-		return wm.get(this).type;
-	}
-
-	/**
-	 * 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() {
-		return Buffer.from(await this.arrayBuffer()).toString();
-	}
-
-	/**
-	 * 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() {
-		const data = new Uint8Array(this.size);
-		let offset = 0;
-		for await (const chunk of this.stream()) {
-			data.set(chunk, offset);
-			offset += chunk.length;
-		}
-
-		return data.buffer;
-	}
-
-	/**
-	 * The Blob interface's stream() method is difference from native
-	 * and uses node streams instead of whatwg streams.
-	 *
-	 * @returns {Readable} Node readable stream
-	 */
-	stream() {
-		return Readable.from(read(wm.get(this).parts));
-	}
-
-	/**
-	 * 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 = wm.get(this).parts.values();
-		const blobParts = [];
-		let added = 0;
-
-		for (const part of parts) {
-			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 {
-				const chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
-				blobParts.push(chunk);
-				added += ArrayBuffer.isView(chunk) ? chunk.byteLength : chunk.size;
-				relativeStart = 0; // All next sequental parts should start at 0
-
-				// don't add the overflow to new blobParts
-				if (added >= span) {
-					break;
-				}
-			}
-		}
-
-		const blob = new Blob([], {type});
-		Object.assign(wm.get(blob), {size: span, parts: blobParts});
-
-		return blob;
-	}
-
-	get [Symbol.toStringTag]() {
-		return 'Blob';
-	}
-
-	static [Symbol.hasInstance](object) {
-		return (
-			typeof object === 'object' &&
-			typeof object.stream === 'function' &&
-			object.stream.length === 0 &&
-			typeof object.constructor === 'function' &&
-			/^(Blob|File)$/.test(object[Symbol.toStringTag])
-		);
-	}
-}
-
-Object.defineProperties(Blob.prototype, {
-	size: {enumerable: true},
-	type: {enumerable: true},
-	slice: {enumerable: true}
-});
-
-var fetchBlob = Blob;
-
-class FetchBaseError extends Error {
-	constructor(message, type) {
-		super(message);
-		// Hide custom error implementation details from end-users
-		Error.captureStackTrace(this, this.constructor);
-
-		this.type = type;
-	}
-
-	get name() {
-		return this.constructor.name;
-	}
-
-	get [Symbol.toStringTag]() {
-		return this.constructor.name;
-	}
-}
-
-/**
- * @typedef {{ address?: string, code: string, dest?: string, errno: number, info?: object, message: string, path?: string, port?: number, syscall: string}} SystemError
-*/
-
-/**
- * FetchError interface for operational errors
- */
-class FetchError extends FetchBaseError {
-	/**
-	 * @param  {string} message -      Error message for human
-	 * @param  {string} [type] -        Error type for machine
-	 * @param  {SystemError} [systemError] - For Node.js system error
-	 */
-	constructor(message, type, systemError) {
-		super(message, type);
-		// When err.type is `system`, err.erroredSysCall contains system error and err.code contains system error code
-		if (systemError) {
-			// eslint-disable-next-line no-multi-assign
-			this.code = this.errno = systemError.code;
-			this.erroredSysCall = systemError.syscall;
-		}
-	}
-}
-
-/**
- * Is.js
- *
- * Object type checks.
- */
-
-const NAME = Symbol.toStringTag;
-
-/**
- * Check if `obj` is a URLSearchParams object
- * ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
- *
- * @param  {*} obj
- * @return {boolean}
- */
-const isURLSearchParameters = object => {
-	return (
-		typeof object === 'object' &&
-		typeof object.append === 'function' &&
-		typeof object.delete === 'function' &&
-		typeof object.get === 'function' &&
-		typeof object.getAll === 'function' &&
-		typeof object.has === 'function' &&
-		typeof object.set === 'function' &&
-		typeof object.sort === 'function' &&
-		object[NAME] === 'URLSearchParams'
-	);
-};
-
-/**
- * Check if `object` is a W3C `Blob` object (which `File` inherits from)
- *
- * @param  {*} obj
- * @return {boolean}
- */
-const isBlob = object => {
-	return (
-		typeof object === 'object' &&
-		typeof object.arrayBuffer === 'function' &&
-		typeof object.type === 'string' &&
-		typeof object.stream === 'function' &&
-		typeof object.constructor === 'function' &&
-		/^(Blob|File)$/.test(object[NAME])
-	);
-};
-
-/**
- * Check if `obj` is a spec-compliant `FormData` object
- *
- * @param {*} object
- * @return {boolean}
- */
-function isFormData(object) {
-	return (
-		typeof object === 'object' &&
-		typeof object.append === 'function' &&
-		typeof object.set === 'function' &&
-		typeof object.get === 'function' &&
-		typeof object.getAll === 'function' &&
-		typeof object.delete === 'function' &&
-		typeof object.keys === 'function' &&
-		typeof object.values === 'function' &&
-		typeof object.entries === 'function' &&
-		typeof object.constructor === 'function' &&
-		object[NAME] === 'FormData'
-	);
-}
-
-/**
- * Check if `obj` is an instance of AbortSignal.
- *
- * @param  {*} obj
- * @return {boolean}
- */
-const isAbortSignal = object => {
-	return (
-		typeof object === 'object' &&
-		object[NAME] === 'AbortSignal'
-	);
-};
-
-const carriage = '\r\n';
-const dashes = '-'.repeat(2);
-const carriageLength = Buffer.byteLength(carriage);
-
-/**
- * @param {string} boundary
- */
-const getFooter = boundary => `${dashes}${boundary}${dashes}${carriage.repeat(2)}`;
-
-/**
- * @param {string} boundary
- * @param {string} name
- * @param {*} field
- *
- * @return {string}
- */
-function getHeader(boundary, name, field) {
-	let header = '';
-
-	header += `${dashes}${boundary}${carriage}`;
-	header += `Content-Disposition: form-data; name="${name}"`;
-
-	if (isBlob(field)) {
-		header += `; filename="${field.name}"${carriage}`;
-		header += `Content-Type: ${field.type || 'application/octet-stream'}`;
-	}
-
-	return `${header}${carriage.repeat(2)}`;
-}
-
-/**
- * @return {string}
- */
-const getBoundary = () => randomBytes(8).toString('hex');
-
-/**
- * @param {FormData} form
- * @param {string} boundary
- */
-async function * formDataIterator(form, boundary) {
-	for (const [name, value] of form) {
-		yield getHeader(boundary, name, value);
-
-		if (isBlob(value)) {
-			yield * value.stream();
-		} else {
-			yield value;
-		}
-
-		yield carriage;
-	}
-
-	yield getFooter(boundary);
-}
-
-/**
- * @param {FormData} form
- * @param {string} boundary
- */
-function getFormDataLength(form, boundary) {
-	let length = 0;
-
-	for (const [name, value] of form) {
-		length += Buffer.byteLength(getHeader(boundary, name, value));
-
-		if (isBlob(value)) {
-			length += value.size;
-		} else {
-			length += Buffer.byteLength(String(value));
-		}
-
-		length += carriageLength;
-	}
-
-	length += Buffer.byteLength(getFooter(boundary));
-
-	return length;
-}
-
-const INTERNALS$2 = Symbol('Body internals');
-
-/**
- * Body mixin
- *
- * Ref: https://fetch.spec.whatwg.org/#body
- *
- * @param   Stream  body  Readable stream
- * @param   Object  opts  Response options
- * @return  Void
- */
-class Body {
-	constructor(body, {
-		size = 0
-	} = {}) {
-		let boundary = null;
-
-		if (body === null) {
-			// Body is undefined or null
-			body = null;
-		} else if (isURLSearchParameters(body)) {
-		// Body is a URLSearchParams
-			body = Buffer.from(body.toString());
-		} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (types.isAnyArrayBuffer(body)) {
-			// Body is ArrayBuffer
-			body = Buffer.from(body);
-		} else if (ArrayBuffer.isView(body)) {
-			// Body is ArrayBufferView
-			body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
-		} else if (body instanceof Stream) ; else if (isFormData(body)) {
-			// Body is an instance of formdata-node
-			boundary = `NodeFetchFormDataBoundary${getBoundary()}`;
-			body = Stream.Readable.from(formDataIterator(body, boundary));
-		} else {
-			// None of the above
-			// coerce to string then buffer
-			body = Buffer.from(String(body));
-		}
-
-		this[INTERNALS$2] = {
-			body,
-			boundary,
-			disturbed: false,
-			error: null
-		};
-		this.size = size;
-
-		if (body instanceof Stream) {
-			body.on('error', err => {
-				const error = err instanceof FetchBaseError ?
-					err :
-					new FetchError(`Invalid response body while trying to fetch ${this.url}: ${err.message}`, 'system', err);
-				this[INTERNALS$2].error = error;
-			});
-		}
-	}
-
-	get body() {
-		return this[INTERNALS$2].body;
-	}
-
-	get bodyUsed() {
-		return this[INTERNALS$2].disturbed;
-	}
-
-	/**
-	 * Decode response as ArrayBuffer
-	 *
-	 * @return  Promise
-	 */
-	async arrayBuffer() {
-		const {buffer, byteOffset, byteLength} = await consumeBody(this);
-		return buffer.slice(byteOffset, byteOffset + byteLength);
-	}
-
-	/**
-	 * Return raw response as Blob
-	 *
-	 * @return Promise
-	 */
-	async blob() {
-		const ct = (this.headers && this.headers.get('content-type')) || (this[INTERNALS$2].body && this[INTERNALS$2].body.type) || '';
-		const buf = await this.buffer();
-
-		return new fetchBlob([buf], {
-			type: ct
-		});
-	}
-
-	/**
-	 * Decode response as json
-	 *
-	 * @return  Promise
-	 */
-	async json() {
-		const buffer = await consumeBody(this);
-		return JSON.parse(buffer.toString());
-	}
-
-	/**
-	 * Decode response as text
-	 *
-	 * @return  Promise
-	 */
-	async text() {
-		const buffer = await consumeBody(this);
-		return buffer.toString();
-	}
-
-	/**
-	 * Decode response as buffer (non-spec api)
-	 *
-	 * @return  Promise
-	 */
-	buffer() {
-		return consumeBody(this);
-	}
-}
-
-// In browsers, all properties are enumerable.
-Object.defineProperties(Body.prototype, {
-	body: {enumerable: true},
-	bodyUsed: {enumerable: true},
-	arrayBuffer: {enumerable: true},
-	blob: {enumerable: true},
-	json: {enumerable: true},
-	text: {enumerable: true}
-});
-
-/**
- * Consume and convert an entire Body to a Buffer.
- *
- * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
- *
- * @return Promise
- */
-async function consumeBody(data) {
-	if (data[INTERNALS$2].disturbed) {
-		throw new TypeError(`body used already for: ${data.url}`);
-	}
-
-	data[INTERNALS$2].disturbed = true;
-
-	if (data[INTERNALS$2].error) {
-		throw data[INTERNALS$2].error;
-	}
-
-	let {body} = data;
-
-	// Body is null
-	if (body === null) {
-		return Buffer.alloc(0);
-	}
-
-	// Body is blob
-	if (isBlob(body)) {
-		body = body.stream();
-	}
-
-	// Body is buffer
-	if (Buffer.isBuffer(body)) {
-		return body;
-	}
-
-	/* c8 ignore next 3 */
-	if (!(body instanceof Stream)) {
-		return Buffer.alloc(0);
-	}
-
-	// Body is stream
-	// get ready to actually consume the body
-	const accum = [];
-	let accumBytes = 0;
-
-	try {
-		for await (const chunk of body) {
-			if (data.size > 0 && accumBytes + chunk.length > data.size) {
-				const err = new FetchError(`content size at ${data.url} over limit: ${data.size}`, 'max-size');
-				body.destroy(err);
-				throw err;
-			}
-
-			accumBytes += chunk.length;
-			accum.push(chunk);
-		}
-	} catch (error) {
-		if (error instanceof FetchBaseError) {
-			throw error;
-		} else {
-			// Other errors, such as incorrect content-encoding
-			throw new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, 'system', error);
-		}
-	}
-
-	if (body.readableEnded === true || body._readableState.ended === true) {
-		try {
-			if (accum.every(c => typeof c === 'string')) {
-				return Buffer.from(accum.join(''));
-			}
-
-			return Buffer.concat(accum, accumBytes);
-		} catch (error) {
-			throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, 'system', error);
-		}
-	} else {
-		throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
-	}
-}
-
-/**
- * Clone body given Res/Req instance
- *
- * @param   Mixed   instance       Response or Request instance
- * @param   String  highWaterMark  highWaterMark for both PassThrough body streams
- * @return  Mixed
- */
-const clone = (instance, highWaterMark) => {
-	let p1;
-	let p2;
-	let {body} = instance;
-
-	// Don't allow cloning a used body
-	if (instance.bodyUsed) {
-		throw new Error('cannot clone body after it is used');
-	}
-
-	// Check that body is a stream and not form-data object
-	// note: we can't clone the form-data object without having it as a dependency
-	if ((body instanceof Stream) && (typeof body.getBoundary !== 'function')) {
-		// Tee instance body
-		p1 = new PassThrough({highWaterMark});
-		p2 = new PassThrough({highWaterMark});
-		body.pipe(p1);
-		body.pipe(p2);
-		// Set instance body to teed body and return the other teed body
-		instance[INTERNALS$2].body = p1;
-		body = p2;
-	}
-
-	return body;
-};
-
-/**
- * Performs the operation "extract a `Content-Type` value from |object|" as
- * specified in the specification:
- * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
- *
- * This function assumes that instance.body is present.
- *
- * @param {any} body Any options.body input
- * @returns {string | null}
- */
-const extractContentType = (body, request) => {
-	// Body is null or undefined
-	if (body === null) {
-		return null;
-	}
-
-	// Body is string
-	if (typeof body === 'string') {
-		return 'text/plain;charset=UTF-8';
-	}
-
-	// Body is a URLSearchParams
-	if (isURLSearchParameters(body)) {
-		return 'application/x-www-form-urlencoded;charset=UTF-8';
-	}
-
-	// Body is blob
-	if (isBlob(body)) {
-		return body.type || null;
-	}
-
-	// Body is a Buffer (Buffer, ArrayBuffer or ArrayBufferView)
-	if (Buffer.isBuffer(body) || types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
-		return null;
-	}
-
-	// Detect form data input from form-data module
-	if (body && typeof body.getBoundary === 'function') {
-		return `multipart/form-data;boundary=${body.getBoundary()}`;
-	}
-
-	if (isFormData(body)) {
-		return `multipart/form-data; boundary=${request[INTERNALS$2].boundary}`;
-	}
-
-	// Body is stream - can't really do much about this
-	if (body instanceof Stream) {
-		return null;
-	}
-
-	// Body constructor defaults other things to string
-	return 'text/plain;charset=UTF-8';
-};
-
-/**
- * The Fetch Standard treats this as if "total bytes" is a property on the body.
- * For us, we have to explicitly get it with a function.
- *
- * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
- *
- * @param {any} obj.body Body object from the Body instance.
- * @returns {number | null}
- */
-const getTotalBytes = request => {
-	const {body} = request;
-
-	// Body is null or undefined
-	if (body === null) {
-		return 0;
-	}
-
-	// Body is Blob
-	if (isBlob(body)) {
-		return body.size;
-	}
-
-	// Body is Buffer
-	if (Buffer.isBuffer(body)) {
-		return body.length;
-	}
-
-	// Detect form data input from form-data module
-	if (body && typeof body.getLengthSync === 'function') {
-		return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
-	}
-
-	// Body is a spec-compliant form-data
-	if (isFormData(body)) {
-		return getFormDataLength(request[INTERNALS$2].boundary);
-	}
-
-	// Body is stream
-	return null;
-};
-
-/**
- * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
- *
- * @param {Stream.Writable} dest The stream to write to.
- * @param obj.body Body object from the Body instance.
- * @returns {void}
- */
-const writeToStream = (dest, {body}) => {
-	if (body === null) {
-		// Body is null
-		dest.end();
-	} else if (isBlob(body)) {
-		// Body is Blob
-		body.stream().pipe(dest);
-	} else if (Buffer.isBuffer(body)) {
-		// Body is buffer
-		dest.write(body);
-		dest.end();
-	} else {
-		// Body is stream
-		body.pipe(dest);
-	}
-};
-
-/**
- * Headers.js
- *
- * Headers class offers convenient helpers
- */
-
-const validateHeaderName = typeof http.validateHeaderName === 'function' ?
-	http.validateHeaderName :
-	name => {
-		if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
-			const err = new TypeError(`Header name must be a valid HTTP token [${name}]`);
-			Object.defineProperty(err, 'code', {value: 'ERR_INVALID_HTTP_TOKEN'});
-			throw err;
-		}
-	};
-
-const validateHeaderValue = typeof http.validateHeaderValue === 'function' ?
-	http.validateHeaderValue :
-	(name, value) => {
-		if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
-			const err = new TypeError(`Invalid character in header content ["${name}"]`);
-			Object.defineProperty(err, 'code', {value: 'ERR_INVALID_CHAR'});
-			throw err;
-		}
-	};
-
-/**
- * @typedef {Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>} HeadersInit
- */
-
-/**
- * This Fetch API interface allows you to perform various actions on HTTP request and response headers.
- * These actions include retrieving, setting, adding to, and removing.
- * A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.
- * You can add to this using methods like append() (see Examples.)
- * In all methods of this interface, header names are matched by case-insensitive byte sequence.
- *
- */
-class Headers extends URLSearchParams {
-	/**
-	 * Headers class
-	 *
-	 * @constructor
-	 * @param {HeadersInit} [init] - Response headers
-	 */
-	constructor(init) {
-		// Validate and normalize init object in [name, value(s)][]
-		/** @type {string[][]} */
-		let result = [];
-		if (init instanceof Headers) {
-			const raw = init.raw();
-			for (const [name, values] of Object.entries(raw)) {
-				result.push(...values.map(value => [name, value]));
-			}
-		} else if (init == null) ; else if (typeof init === 'object' && !types.isBoxedPrimitive(init)) {
-			const method = init[Symbol.iterator];
-			// eslint-disable-next-line no-eq-null, eqeqeq
-			if (method == null) {
-				// Record<ByteString, ByteString>
-				result.push(...Object.entries(init));
-			} else {
-				if (typeof method !== 'function') {
-					throw new TypeError('Header pairs must be iterable');
-				}
-
-				// Sequence<sequence<ByteString>>
-				// Note: per spec we have to first exhaust the lists then process them
-				result = [...init]
-					.map(pair => {
-						if (
-							typeof pair !== 'object' || types.isBoxedPrimitive(pair)
-						) {
-							throw new TypeError('Each header pair must be an iterable object');
-						}
-
-						return [...pair];
-					}).map(pair => {
-						if (pair.length !== 2) {
-							throw new TypeError('Each header pair must be a name/value tuple');
-						}
-
-						return [...pair];
-					});
-			}
-		} else {
-			throw new TypeError('Failed to construct \'Headers\': The provided value is not of type \'(sequence<sequence<ByteString>> or record<ByteString, ByteString>)');
-		}
-
-		// Validate and lowercase
-		result =
-			result.length > 0 ?
-				result.map(([name, value]) => {
-					validateHeaderName(name);
-					validateHeaderValue(name, String(value));
-					return [String(name).toLowerCase(), String(value)];
-				}) :
-				undefined;
-
-		super(result);
-
-		// Returning a Proxy that will lowercase key names, validate parameters and sort keys
-		// eslint-disable-next-line no-constructor-return
-		return new Proxy(this, {
-			get(target, p, receiver) {
-				switch (p) {
-					case 'append':
-					case 'set':
-						return (name, value) => {
-							validateHeaderName(name);
-							validateHeaderValue(name, String(value));
-							return URLSearchParams.prototype[p].call(
-								receiver,
-								String(name).toLowerCase(),
-								String(value)
-							);
-						};
-
-					case 'delete':
-					case 'has':
-					case 'getAll':
-						return name => {
-							validateHeaderName(name);
-							return URLSearchParams.prototype[p].call(
-								receiver,
-								String(name).toLowerCase()
-							);
-						};
-
-					case 'keys':
-						return () => {
-							target.sort();
-							return new Set(URLSearchParams.prototype.keys.call(target)).keys();
-						};
-
-					default:
-						return Reflect.get(target, p, receiver);
-				}
-			}
-			/* c8 ignore next */
-		});
-	}
-
-	get [Symbol.toStringTag]() {
-		return this.constructor.name;
-	}
-
-	toString() {
-		return Object.prototype.toString.call(this);
-	}
-
-	get(name) {
-		const values = this.getAll(name);
-		if (values.length === 0) {
-			return null;
-		}
-
-		let value = values.join(', ');
-		if (/^content-encoding$/i.test(name)) {
-			value = value.toLowerCase();
-		}
-
-		return value;
-	}
-
-	forEach(callback) {
-		for (const name of this.keys()) {
-			callback(this.get(name), name);
-		}
-	}
-
-	* values() {
-		for (const name of this.keys()) {
-			yield this.get(name);
-		}
-	}
-
-	/**
-	 * @type {() => IterableIterator<[string, string]>}
-	 */
-	* entries() {
-		for (const name of this.keys()) {
-			yield [name, this.get(name)];
-		}
-	}
-
-	[Symbol.iterator]() {
-		return this.entries();
-	}
-
-	/**
-	 * Node-fetch non-spec method
-	 * returning all headers and their values as array
-	 * @returns {Record<string, string[]>}
-	 */
-	raw() {
-		return [...this.keys()].reduce((result, key) => {
-			result[key] = this.getAll(key);
-			return result;
-		}, {});
-	}
-
-	/**
-	 * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
-	 */
-	[Symbol.for('nodejs.util.inspect.custom')]() {
-		return [...this.keys()].reduce((result, key) => {
-			const values = this.getAll(key);
-			// Http.request() only supports string as Host header.
-			// This hack makes specifying custom Host header possible.
-			if (key === 'host') {
-				result[key] = values[0];
-			} else {
-				result[key] = values.length > 1 ? values : values[0];
-			}
-
-			return result;
-		}, {});
-	}
-}
-
-/**
- * Re-shaping object for Web IDL tests
- * Only need to do it for overridden methods
- */
-Object.defineProperties(
-	Headers.prototype,
-	['get', 'entries', 'forEach', 'values'].reduce((result, property) => {
-		result[property] = {enumerable: true};
-		return result;
-	}, {})
-);
-
-/**
- * Create a Headers object from an http.IncomingMessage.rawHeaders, ignoring those that do
- * not conform to HTTP grammar productions.
- * @param {import('http').IncomingMessage['rawHeaders']} headers
- */
-function fromRawHeaders(headers = []) {
-	return new Headers(
-		headers
-			// Split into pairs
-			.reduce((result, value, index, array) => {
-				if (index % 2 === 0) {
-					result.push(array.slice(index, index + 2));
-				}
-
-				return result;
-			}, [])
-			.filter(([name, value]) => {
-				try {
-					validateHeaderName(name);
-					validateHeaderValue(name, String(value));
-					return true;
-				} catch {
-					return false;
-				}
-			})
-
-	);
-}
-
-const redirectStatus = new Set([301, 302, 303, 307, 308]);
-
-/**
- * Redirect code matching
- *
- * @param {number} code - Status code
- * @return {boolean}
- */
-const isRedirect = code => {
-	return redirectStatus.has(code);
-};
-
-/**
- * Response.js
- *
- * Response class provides content decoding
- */
-
-const INTERNALS$1 = Symbol('Response internals');
-
-/**
- * Response class
- *
- * @param   Stream  body  Readable stream
- * @param   Object  opts  Response options
- * @return  Void
- */
-class Response extends Body {
-	constructor(body = null, options = {}) {
-		super(body, options);
-
-		const status = options.status || 200;
-		const headers = new Headers(options.headers);
-
-		if (body !== null && !headers.has('Content-Type')) {
-			const contentType = extractContentType(body);
-			if (contentType) {
-				headers.append('Content-Type', contentType);
-			}
-		}
-
-		this[INTERNALS$1] = {
-			url: options.url,
-			status,
-			statusText: options.statusText || '',
-			headers,
-			counter: options.counter,
-			highWaterMark: options.highWaterMark
-		};
-	}
-
-	get url() {
-		return this[INTERNALS$1].url || '';
-	}
-
-	get status() {
-		return this[INTERNALS$1].status;
-	}
-
-	/**
-	 * Convenience property representing if the request ended normally
-	 */
-	get ok() {
-		return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
-	}
-
-	get redirected() {
-		return this[INTERNALS$1].counter > 0;
-	}
-
-	get statusText() {
-		return this[INTERNALS$1].statusText;
-	}
-
-	get headers() {
-		return this[INTERNALS$1].headers;
-	}
-
-	get highWaterMark() {
-		return this[INTERNALS$1].highWaterMark;
-	}
-
-	/**
-	 * Clone this response
-	 *
-	 * @return  Response
-	 */
-	clone() {
-		return new Response(clone(this, this.highWaterMark), {
-			url: this.url,
-			status: this.status,
-			statusText: this.statusText,
-			headers: this.headers,
-			ok: this.ok,
-			redirected: this.redirected,
-			size: this.size
-		});
-	}
-
-	/**
-	 * @param {string} url    The URL that the new response is to originate from.
-	 * @param {number} status An optional status code for the response (e.g., 302.)
-	 * @returns {Response}    A Response object.
-	 */
-	static redirect(url, status = 302) {
-		if (!isRedirect(status)) {
-			throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
-		}
-
-		return new Response(null, {
-			headers: {
-				location: new URL(url).toString()
-			},
-			status
-		});
-	}
-
-	get [Symbol.toStringTag]() {
-		return 'Response';
-	}
-}
-
-Object.defineProperties(Response.prototype, {
-	url: {enumerable: true},
-	status: {enumerable: true},
-	ok: {enumerable: true},
-	redirected: {enumerable: true},
-	statusText: {enumerable: true},
-	headers: {enumerable: true},
-	clone: {enumerable: true}
-});
-
-const getSearch = parsedURL => {
-	if (parsedURL.search) {
-		return parsedURL.search;
-	}
-
-	const lastOffset = parsedURL.href.length - 1;
-	const hash = parsedURL.hash || (parsedURL.href[lastOffset] === '#' ? '#' : '');
-	return parsedURL.href[lastOffset - hash.length] === '?' ? '?' : '';
-};
-
-const INTERNALS = Symbol('Request internals');
-
-/**
- * Check if `obj` is an instance of Request.
- *
- * @param  {*} obj
- * @return {boolean}
- */
-const isRequest = object => {
-	return (
-		typeof object === 'object' &&
-		typeof object[INTERNALS] === 'object'
-	);
-};
-
-/**
- * Request class
- *
- * @param   Mixed   input  Url or Request instance
- * @param   Object  init   Custom options
- * @return  Void
- */
-class Request extends Body {
-	constructor(input, init = {}) {
-		let parsedURL;
-
-		// Normalize input and force URL to be encoded as UTF-8 (https://github.com/node-fetch/node-fetch/issues/245)
-		if (isRequest(input)) {
-			parsedURL = new URL(input.url);
-		} else {
-			parsedURL = new URL(input);
-			input = {};
-		}
-
-		let method = init.method || input.method || 'GET';
-		method = method.toUpperCase();
-
-		// eslint-disable-next-line no-eq-null, eqeqeq
-		if (((init.body != null || isRequest(input)) && input.body !== null) &&
-			(method === 'GET' || method === 'HEAD')) {
-			throw new TypeError('Request with GET/HEAD method cannot have body');
-		}
-
-		const inputBody = init.body ?
-			init.body :
-			(isRequest(input) && input.body !== null ?
-				clone(input) :
-				null);
-
-		super(inputBody, {
-			size: init.size || input.size || 0
-		});
-
-		const headers = new Headers(init.headers || input.headers || {});
-
-		if (inputBody !== null && !headers.has('Content-Type')) {
-			const contentType = extractContentType(inputBody, this);
-			if (contentType) {
-				headers.append('Content-Type', contentType);
-			}
-		}
-
-		let signal = isRequest(input) ?
-			input.signal :
-			null;
-		if ('signal' in init) {
-			signal = init.signal;
-		}
-
-		if (signal !== null && !isAbortSignal(signal)) {
-			throw new TypeError('Expected signal to be an instanceof AbortSignal');
-		}
-
-		this[INTERNALS] = {
-			method,
-			redirect: init.redirect || input.redirect || 'follow',
-			headers,
-			parsedURL,
-			signal
-		};
-
-		// Node-fetch-only options
-		this.follow = init.follow === undefined ? (input.follow === undefined ? 20 : input.follow) : init.follow;
-		this.compress = init.compress === undefined ? (input.compress === undefined ? true : input.compress) : init.compress;
-		this.counter = init.counter || input.counter || 0;
-		this.agent = init.agent || input.agent;
-		this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
-		this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
-	}
-
-	get method() {
-		return this[INTERNALS].method;
-	}
-
-	get url() {
-		return format(this[INTERNALS].parsedURL);
-	}
-
-	get headers() {
-		return this[INTERNALS].headers;
-	}
-
-	get redirect() {
-		return this[INTERNALS].redirect;
-	}
-
-	get signal() {
-		return this[INTERNALS].signal;
-	}
-
-	/**
-	 * Clone this request
-	 *
-	 * @return  Request
-	 */
-	clone() {
-		return new Request(this);
-	}
-
-	get [Symbol.toStringTag]() {
-		return 'Request';
-	}
-}
-
-Object.defineProperties(Request.prototype, {
-	method: {enumerable: true},
-	url: {enumerable: true},
-	headers: {enumerable: true},
-	redirect: {enumerable: true},
-	clone: {enumerable: true},
-	signal: {enumerable: true}
-});
-
-/**
- * Convert a Request to Node.js http request options.
- *
- * @param   Request  A Request instance
- * @return  Object   The options object to be passed to http.request
- */
-const getNodeRequestOptions = request => {
-	const {parsedURL} = request[INTERNALS];
-	const headers = new Headers(request[INTERNALS].headers);
-
-	// Fetch step 1.3
-	if (!headers.has('Accept')) {
-		headers.set('Accept', '*/*');
-	}
-
-	// HTTP-network-or-cache fetch steps 2.4-2.7
-	let contentLengthValue = null;
-	if (request.body === null && /^(post|put)$/i.test(request.method)) {
-		contentLengthValue = '0';
-	}
-
-	if (request.body !== null) {
-		const totalBytes = getTotalBytes(request);
-		// Set Content-Length if totalBytes is a number (that is not NaN)
-		if (typeof totalBytes === 'number' && !Number.isNaN(totalBytes)) {
-			contentLengthValue = String(totalBytes);
-		}
-	}
-
-	if (contentLengthValue) {
-		headers.set('Content-Length', contentLengthValue);
-	}
-
-	// HTTP-network-or-cache fetch step 2.11
-	if (!headers.has('User-Agent')) {
-		headers.set('User-Agent', 'node-fetch');
-	}
-
-	// HTTP-network-or-cache fetch step 2.15
-	if (request.compress && !headers.has('Accept-Encoding')) {
-		headers.set('Accept-Encoding', 'gzip,deflate,br');
-	}
-
-	let {agent} = request;
-	if (typeof agent === 'function') {
-		agent = agent(parsedURL);
-	}
-
-	if (!headers.has('Connection') && !agent) {
-		headers.set('Connection', 'close');
-	}
-
-	// HTTP-network fetch step 4.2
-	// chunked encoding is handled by Node.js
-
-	const search = getSearch(parsedURL);
-
-	// Manually spread the URL object instead of spread syntax
-	const requestOptions = {
-		path: parsedURL.pathname + search,
-		pathname: parsedURL.pathname,
-		hostname: parsedURL.hostname,
-		protocol: parsedURL.protocol,
-		port: parsedURL.port,
-		hash: parsedURL.hash,
-		search: parsedURL.search,
-		query: parsedURL.query,
-		href: parsedURL.href,
-		method: request.method,
-		headers: headers[Symbol.for('nodejs.util.inspect.custom')](),
-		insecureHTTPParser: request.insecureHTTPParser,
-		agent
-	};
-
-	return requestOptions;
-};
-
-/**
- * AbortError interface for cancelled requests
- */
-class AbortError extends FetchBaseError {
-	constructor(message, type = 'aborted') {
-		super(message, type);
-	}
-}
-
-/**
- * Index.js
- *
- * a request API compatible with window.fetch
- *
- * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
- */
-
-const supportedSchemas = new Set(['data:', 'http:', 'https:']);
-
-/**
- * Fetch function
- *
- * @param   {string | URL | import('./request').default} url - Absolute url or Request instance
- * @param   {*} [options_] - Fetch options
- * @return  {Promise<import('./response').default>}
- */
-async function fetch(url, options_) {
-	return new Promise((resolve, reject) => {
-		// Build request object
-		const request = new Request(url, options_);
-		const options = getNodeRequestOptions(request);
-		if (!supportedSchemas.has(options.protocol)) {
-			throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${options.protocol.replace(/:$/, '')}" is not supported.`);
-		}
-
-		if (options.protocol === 'data:') {
-			const data = src(request.url);
-			const response = new Response(data, {headers: {'Content-Type': data.typeFull}});
-			resolve(response);
-			return;
-		}
-
-		// Wrap http.request into fetch
-		const send = (options.protocol === 'https:' ? https : http).request;
-		const {signal} = request;
-		let response = null;
-
-		const abort = () => {
-			const error = new AbortError('The operation was aborted.');
-			reject(error);
-			if (request.body && request.body instanceof Stream.Readable) {
-				request.body.destroy(error);
-			}
-
-			if (!response || !response.body) {
-				return;
-			}
-
-			response.body.emit('error', error);
-		};
-
-		if (signal && signal.aborted) {
-			abort();
-			return;
-		}
-
-		const abortAndFinalize = () => {
-			abort();
-			finalize();
-		};
-
-		// Send request
-		const request_ = send(options);
-
-		if (signal) {
-			signal.addEventListener('abort', abortAndFinalize);
-		}
-
-		const finalize = () => {
-			request_.abort();
-			if (signal) {
-				signal.removeEventListener('abort', abortAndFinalize);
-			}
-		};
-
-		request_.on('error', err => {
-			reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
-			finalize();
-		});
-
-		request_.on('response', response_ => {
-			request_.setTimeout(0);
-			const headers = fromRawHeaders(response_.rawHeaders);
-
-			// HTTP fetch step 5
-			if (isRedirect(response_.statusCode)) {
-				// HTTP fetch step 5.2
-				const location = headers.get('Location');
-
-				// HTTP fetch step 5.3
-				const locationURL = location === null ? null : new URL(location, request.url);
-
-				// HTTP fetch step 5.5
-				switch (request.redirect) {
-					case 'error':
-						reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
-						finalize();
-						return;
-					case 'manual':
-						// Node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
-						if (locationURL !== null) {
-							// Handle corrupted header
-							try {
-								headers.set('Location', locationURL);
-								/* c8 ignore next 3 */
-							} catch (error) {
-								reject(error);
-							}
-						}
-
-						break;
-					case 'follow': {
-						// HTTP-redirect fetch step 2
-						if (locationURL === null) {
-							break;
-						}
-
-						// HTTP-redirect fetch step 5
-						if (request.counter >= request.follow) {
-							reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
-							finalize();
-							return;
-						}
-
-						// HTTP-redirect fetch step 6 (counter increment)
-						// Create a new Request object.
-						const requestOptions = {
-							headers: new Headers(request.headers),
-							follow: request.follow,
-							counter: request.counter + 1,
-							agent: request.agent,
-							compress: request.compress,
-							method: request.method,
-							body: request.body,
-							signal: request.signal,
-							size: request.size
-						};
-
-						// HTTP-redirect fetch step 9
-						if (response_.statusCode !== 303 && request.body && options_.body instanceof Stream.Readable) {
-							reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
-							finalize();
-							return;
-						}
-
-						// HTTP-redirect fetch step 11
-						if (response_.statusCode === 303 || ((response_.statusCode === 301 || response_.statusCode === 302) && request.method === 'POST')) {
-							requestOptions.method = 'GET';
-							requestOptions.body = undefined;
-							requestOptions.headers.delete('content-length');
-						}
-
-						// HTTP-redirect fetch step 15
-						resolve(fetch(new Request(locationURL, requestOptions)));
-						finalize();
-						return;
-					}
-					// Do nothing
-				}
-			}
-
-			// Prepare response
-			response_.once('end', () => {
-				if (signal) {
-					signal.removeEventListener('abort', abortAndFinalize);
-				}
-			});
-
-			let body = pipeline(response_, new PassThrough(), error => {
-				reject(error);
-			});
-			// see https://github.com/nodejs/node/pull/29376
-			if (process.version < 'v12.10') {
-				response_.on('aborted', abortAndFinalize);
-			}
-
-			const responseOptions = {
-				url: request.url,
-				status: response_.statusCode,
-				statusText: response_.statusMessage,
-				headers,
-				size: request.size,
-				counter: request.counter,
-				highWaterMark: request.highWaterMark
-			};
-
-			// HTTP-network fetch step 12.1.1.3
-			const codings = headers.get('Content-Encoding');
-
-			// HTTP-network fetch step 12.1.1.4: handle content codings
-
-			// in following scenarios we ignore compression support
-			// 1. compression support is disabled
-			// 2. HEAD request
-			// 3. no Content-Encoding header
-			// 4. no content response (204)
-			// 5. content not modified response (304)
-			if (!request.compress || request.method === 'HEAD' || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
-				response = new Response(body, responseOptions);
-				resolve(response);
-				return;
-			}
-
-			// For Node v6+
-			// Be less strict when decoding compressed responses, since sometimes
-			// servers send slightly invalid responses that are still accepted
-			// by common browsers.
-			// Always using Z_SYNC_FLUSH is what cURL does.
-			const zlibOptions = {
-				flush: zlib.Z_SYNC_FLUSH,
-				finishFlush: zlib.Z_SYNC_FLUSH
-			};
-
-			// For gzip
-			if (codings === 'gzip' || codings === 'x-gzip') {
-				body = pipeline(body, zlib.createGunzip(zlibOptions), error => {
-					reject(error);
-				});
-				response = new Response(body, responseOptions);
-				resolve(response);
-				return;
-			}
-
-			// For deflate
-			if (codings === 'deflate' || codings === 'x-deflate') {
-				// Handle the infamous raw deflate response from old servers
-				// a hack for old IIS and Apache servers
-				const raw = pipeline(response_, new PassThrough(), error => {
-					reject(error);
-				});
-				raw.once('data', chunk => {
-					// See http://stackoverflow.com/questions/37519828
-					if ((chunk[0] & 0x0F) === 0x08) {
-						body = pipeline(body, zlib.createInflate(), error => {
-							reject(error);
-						});
-					} else {
-						body = pipeline(body, zlib.createInflateRaw(), error => {
-							reject(error);
-						});
-					}
-
-					response = new Response(body, responseOptions);
-					resolve(response);
-				});
-				return;
-			}
-
-			// For br
-			if (codings === 'br') {
-				body = pipeline(body, zlib.createBrotliDecompress(), error => {
-					reject(error);
-				});
-				response = new Response(body, responseOptions);
-				resolve(response);
-				return;
-			}
-
-			// Otherwise, use response as-is
-			response = new Response(body, responseOptions);
-			resolve(response);
-		});
-
-		writeToStream(request_, request);
-	});
-}
-
-function noop() { }
-function safe_not_equal(a, b) {
-    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
-}
-
-console.log('>>> module');
-
-const subscriber_queue = [];
-/**
- * Create a `Writable` store that allows both updating and reading by subscription.
- * @param {*=}value initial value
- * @param {StartStopNotifier=}start start and stop notifications for subscriptions
- */
-function writable(value, start = noop) {
-    let stop;
-    const subscribers = [];
-    function set(new_value) {
-        if (safe_not_equal(value, new_value)) {
-            value = new_value;
-            if (stop) { // store is ready
-                const run_queue = !subscriber_queue.length;
-                for (let i = 0; i < subscribers.length; i += 1) {
-                    const s = subscribers[i];
-                    s[1]();
-                    subscriber_queue.push(s, value);
-                }
-                if (run_queue) {
-                    for (let i = 0; i < subscriber_queue.length; i += 2) {
-                        subscriber_queue[i][0](subscriber_queue[i + 1]);
-                    }
-                    subscriber_queue.length = 0;
-                }
-            }
-        }
-    }
-    function update(fn) {
-        set(fn(value));
-    }
-    function subscribe(run, invalidate = noop) {
-        const subscriber = [run, invalidate];
-        subscribers.push(subscriber);
-        if (subscribers.length === 1) {
-            stop = start(set) || noop;
-        }
-        run(value);
-        return () => {
-            const index = subscribers.indexOf(subscriber);
-            if (index !== -1) {
-                subscribers.splice(index, 1);
-            }
-            if (subscribers.length === 0) {
-                stop();
-                stop = null;
-            }
-        };
-    }
-    return { set, update, subscribe };
-}
-
-/**
- * @param {import('../types').LoadResult} loaded
- * @returns {import('../types').LoadResult}
- */
-function normalize(loaded) {
-	// TODO should this behaviour be dev-only?
-
-	if (loaded.error) {
-		const error = typeof loaded.error === 'string' ? new Error(loaded.error) : loaded.error;
-		const status = loaded.status;
-
-		if (!(error instanceof Error)) {
-			return {
-				status: 500,
-				error: new Error(
-					`"error" property returned from load() must be a string or instance of Error, received type "${typeof error}"`
-				)
-			};
-		}
-
-		if (!status || status < 400 || status > 599) {
-			console.warn('"error" returned from load() without a valid status code — defaulting to 500');
-			return { status: 500, error };
-		}
-
-		return { status, error };
-	}
-
-	if (loaded.redirect) {
-		if (!loaded.status || Math.floor(loaded.status / 100) !== 3) {
-			return {
-				status: 500,
-				error: new Error(
-					'"redirect" property returned from load() must be accompanied by a 3xx status code'
-				)
-			};
-		}
-
-		if (typeof loaded.redirect !== 'string') {
-			return {
-				status: 500,
-				error: new Error('"redirect" property returned from load() must be a string')
-			};
-		}
-	}
-
-	return loaded;
-}
-
-/**
- * @param {{
- *   request: import('../../types').Request;
- *   options: import('../../types').RenderOptions;
- *   $session: any;
- *   route: import('../../types').Page;
- *   status: number;
- *   error: Error
- * }} opts
- * @returns {Promise<import('../../types').Response>}
- */
-async function get_response({ request, options, $session, route, status = 200, error }) {
-	const host = options.host || request.headers[options.host_header];
-
-	/** @type {Record<string, import('../../types').Response>} */
-	const dependencies = {};
-
-	const serialized_session = try_serialize($session, (error) => {
-		throw new Error(`Failed to serialize session data: ${error.message}`);
-	});
-
-	/** @type {Array<{ url: string, payload: string }>} */
-	const serialized_data = [];
-
-	const match = route && route.pattern.exec(request.path);
-	const params = route && route.params(match);
-
-	const page = {
-		host,
-		path: request.path,
-		query: request.query,
-		params
-	};
-
-	let uses_credentials = false;
-
-	/**
-	 * @param {string} url
-	 * @param {RequestInit} opts
-	 */
-	const fetcher = async (url, opts = {}) => {
-		if (options.local && url.startsWith(options.paths.assets)) {
-			// when running `start`, or prerendering, `assets` should be
-			// config.kit.paths.assets, but we should still be able to fetch
-			// assets directly from `static`
-			url = url.replace(options.paths.assets, '');
-		}
-
-		const parsed = parse(url);
-
-		if (opts.credentials !== 'omit') {
-			uses_credentials = true;
-		}
-
-		let response;
-
-		if (parsed.protocol) {
-			// external fetch
-			response = await fetch(parsed.href, opts);
-		} else {
-			// otherwise we're dealing with an internal fetch
-			const resolved = resolve(request.path, parsed.pathname);
-
-			// is this a request for a static asset?
-			const filename = resolved.slice(1);
-			const filename_html = `${filename}/index.html`;
-			const asset = options.manifest.assets.find(
-				(d) => d.file === filename || d.file === filename_html
-			);
-
-			if (asset) {
-				if (options.get_static_file) {
-					response = new Response(options.get_static_file(asset.file), {
-						headers: {
-							'content-type': asset.type
-						}
-					});
-				} else {
-					// TODO we need to know what protocol to use
-					response = await fetch(`http://${page.host}/${asset.file}`, opts);
-				}
-			}
-
-			if (!response) {
-				const rendered = await ssr(
-					{
-						host: request.host,
-						method: opts.method || 'GET',
-						headers: opts.headers || {}, // TODO inject credentials...
-						path: resolved,
-						body: opts.body,
-						query: new URLSearchParams$1(parsed.query || '')
-					},
-					{
-						...options,
-						fetched: url
-					}
-				);
-
-				if (rendered) {
-					// TODO this is primarily for the benefit of the static case,
-					// but could it be used elsewhere?
-					dependencies[resolved] = rendered;
-
-					response = new Response(rendered.body, {
-						status: rendered.status,
-						headers: rendered.headers
-					});
-				}
-			}
-		}
-
-		if (response) {
-			const clone = response.clone();
-
-			/** @type {import('../../types').Headers} */
-			const headers = {};
-			clone.headers.forEach((value, key) => {
-				if (key !== 'etag') headers[key] = value;
-			});
-
-			const payload = JSON.stringify({
-				status: clone.status,
-				statusText: clone.statusText,
-				headers,
-				body: await clone.text() // TODO handle binary data
-			});
-
-			// TODO i guess we need to sanitize/escape this... somehow?
-			serialized_data.push({ url, payload });
-
-			return response;
-		}
-
-		return new Response('Not found', {
-			status: 404
-		});
-	};
-
-	const parts = error ? [options.manifest.layout] : [options.manifest.layout, ...route.parts];
-
-	const component_promises = parts.map((loader) => loader());
-	const components = [];
-	const props_promises = [];
-
-	let context = {};
-	let maxage;
-
-	for (let i = 0; i < component_promises.length; i += 1) {
-		let loaded;
-
-		try {
-			const mod = await component_promises[i];
-			components[i] = mod.default;
-
-			if (options.only_prerender && !mod.prerender) {
-				return;
-			}
-
-			if (mod.preload) {
-				throw new Error(
-					'preload has been deprecated in favour of load. Please consult the documentation: https://kit.svelte.dev/docs#load'
-				);
-			}
-
-			loaded =
-				mod.load &&
-				(await mod.load.call(null, {
-					page,
-					get session() {
-						uses_credentials = true;
-						return $session;
-					},
-					fetch: fetcher,
-					context: { ...context }
-				}));
-		} catch (e) {
-			// if load fails when we're already rendering the
-			// error page, there's not a lot we can do
-			if (error) throw e;
-
-			loaded = { error: e, status: 500 };
-		}
-
-		if (loaded) {
-			loaded = normalize(loaded);
-
-			// TODO there's some logic that's duplicated in the client runtime,
-			// it would be nice to DRY it out if possible
-			if (loaded.error) {
-				return await get_response({
-					request,
-					options,
-					$session,
-					route,
-					status: loaded.status,
-					error: loaded.error
-				});
-			}
-
-			if (loaded.redirect) {
-				return {
-					status: loaded.status,
-					headers: {
-						location: loaded.redirect
-					}
-				};
-			}
-
-			if (loaded.context) {
-				context = {
-					...context,
-					...loaded.context
-				};
-			}
-
-			maxage = loaded.maxage || 0;
-
-			props_promises[i] = loaded.props;
-		}
-	}
-
-	const session = writable($session);
-	let session_tracking_active = false;
-	const unsubscribe = session.subscribe(() => {
-		if (session_tracking_active) uses_credentials = true;
-	});
-	session_tracking_active = true;
-
-	if (error) {
-		if (options.dev) {
-			error.stack = await options.get_stack(error);
-		} else {
-			// remove error.stack in production
-			error.stack = String(error);
-		}
-	}
-
-	/** @type {Record<string, any>} */
-	const props = {
-		status,
-		error,
-		stores: {
-			page: writable(null),
-			navigating: writable(null),
-			session
-		},
-		page,
-		components
-	};
-
-	// leveln (instead of levels[n]) makes it easy to avoid
-	// unnecessary updates for layout components
-	for (let i = 0; i < props_promises.length; i += 1) {
-		props[`props_${i}`] = await props_promises[i];
-	}
-
-	let rendered;
-
-	try {
-		rendered = options.root.render(props);
-	} catch (e) {
-		if (error) throw e;
-
-		return await get_response({
-			request,
-			options,
-			$session,
-			route,
-			status: 500,
-			error: e
-		});
-	}
-
-	unsubscribe();
-
-	// TODO all the `route &&` stuff is messy
-	const js_deps = route ? route.js : [];
-	const css_deps = route ? route.css : [];
-	const style = route ? route.style : '';
-
-	const s = JSON.stringify;
-
-	// TODO strip the AMP stuff out of the build if not relevant
-	const links = options.amp
-		? `<style amp-custom>${
-				style || (await Promise.all(css_deps.map((dep) => options.get_amp_css(dep)))).join('\n')
-		  }</style>`
-		: [
-				...js_deps.map((dep) => `<link rel="modulepreload" href="${dep}">`),
-				...css_deps.map((dep) => `<link rel="stylesheet" href="${dep}">`)
-		  ].join('\n\t\t\t');
-
-	const init = options.amp
-		? `
-		<style amp-boilerplate>body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}</style>
-		<noscript><style amp-boilerplate>body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}</style></noscript>
-		<script async src="https://cdn.ampproject.org/v0.js"></script>`
-		: `
-		<script type="module">
-			import { start } from ${s(options.entry)};
-			${options.start_global ? `window.${options.start_global} = () => ` : ''}start({
-				target: ${options.target ? `document.querySelector(${s(options.target)})` : 'document.body'},
-				host: ${host ? s(host) : 'location.host'},
-				paths: ${s(options.paths)},
-				status: ${status},
-				error: ${serialize_error(error)},
-				session: ${serialized_session}
-			});
-		</script>`;
-
-	const head = [
-		rendered.head,
-		options.amp ? '' : `<style data-svelte>${style}</style>`,
-		links,
-		init
-	].join('\n\n');
-
-	const body = options.amp
-		? rendered.html
-		: `${rendered.html}
-
-			${serialized_data
-				.map(({ url, payload }) => `<script type="svelte-data" url="${url}">${payload}</script>`)
-				.join('\n\n\t\t\t')}
-		`.replace(/^\t{2}/gm, '');
-
-	/** @type {import('../../types').Headers} */
-	const headers = {
-		'content-type': 'text/html'
-	};
-
-	if (maxage) {
-		headers['cache-control'] = `${uses_credentials ? 'private' : 'public'}, max-age=${maxage}`;
-	}
-
-	return {
-		status,
-		headers,
-		body: options.template({ head, body }),
-		dependencies
-	};
-}
-
-/**
- * @param {import('../../types').Request} request
- * @param {any} context
- * @param {import('../../types').RenderOptions} options
- */
-async function render_page(request, context, options) {
-	const route = options.manifest.pages.find((route) => route.pattern.test(request.path));
-
-	const $session = await (options.setup.getSession && options.setup.getSession(context));
-
-	if (!route) {
-		if (options.fetched) {
-			// we came here because of a bad request in a `load` function.
-			// rather than render the error page — which could lead to an
-			// infinite loop, if the `load` belonged to the root layout,
-			// we respond with a bare-bones 500
-			throw new Error(`Bad request in load function: failed to fetch ${options.fetched}`);
-		}
-
-		return await get_response({
-			request,
-			options,
-			$session,
-			route,
-			status: 404,
-			error: new Error(`Not found: ${request.path}`)
-		});
-	}
-
-	return await get_response({
-		request,
-		options,
-		$session,
-		route,
-		status: 200,
-		error: null
-	});
-}
-
-/**
- * @param {any} data
- * @param {(error: Error) => void} [fail]
- */
-function try_serialize(data, fail) {
-	try {
-		return devalue(data);
-	} catch (err) {
-		if (fail) fail(err);
-		return null;
-	}
-}
-
-// Ensure we return something truthy so the client will not re-render the page over the error
-
-/** @param {Error} error */
-function serialize_error(error) {
-	if (!error) return null;
-	let serialized = try_serialize(error);
-	if (!serialized) {
-		const { name, message, stack } = error;
-		serialized = try_serialize({ name, message, stack });
-	}
-	if (!serialized) {
-		serialized = '{}';
-	}
-	return serialized;
-}
-
-/**
- * @param {import('../../types').Request} request
- * @param {*} context // TODO
- * @param {import('../../types').RenderOptions} options
- * @returns {Promise<import('../../types').Response>}
- */
-function render_route(request, context, options) {
-	const route = options.manifest.endpoints.find((route) => route.pattern.test(request.path));
-	if (!route) return null;
-
-	return route.load().then(async (mod) => {
-		const handler = mod[request.method.toLowerCase().replace('delete', 'del')]; // 'delete' is a reserved word
-
-		if (handler) {
-			const match = route.pattern.exec(request.path);
-			const params = route.params(match);
-
-			const response = await handler(
-				{
-					host: options.host || request.headers[options.host_header || 'host'],
-					path: request.path,
-					headers: request.headers,
-					query: request.query,
-					body: request.body,
-					params
-				},
-				context
-			);
-
-			if (typeof response !== 'object' || response.body == null) {
-				return {
-					status: 500,
-					body: `Invalid response from route ${request.path}; ${
-						response.body == null ? 'body is missing' : `expected an object, got ${typeof response}`
-					}`,
-					headers: {}
-				};
-			}
-
-			let { status = 200, body, headers = {} } = response;
-
-			headers = lowercase_keys(headers);
-
-			if (
-				(typeof body === 'object' && !('content-type' in headers)) ||
-				headers['content-type'] === 'application/json'
-			) {
-				headers = { ...headers, 'content-type': 'application/json' };
-				body = JSON.stringify(body);
-			}
-
-			return { status, body, headers };
-		} else {
-			return {
-				status: 501,
-				body: `${request.method} is not implemented for ${request.path}`,
-				headers: {}
-			};
-		}
-	});
-}
-
-/** @param {Record<string, string>} obj */
-function lowercase_keys(obj) {
-	/** @type {Record<string, string>} */
-	const clone = {};
-
-	for (const key in obj) {
-		clone[key.toLowerCase()] = obj[key];
-	}
-
-	return clone;
-}
-
-/** @param {string} body */
-function md5(body) {
-	return createHash('md5').update(body).digest('hex');
-}
-
-/**
- * @param {import('../../types').Request} request
- * @param {import('../../types').RenderOptions} options
- */
-async function ssr(request, options) {
-	if (request.path.endsWith('/') && request.path !== '/') {
-		const q = request.query.toString();
-
-		return {
-			status: 301,
-			headers: {
-				location: request.path.slice(0, -1) + (q ? `?${q}` : '')
-			}
-		};
-	}
-
-	const { context, headers = {} } =
-		(await (options.setup.prepare && options.setup.prepare({ headers: request.headers }))) || {};
-
-	try {
-		const response = await (render_route(request, context, options) ||
-			render_page(request, context, options));
-
-		if (response) {
-			// inject ETags for 200 responses
-			if (response.status === 200) {
-				if (!/(no-store|immutable)/.test(response.headers['cache-control'])) {
-					const etag = `"${md5(response.body)}"`;
-
-					if (request.headers['if-none-match'] === etag) {
-						return {
-							status: 304,
-							headers: {},
-							body: null
-						};
-					}
-
-					response.headers['etag'] = etag;
-				}
-			}
-
-			return {
-				status: response.status,
-				headers: { ...headers, ...response.headers },
-				body: response.body,
-				dependencies: response.dependencies
-			};
-		}
-	} catch (e) {
-		if (e && e.stack) {
-			e.stack = await options.get_stack(e);
-		}
-
-		console.error((e && e.stack) || e);
-
-		return {
-			status: 500,
-			headers,
-			body: options.dev ? e.stack : e.message
-		};
-	}
-}
-
-export { ssr };