private renderDeclarationEnd (
		code: MagicString,
		separatorString: string,
		lastSeparatorPos: number,
		actualContentEnd: number,
		renderedContentEnd: number,
		addSemicolon: boolean
	) {
		if (code.original.charCodeAt(this.end - 1) === 59 /*";"*/) {
			code.remove(this.end - 1, this.end);
		}
		if (addSemicolon) {
			separatorString += ';';
		}
		if (lastSeparatorPos !== null) {
			if (
				code.original.charCodeAt(actualContentEnd - 1) === 10 /*"\n"*/
				&& (code.original.charCodeAt(this.end) === 10 /*"\n"*/ || code.original.charCodeAt(this.end) === 13 /*"\r"*/)
			) {
				actualContentEnd--;
				if (code.original.charCodeAt(actualContentEnd) === 13 /*"\r"*/) {
					actualContentEnd--;
				}
			}
			if (actualContentEnd === lastSeparatorPos + 1) {
				code.overwrite(lastSeparatorPos, renderedContentEnd, separatorString);
			} else {
				code.overwrite(lastSeparatorPos, lastSeparatorPos + 1, separatorString);
				code.remove(actualContentEnd, renderedContentEnd);
			}
		} else {
			code.appendLeft(renderedContentEnd, separatorString);
		}
		return separatorString;
	}

	render(code: MagicString, options: RenderOptions) {
		// Note that unknown test values are always included
		if (
			!this.test.included &&
			(this.testValue
				? this.alternate === null || !this.alternate.included
				: !this.consequent.included)
		) {
			const singleRetainedBranch = this.testValue ? this.consequent : this.alternate;
			code.remove(this.start, singleRetainedBranch.start);
			code.remove(singleRetainedBranch.end, this.end);
			removeAnnotations(this, code);
			singleRetainedBranch.render(code, options);
		} else {
			if (this.test.included) {
				this.test.render(code, options);
			} else {
				code.overwrite(this.test.start, this.test.end, this.testValue ? 'true' : 'false');
			}
			if (this.consequent.included) {
				this.consequent.render(code, options);
			} else {
				code.overwrite(this.consequent.start, this.consequent.end, ';');
			}
			if (this.alternate !== null) {
				if (this.alternate.included) {
					this.alternate.render(code, options);
				} else {
					code.remove(this.consequent.end, this.alternate.end);
				}
			}
		}
	}

	render (code: MagicString, options: RenderOptions) {
		if (!this.module.graph.treeshake) {
			super.render(code, options);
		} else {
			const last = this.expressions[this.expressions.length - 1];
			last.render(code, options);

			if (
				this.parent.type === NodeType.CallExpression &&
				last.type === NodeType.MemberExpression &&
				this.expressions.length > 1
			) {
				this.expressions[0].included = true;
			}

			const included = this.expressions
				.slice(0, this.expressions.length - 1)
				.filter(expression => expression.included);
			if (included.length === 0) {
				code.remove(this.start, last.start);
				code.remove(last.end, this.end);
			} else {
				let previousEnd = this.start;
				for (const expression of included) {
					expression.render(code, options);
					code.remove(previousEnd, expression.start);
					code.appendLeft(expression.end, ', ');
					previousEnd = expression.end;
				}

				code.remove(previousEnd, last.start);
				code.remove(last.end, this.end);
			}
		}
	}

	render (code: MagicString, options: RenderOptions) {
		if (this.declaration) {
			code.remove(this.start, this.declaration.start);
			this.declaration.render(code, options);
		} else {
			const start = this.leadingCommentStart || this.start;
			const end = this.next || this.end;
			code.remove(start, end);
		}
	}

export function treeshakeNode(node: Node, code: MagicString, start: number, end: number) {
	code.remove(start, end);
	if (node.annotations) {
		for (const annotation of node.annotations) {
			if (annotation.start < start) {
				code.remove(annotation.start, annotation.end);
			} else {
				return;
			}
		}
	}
}

	render (code: MagicString, options: RenderOptions) {
		if (this.module.graph.treeshake) {
			if (this.testValue === UNKNOWN_VALUE) {
				super.render(code, options);
			} else {
				code.overwrite(
					this.test.start,
					this.test.end,
					JSON.stringify(this.testValue)
				);

				// TODO if no block-scoped declarations, remove enclosing
				// curlies and dedent block (if there is a block)

				if (this.hoistedVars) {
					const names = this.hoistedVars
						.map(name => {
							const variable = this.scope.findVariable(name);
							return variable.included ? variable.getName() : null;
						})
						.filter(Boolean);

					if (names.length > 0) {
						code.appendLeft(this.start, `var ${names.join(', ')};\n\n`);
					}
				}

				if (this.testValue) {
					code.remove(this.start, this.consequent.start);
					code.remove(this.consequent.end, this.end);
					this.consequent.render(code, options);
				} else {
					code.remove(
						this.start,
						this.alternate ? this.alternate.start : this.next || this.end
					);

					if (this.alternate) {
						this.alternate.render(code, options);
					} else if (statementsWithIfStatements.has(this.parent.type)) {
						code.prependRight(this.start, '{}');
					}
				}
			}
		} else {
			super.render(code, options);
		}
	}

export function remove_indentation(code: MagicString, node: Node) {
	const indent = code.getIndentString();
	const pattern = new RegExp(`^${indent}`, 'gm');

	const excluded = [];

	walk(node, {
		enter(node) {
			if (node.type === 'TemplateElement') {
				excluded.push(node);
			}
		}
	});

	const str = code.original.slice(node.start, node.end);

	let match;
	while (match = pattern.exec(str)) {
		const index = node.start + match.index;
		while (excluded[0] && excluded[0].end < index) excluded.shift();
		if (excluded[0] && excluded[0].start < index) continue;

		code.remove(index, index + indent.length);
	}
}

export function removeNode(code: MagicString, parent: Node, node: Node) {
	const key = keys[parent.type];
	const offset = offsets[parent.type];
	if (!key || !offset) throw new Error(`not implemented: ${parent.type}`);

	const list = parent[key];
	const i = list.indexOf(node);
	if (i === -1) throw new Error('node not in list');

	let a;
	let b;

	if (list.length === 1) {
		// remove everything, leave {}
		a = parent.start + offset[0];
		b = parent.end + offset[1];
	} else if (i === 0) {
		// remove everything before second node, including comments
		a = parent.start + offset[0];
		while (/\s/.test(code.original[a])) a += 1;

		b = list[i].end;
		while (/[\s,]/.test(code.original[b])) b += 1;
	} else {
		// remove the end of the previous node to the end of this one
		a = list[i - 1].end;
		b = node.end;
	}

	code.remove(a, b);
	list.splice(i, 1);
	return;
}

export function renderStatementList (statements: Node[], code: MagicString, start: number, end: number, options: RenderOptions) {
	if (statements.length === 0) return;
	let currentNode, currentNodeStart, currentNodeNeedsBoundaries, nextNodeStart;
	let nextNode = statements[0];
	let nextNodeNeedsBoundaries = !nextNode.included || nextNode.needsBoundaries;
	if (nextNodeNeedsBoundaries) {
		nextNodeStart = start + findFirstLineBreakOutsideComment(code.original.slice(start, nextNode.start)) + 1;
	}

	for (let nextIndex = 1; nextIndex <= statements.length; nextIndex++) {
		currentNode = nextNode;
		currentNodeStart = nextNodeStart;
		currentNodeNeedsBoundaries = nextNodeNeedsBoundaries;
		nextNode = statements[nextIndex];
		nextNodeNeedsBoundaries = nextNode === undefined ? false : !nextNode.included || nextNode.needsBoundaries;
		if (currentNodeNeedsBoundaries || nextNodeNeedsBoundaries) {
			nextNodeStart = currentNode.end + findFirstLineBreakOutsideComment(
				code.original.slice(currentNode.end, nextNode === undefined ? end : nextNode.start)
			) + 1;
			if (currentNode.included) {
				currentNodeNeedsBoundaries
					? currentNode.render(code, options, { start: currentNodeStart, end: nextNodeStart })
					: currentNode.render(code, options);
			} else {
				code.remove(currentNodeStart, nextNodeStart);
			}
		} else {
			currentNode.render(code, options);
		}
	}
}

 nodesToRemove.forEach(node => {
   // remove any trailing comma
   const end = (output.slice(node.getEnd(), node.getEnd() + 1) === ',') ?
       node.getEnd() + 1 :
       node.getEnd();
   output.remove(node.getFullStart(), end);
 });