condenser 0.0.4 → 0.0.5

data/lib/condenser/processors/node_modules/magic-string/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2018 Rich Harris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/condenser/processors/node_modules/magic-string/README.md

@@ -1,26 +1,17 @@
 # magic-string
 
-<p align="center">
-  <a href="https://travis-ci.org/Rich-Harris/magic-string">
-    <img src="http://img.shields.io/travis/Rich-Harris/magic-string.svg"
-         alt="build status">
-  </a>
-  <a href="https://npmjs.org/package/magic-string">
-    <img src="https://img.shields.io/npm/v/magic-string.svg"
-         alt="npm version">
-  </a>
-  <a href="https://github.com/Rich-Harris/magic-string/blob/master/LICENSE.md">
-    <img src="https://img.shields.io/npm/l/magic-string.svg"
-         alt="license">
-  </a>
-  <a href="https://david-dm.org/Rich-Harris/magic-string">
-    <img src="https://david-dm.org/Rich-Harris/magic-string.svg"
-         alt="dependency status">
-  </a>
-  <a href="http://codecov.io/github/Rich-Harris/magic-string?branch=master">
-    <img src="http://codecov.io/github/Rich-Harris/magic-string/coverage.svg?branch=master" alt="Coverage via Codecov" />
-  </a>
-</p>
+<a href="https://travis-ci.org/Rich-Harris/magic-string">
+  <img src="http://img.shields.io/travis/Rich-Harris/magic-string.svg"
+       alt="build status">
+</a>
+<a href="https://npmjs.org/package/magic-string">
+  <img src="https://img.shields.io/npm/v/magic-string.svg"
+       alt="npm version">
+</a>
+<a href="https://github.com/Rich-Harris/magic-string/blob/master/LICENSE.md">
+  <img src="https://img.shields.io/npm/l/magic-string.svg"
+       alt="license">
+</a>
 
 Suppose you have some source code. You want to make some light modifications to it - replacing a few characters here and there, wrapping it with a header and footer, etc - and ideally you'd like to generate a source map at the end of it. You've thought about using something like [recast](https://github.com/benjamn/recast) (which allows you to generate an AST from some JavaScript, manipulate it, and reprint it with a sourcemap without losing your comments and formatting), but it seems like overkill for your needs (or maybe the source code isn't JavaScript).
 
@@ -102,6 +93,10 @@ Appends the specified `content` at the `index` in the original string. If a rang
 
 Does what you'd expect.
 
+### s.generateDecodedMap( options )
+
+Generates a sourcemap object with raw mappings in array form, rather than encoded as a string. See `generateMap` documentation below for options details. Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead.
+
 ### s.generateMap( options )
 
 Generates a [version 3 sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit). All options are, well, optional:
@@ -196,6 +191,10 @@ Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the e
 
 Removes empty lines from the start and end. Returns `this`.
 
+### s.isEmpty()
+
+Returns true if the resulting source is empty (disregarding white space).
+
 ## Bundling
 
 To concatenate several sources, use `MagicString.Bundle`:

data/lib/condenser/processors/node_modules/magic-string/dist/magic-string.cjs.js

@@ -1,8 +1,8 @@
 'use strict';
 
-var vlq = require('vlq');
+var sourcemapCodec = require('sourcemap-codec');
 
-function Chunk ( start, end, content ) {
+var Chunk = function Chunk(start, end, content) {
 	this.start = start;
 	this.end = end;
 	this.original = content;
@@ -15,416 +15,332 @@ function Chunk ( start, end, content ) {
 	this.edited = false;
 
 	// we make these non-enumerable, for sanity while debugging
-	Object.defineProperties( this, {
+	Object.defineProperties(this, {
 		previous: { writable: true, value: null },
-		next: { writable: true, value: null }
+		next:     { writable: true, value: null }
 	});
-}
-
-Chunk.prototype = {
-	appendLeft: function appendLeft ( content ) {
-		this.outro += content;
-	},
-
-	appendRight: function appendRight ( content ) {
-		this.intro = this.intro + content;
-	},
+};
 
-	clone: function clone () {
-		var chunk = new Chunk( this.start, this.end, this.original );
+Chunk.prototype.appendLeft = function appendLeft (content) {
+	this.outro += content;
+};
 
-		chunk.intro = this.intro;
-		chunk.outro = this.outro;
-		chunk.content = this.content;
-		chunk.storeName = this.storeName;
-		chunk.edited = this.edited;
+Chunk.prototype.appendRight = function appendRight (content) {
+	this.intro = this.intro + content;
+};
 
-		return chunk;
-	},
+Chunk.prototype.clone = function clone () {
+	var chunk = new Chunk(this.start, this.end, this.original);
 
-	contains: function contains ( index ) {
-		return this.start < index && index < this.end;
-	},
+	chunk.intro = this.intro;
+	chunk.outro = this.outro;
+	chunk.content = this.content;
+	chunk.storeName = this.storeName;
+	chunk.edited = this.edited;
 
-	eachNext: function eachNext ( fn ) {
-		var chunk = this;
-		while ( chunk ) {
-			fn( chunk );
-			chunk = chunk.next;
-		}
-	},
+	return chunk;
+};
 
-	eachPrevious: function eachPrevious ( fn ) {
-		var chunk = this;
-		while ( chunk ) {
-			fn( chunk );
-			chunk = chunk.previous;
-		}
-	},
+Chunk.prototype.contains = function contains (index) {
+	return this.start < index && index < this.end;
+};
 
-	edit: function edit ( content, storeName, contentOnly ) {
-		this.content = content;
-		if ( !contentOnly ) {
-			this.intro = '';
-			this.outro = '';
-		}
-		this.storeName = storeName;
+Chunk.prototype.eachNext = function eachNext (fn) {
+	var chunk = this;
+	while (chunk) {
+		fn(chunk);
+		chunk = chunk.next;
+	}
+};
 
-		this.edited = true;
+Chunk.prototype.eachPrevious = function eachPrevious (fn) {
+	var chunk = this;
+	while (chunk) {
+		fn(chunk);
+		chunk = chunk.previous;
+	}
+};
 
-		return this;
-	},
+Chunk.prototype.edit = function edit (content, storeName, contentOnly) {
+	this.content = content;
+	if (!contentOnly) {
+		this.intro = '';
+		this.outro = '';
+	}
+	this.storeName = storeName;
 
-	prependLeft: function prependLeft ( content ) {
-		this.outro = content + this.outro;
-	},
+	this.edited = true;
 
-	prependRight: function prependRight ( content ) {
-		this.intro = content + this.intro;
-	},
+	return this;
+};
 
-	split: function split ( index ) {
-		var sliceIndex = index - this.start;
+Chunk.prototype.prependLeft = function prependLeft (content) {
+	this.outro = content + this.outro;
+};
 
-		var originalBefore = this.original.slice( 0, sliceIndex );
-		var originalAfter = this.original.slice( sliceIndex );
+Chunk.prototype.prependRight = function prependRight (content) {
+	this.intro = content + this.intro;
+};
 
-		this.original = originalBefore;
+Chunk.prototype.split = function split (index) {
+	var sliceIndex = index - this.start;
 
-		var newChunk = new Chunk( index, this.end, originalAfter );
-		newChunk.outro = this.outro;
-		this.outro = '';
+	var originalBefore = this.original.slice(0, sliceIndex);
+	var originalAfter = this.original.slice(sliceIndex);
 
-		this.end = index;
+	this.original = originalBefore;
 
-		if ( this.edited ) {
-			// TODO is this block necessary?...
-			newChunk.edit( '', false );
-			this.content = '';
-		} else {
-			this.content = originalBefore;
-		}
+	var newChunk = new Chunk(index, this.end, originalAfter);
+	newChunk.outro = this.outro;
+	this.outro = '';
 
-		newChunk.next = this.next;
-		if ( newChunk.next ) { newChunk.next.previous = newChunk; }
-		newChunk.previous = this;
-		this.next = newChunk;
+	this.end = index;
 
-		return newChunk;
-	},
+	if (this.edited) {
+		// TODO is this block necessary?...
+		newChunk.edit('', false);
+		this.content = '';
+	} else {
+		this.content = originalBefore;
+	}
 
-	toString: function toString () {
-		return this.intro + this.content + this.outro;
-	},
+	newChunk.next = this.next;
+	if (newChunk.next) { newChunk.next.previous = newChunk; }
+	newChunk.previous = this;
+	this.next = newChunk;
 
-	trimEnd: function trimEnd ( rx ) {
-		this.outro = this.outro.replace( rx, '' );
-		if ( this.outro.length ) { return true; }
+	return newChunk;
+};
 
-		var trimmed = this.content.replace( rx, '' );
+Chunk.prototype.toString = function toString () {
+	return this.intro + this.content + this.outro;
+};
 
-		if ( trimmed.length ) {
-			if ( trimmed !== this.content ) {
-				this.split( this.start + trimmed.length ).edit( '', false );
-			}
+Chunk.prototype.trimEnd = function trimEnd (rx) {
+	this.outro = this.outro.replace(rx, '');
+	if (this.outro.length) { return true; }
 
-			return true;
-		} else {
-			this.edit( '', false );
+	var trimmed = this.content.replace(rx, '');
 
-			this.intro = this.intro.replace( rx, '' );
-			if ( this.intro.length ) { return true; }
+	if (trimmed.length) {
+		if (trimmed !== this.content) {
+			this.split(this.start + trimmed.length).edit('', undefined, true);
 		}
-	},
+		return true;
 
-	trimStart: function trimStart ( rx ) {
-		this.intro = this.intro.replace( rx, '' );
-		if ( this.intro.length ) { return true; }
+	} else {
+		this.edit('', undefined, true);
 
-		var trimmed = this.content.replace( rx, '' );
+		this.intro = this.intro.replace(rx, '');
+		if (this.intro.length) { return true; }
+	}
+};
 
-		if ( trimmed.length ) {
-			if ( trimmed !== this.content ) {
-				this.split( this.end - trimmed.length );
-				this.edit( '', false );
-			}
+Chunk.prototype.trimStart = function trimStart (rx) {
+	this.intro = this.intro.replace(rx, '');
+	if (this.intro.length) { return true; }
 
-			return true;
-		} else {
-			this.edit( '', false );
+	var trimmed = this.content.replace(rx, '');
 
-			this.outro = this.outro.replace( rx, '' );
-			if ( this.outro.length ) { return true; }
+	if (trimmed.length) {
+		if (trimmed !== this.content) {
+			this.split(this.end - trimmed.length);
+			this.edit('', undefined, true);
 		}
+		return true;
+
+	} else {
+		this.edit('', undefined, true);
+
+		this.outro = this.outro.replace(rx, '');
+		if (this.outro.length) { return true; }
 	}
 };
 
-var _btoa;
-
-if ( typeof window !== 'undefined' && typeof window.btoa === 'function' ) {
-	_btoa = window.btoa;
-} else if ( typeof Buffer === 'function' ) {
-	_btoa = function (str) { return new Buffer( str ).toString( 'base64' ); };
-} else {
-	_btoa = function () {
-		throw new Error( 'Unsupported environment: `window.btoa` or `Buffer` should be supported.' );
-	};
+var btoa = function () {
+	throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
+};
+if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
+	btoa = function (str) { return window.btoa(unescape(encodeURIComponent(str))); };
+} else if (typeof Buffer === 'function') {
+	btoa = function (str) { return Buffer.from(str, 'utf-8').toString('base64'); };
 }
 
-var btoa = _btoa;
-
-function SourceMap ( properties ) {
+var SourceMap = function SourceMap(properties) {
 	this.version = 3;
-
-	this.file           = properties.file;
-	this.sources        = properties.sources;
+	this.file = properties.file;
+	this.sources = properties.sources;
 	this.sourcesContent = properties.sourcesContent;
-	this.names          = properties.names;
-	this.mappings       = properties.mappings;
-}
+	this.names = properties.names;
+	this.mappings = sourcemapCodec.encode(properties.mappings);
+};
 
-SourceMap.prototype = {
-	toString: function toString () {
-		return JSON.stringify( this );
-	},
+SourceMap.prototype.toString = function toString () {
+	return JSON.stringify(this);
+};
 
-	toUrl: function toUrl () {
-		return 'data:application/json;charset=utf-8;base64,' + btoa( this.toString() );
-	}
+SourceMap.prototype.toUrl = function toUrl () {
+	return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
 };
 
-function guessIndent ( code ) {
-	var lines = code.split( '\n' );
+function guessIndent(code) {
+	var lines = code.split('\n');
 
-	var tabbed = lines.filter( function (line) { return /^\t+/.test( line ); } );
-	var spaced = lines.filter( function (line) { return /^ {2,}/.test( line ); } );
+	var tabbed = lines.filter(function (line) { return /^\t+/.test(line); });
+	var spaced = lines.filter(function (line) { return /^ {2,}/.test(line); });
 
-	if ( tabbed.length === 0 && spaced.length === 0 ) {
+	if (tabbed.length === 0 && spaced.length === 0) {
 		return null;
 	}
 
 	// More lines tabbed than spaced? Assume tabs, and
 	// default to tabs in the case of a tie (or nothing
 	// to go on)
-	if ( tabbed.length >= spaced.length ) {
+	if (tabbed.length >= spaced.length) {
 		return '\t';
 	}
 
 	// Otherwise, we need to guess the multiple
-	var min = spaced.reduce( function ( previous, current ) {
-		var numSpaces = /^ +/.exec( current )[0].length;
-		return Math.min( numSpaces, previous );
-	}, Infinity );
+	var min = spaced.reduce(function (previous, current) {
+		var numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
 
-	return new Array( min + 1 ).join( ' ' );
+	return new Array(min + 1).join(' ');
 }
 
-function getRelativePath ( from, to ) {
-	var fromParts = from.split( /[\/\\]/ );
-	var toParts = to.split( /[\/\\]/ );
+function getRelativePath(from, to) {
+	var fromParts = from.split(/[/\\]/);
+	var toParts = to.split(/[/\\]/);
 
 	fromParts.pop(); // get dirname
 
-	while ( fromParts[0] === toParts[0] ) {
+	while (fromParts[0] === toParts[0]) {
 		fromParts.shift();
 		toParts.shift();
 	}
 
-	if ( fromParts.length ) {
+	if (fromParts.length) {
 		var i = fromParts.length;
-		while ( i-- ) { fromParts[i] = '..'; }
+		while (i--) { fromParts[i] = '..'; }
 	}
 
-	return fromParts.concat( toParts ).join( '/' );
+	return fromParts.concat(toParts).join('/');
 }
 
 var toString = Object.prototype.toString;
 
-function isObject ( thing ) {
-	return toString.call( thing ) === '[object Object]';
+function isObject(thing) {
+	return toString.call(thing) === '[object Object]';
 }
 
-function getLocator ( source ) {
-	var originalLines = source.split( '\n' );
+function getLocator(source) {
+	var originalLines = source.split('\n');
+	var lineOffsets = [];
 
-	var start = 0;
-	var lineRanges = originalLines.map( function ( line, i ) {
-		var end = start + line.length + 1;
-		var range = { start: start, end: end, line: i };
-
-		start = end;
-		return range;
-	});
-
-	var i = 0;
-
-	function rangeContains ( range, index ) {
-		return range.start <= index && index < range.end;
+	for (var i = 0, pos = 0; i < originalLines.length; i++) {
+		lineOffsets.push(pos);
+		pos += originalLines[i].length + 1;
 	}
 
-	function getLocation ( range, index ) {
-		return { line: range.line, column: index - range.start };
-	}
-
-	return function locate ( index ) {
-		var range = lineRanges[i];
-
-		var d = index >= range.end ? 1 : -1;
-
-		while ( range ) {
-			if ( rangeContains( range, index ) ) { return getLocation( range, index ); }
-
-			i += d;
-			range = lineRanges[i];
+	return function locate(index) {
+		var i = 0;
+		var j = lineOffsets.length;
+		while (i < j) {
+			var m = (i + j) >> 1;
+			if (index < lineOffsets[m]) {
+				j = m;
+			} else {
+				i = m + 1;
+			}
 		}
+		var line = i - 1;
+		var column = index - lineOffsets[line];
+		return { line: line, column: column };
 	};
 }
 
-function Mappings ( hires ) {
-	var this$1 = this;
-
-	var offsets = {
-		generatedCodeColumn: 0,
-		sourceIndex: 0,
-		sourceCodeLine: 0,
-		sourceCodeColumn: 0,
-		sourceCodeName: 0
-	};
-
-	var generatedCodeLine = 0;
-	var generatedCodeColumn = 0;
-
+var Mappings = function Mappings(hires) {
+	this.hires = hires;
+	this.generatedCodeLine = 0;
+	this.generatedCodeColumn = 0;
 	this.raw = [];
-	var rawSegments = this.raw[ generatedCodeLine ] = [];
-
-	var pending = null;
+	this.rawSegments = this.raw[this.generatedCodeLine] = [];
+	this.pending = null;
+};
 
-	this.addEdit = function ( sourceIndex, content, original, loc, nameIndex ) {
-		if ( content.length ) {
-			rawSegments.push([
-				generatedCodeColumn,
-				sourceIndex,
-				loc.line,
-				loc.column,
-				nameIndex ]);
-		} else if ( pending ) {
-			rawSegments.push( pending );
+Mappings.prototype.addEdit = function addEdit (sourceIndex, content, loc, nameIndex) {
+	if (content.length) {
+		var segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
+		if (nameIndex >= 0) {
+			segment.push(nameIndex);
 		}
+		this.rawSegments.push(segment);
+	} else if (this.pending) {
+		this.rawSegments.push(this.pending);
+	}
 
-		this$1.advance( content );
-		pending = null;
-	};
-
-	this.addUneditedChunk = function ( sourceIndex, chunk, original, loc, sourcemapLocations ) {
-		var originalCharIndex = chunk.start;
-		var first = true;
-
-		while ( originalCharIndex < chunk.end ) {
-			if ( hires || first || sourcemapLocations[ originalCharIndex ] ) {
-				rawSegments.push([
-					generatedCodeColumn,
-					sourceIndex,
-					loc.line,
-					loc.column,
-					-1
-				]);
-			}
+	this.advance(content);
+	this.pending = null;
+};
 
-			if ( original[ originalCharIndex ] === '\n' ) {
-				loc.line += 1;
-				loc.column = 0;
-				generatedCodeLine += 1;
-				this$1.raw[ generatedCodeLine ] = rawSegments = [];
-				generatedCodeColumn = 0;
-			} else {
-				loc.column += 1;
-				generatedCodeColumn += 1;
-			}
+Mappings.prototype.addUneditedChunk = function addUneditedChunk (sourceIndex, chunk, original, loc, sourcemapLocations) {
+	var originalCharIndex = chunk.start;
+	var first = true;
 
-			originalCharIndex += 1;
-			first = false;
+	while (originalCharIndex < chunk.end) {
+		if (this.hires || first || sourcemapLocations[originalCharIndex]) {
+			this.rawSegments.push([this.generatedCodeColumn, sourceIndex, loc.line, loc.column]);
 		}
 
-		pending = [
-			generatedCodeColumn,
-			sourceIndex,
-			loc.line,
-			loc.column,
-			-1 ];
-	};
-
-	this.advance = function (str) {
-		if ( !str ) { return; }
-
-		var lines = str.split( '\n' );
-		var lastLine = lines.pop();
-
-		if ( lines.length ) {
-			generatedCodeLine += lines.length;
-			this$1.raw[ generatedCodeLine ] = rawSegments = [];
-			generatedCodeColumn = lastLine.length;
+		if (original[originalCharIndex] === '\n') {
+			loc.line += 1;
+			loc.column = 0;
+			this.generatedCodeLine += 1;
+			this.raw[this.generatedCodeLine] = this.rawSegments = [];
+			this.generatedCodeColumn = 0;
 		} else {
-			generatedCodeColumn += lastLine.length;
+			loc.column += 1;
+			this.generatedCodeColumn += 1;
 		}
-	};
-
-	this.encode = function () {
-		return this$1.raw.map( function (segments) {
-			var generatedCodeColumn = 0;
-
-			return segments.map( function (segment) {
-				var arr = [
-					segment[0] - generatedCodeColumn,
-					segment[1] - offsets.sourceIndex,
-					segment[2] - offsets.sourceCodeLine,
-					segment[3] - offsets.sourceCodeColumn
-				];
-
-				generatedCodeColumn = segment[0];
-				offsets.sourceIndex = segment[1];
-				offsets.sourceCodeLine = segment[2];
-				offsets.sourceCodeColumn = segment[3];
-
-				if ( ~segment[4] ) {
-					arr.push( segment[4] - offsets.sourceCodeName );
-					offsets.sourceCodeName = segment[4];
-				}
 
-				return vlq.encode( arr );
-			}).join( ',' );
-		}).join( ';' );
-	};
-}
+		originalCharIndex += 1;
+		first = false;
+	}
 
-var Stats = function Stats () {
-	Object.defineProperties( this, {
-		startTimes: { value: {} }
-	});
+	this.pending = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column];
 };
 
-Stats.prototype.time = function time ( label ) {
-	this.startTimes[ label ] = process.hrtime();
-};
+Mappings.prototype.advance = function advance (str) {
+	if (!str) { return; }
 
-Stats.prototype.timeEnd = function timeEnd ( label ) {
-	var elapsed = process.hrtime( this.startTimes[ label ] );
+	var lines = str.split('\n');
 
-	if ( !this[ label ] ) { this[ label ] = 0; }
-	this[ label ] += elapsed[0] * 1e3 + elapsed[1] * 1e-6;
+	if (lines.length > 1) {
+		for (var i = 0; i < lines.length - 1; i++) {
+			this.generatedCodeLine++;
+			this.raw[this.generatedCodeLine] = this.rawSegments = [];
+		}
+		this.generatedCodeColumn = 0;
+	}
+
+	this.generatedCodeColumn += lines[lines.length - 1].length;
 };
 
+var n = '\n';
+
 var warned = {
 	insertLeft: false,
 	insertRight: false,
 	storeName: false
 };
 
-function MagicString$1 ( string, options ) {
+var MagicString = function MagicString(string, options) {
 	if ( options === void 0 ) options = {};
 
-	var chunk = new Chunk( 0, string.length, string );
+	var chunk = new Chunk(0, string.length, string);
 
-	Object.defineProperties( this, {
+	Object.defineProperties(this, {
 		original:              { writable: true, value: string },
 		outro:                 { writable: true, value: '' },
 		intro:                 { writable: true, value: '' },
@@ -437,864 +353,946 @@ function MagicString$1 ( string, options ) {
 		indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
 		sourcemapLocations:    { writable: true, value: {} },
 		storedNames:           { writable: true, value: {} },
-		indentStr:             { writable: true, value: guessIndent( string ) }
+		indentStr:             { writable: true, value: guessIndent(string) }
 	});
 
-	this.byStart[ 0 ] = chunk;
-	this.byEnd[ string.length ] = chunk;
-}
-
-MagicString$1.prototype = {
-	addSourcemapLocation: function addSourcemapLocation ( char ) {
-		this.sourcemapLocations[ char ] = true;
-	},
+	this.byStart[0] = chunk;
+	this.byEnd[string.length] = chunk;
+};
 
-	append: function append ( content ) {
-		if ( typeof content !== 'string' ) { throw new TypeError( 'outro content must be a string' ); }
+MagicString.prototype.addSourcemapLocation = function addSourcemapLocation (char) {
+	this.sourcemapLocations[char] = true;
+};
 
-		this.outro += content;
-		return this;
-	},
+MagicString.prototype.append = function append (content) {
+	if (typeof content !== 'string') { throw new TypeError('outro content must be a string'); }
 
-	appendLeft: function appendLeft ( index, content ) {
-		if ( typeof content !== 'string' ) { throw new TypeError( 'inserted content must be a string' ); }
+	this.outro += content;
+	return this;
+};
 
-		this._split( index );
+MagicString.prototype.appendLeft = function appendLeft (index, content) {
+	if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); }
 
-		var chunk = this.byEnd[ index ];
+	this._split(index);
 
-		if ( chunk ) {
-			chunk.appendLeft( content );
-		} else {
-			this.intro += content;
-		}
+	var chunk = this.byEnd[index];
 
-		return this;
-	},
+	if (chunk) {
+		chunk.appendLeft(content);
+	} else {
+		this.intro += content;
+	}
+	return this;
+};
 
-	appendRight: function appendRight ( index, content ) {
-		if ( typeof content !== 'string' ) { throw new TypeError( 'inserted content must be a string' ); }
+MagicString.prototype.appendRight = function appendRight (index, content) {
+	if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); }
 
-		this._split( index );
+	this._split(index);
 
-		var chunk = this.byStart[ index ];
+	var chunk = this.byStart[index];
 
-		if ( chunk ) {
-			chunk.appendRight( content );
-		} else {
-			this.outro += content;
-		}
-
-		return this;
-	},
-
-	clone: function clone () {
-		var cloned = new MagicString$1( this.original, { filename: this.filename });
+	if (chunk) {
+		chunk.appendRight(content);
+	} else {
+		this.outro += content;
+	}
+	return this;
+};
 
-		var originalChunk = this.firstChunk;
-		var clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+MagicString.prototype.clone = function clone () {
+	var cloned = new MagicString(this.original, { filename: this.filename });
 
-		while ( originalChunk ) {
-			cloned.byStart[ clonedChunk.start ] = clonedChunk;
-			cloned.byEnd[ clonedChunk.end ] = clonedChunk;
+	var originalChunk = this.firstChunk;
+	var clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
 
-			var nextOriginalChunk = originalChunk.next;
-			var nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+	while (originalChunk) {
+		cloned.byStart[clonedChunk.start] = clonedChunk;
+		cloned.byEnd[clonedChunk.end] = clonedChunk;
 
-			if ( nextClonedChunk ) {
-				clonedChunk.next = nextClonedChunk;
-				nextClonedChunk.previous = clonedChunk;
+		var nextOriginalChunk = originalChunk.next;
+		var nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
 
-				clonedChunk = nextClonedChunk;
-			}
+		if (nextClonedChunk) {
+			clonedChunk.next = nextClonedChunk;
+			nextClonedChunk.previous = clonedChunk;
 
-			originalChunk = nextOriginalChunk;
+			clonedChunk = nextClonedChunk;
 		}
 
-		cloned.lastChunk = clonedChunk;
+		originalChunk = nextOriginalChunk;
+	}
 
-		if ( this.indentExclusionRanges ) {
-			cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
-		}
+	cloned.lastChunk = clonedChunk;
 
-		Object.keys( this.sourcemapLocations ).forEach( function (loc) {
-			cloned.sourcemapLocations[ loc ] = true;
-		});
+	if (this.indentExclusionRanges) {
+		cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+	}
 
-		return cloned;
-	},
+	Object.keys(this.sourcemapLocations).forEach(function (loc) {
+		cloned.sourcemapLocations[loc] = true;
+	});
 
-	generateMap: function generateMap ( options ) {
-		var this$1 = this;
+	return cloned;
+};
 
-		options = options || {};
+MagicString.prototype.generateDecodedMap = function generateDecodedMap (options) {
+		var this$1 = this;
 
-		var sourceIndex = 0;
-		var names = Object.keys( this.storedNames );
-		var mappings = new Mappings( options.hires );
+	options = options || {};
 
-		var locate = getLocator( this.original );
+	var sourceIndex = 0;
+	var names = Object.keys(this.storedNames);
+	var mappings = new Mappings(options.hires);
 
-		if ( this.intro ) {
-			mappings.advance( this.intro );
-		}
+	var locate = getLocator(this.original);
 
-		this.firstChunk.eachNext( function (chunk) {
-			var loc = locate( chunk.start );
+	if (this.intro) {
+		mappings.advance(this.intro);
+	}
 
-			if ( chunk.intro.length ) { mappings.advance( chunk.intro ); }
+	this.firstChunk.eachNext(function (chunk) {
+		var loc = locate(chunk.start);
 
-			if ( chunk.edited ) {
-				mappings.addEdit( sourceIndex, chunk.content, chunk.original, loc, chunk.storeName ? names.indexOf( chunk.original ) : -1 );
-			} else {
-				mappings.addUneditedChunk( sourceIndex, chunk, this$1.original, loc, this$1.sourcemapLocations );
-			}
+		if (chunk.intro.length) { mappings.advance(chunk.intro); }
 
-			if ( chunk.outro.length ) { mappings.advance( chunk.outro ); }
-		});
+		if (chunk.edited) {
+			mappings.addEdit(
+				sourceIndex,
+				chunk.content,
+				loc,
+				chunk.storeName ? names.indexOf(chunk.original) : -1
+			);
+		} else {
+			mappings.addUneditedChunk(sourceIndex, chunk, this$1.original, loc, this$1.sourcemapLocations);
+		}
 
-		var map = new SourceMap({
-			file: ( options.file ? options.file.split( /[\/\\]/ ).pop() : null ),
-			sources: [ options.source ? getRelativePath( options.file || '', options.source ) : null ],
-			sourcesContent: options.includeContent ? [ this.original ] : [ null ],
-			names: names,
-			mappings: mappings.encode()
-		});
-		return map;
-	},
+		if (chunk.outro.length) { mappings.advance(chunk.outro); }
+	});
 
-	getIndentString: function getIndentString () {
-		return this.indentStr === null ? '\t' : this.indentStr;
-	},
+	return {
+		file: options.file ? options.file.split(/[/\\]/).pop() : null,
+		sources: [options.source ? getRelativePath(options.file || '', options.source) : null],
+		sourcesContent: options.includeContent ? [this.original] : [null],
+		names: names,
+		mappings: mappings.raw
+	};
+};
 
-	indent: function indent ( indentStr, options ) {
-		var this$1 = this;
+MagicString.prototype.generateMap = function generateMap (options) {
+	return new SourceMap(this.generateDecodedMap(options));
+};
 
-		var pattern = /^[^\r\n]/gm;
+MagicString.prototype.getIndentString = function getIndentString () {
+	return this.indentStr === null ? '\t' : this.indentStr;
+};
 
-		if ( isObject( indentStr ) ) {
-			options = indentStr;
-			indentStr = undefined;
-		}
+MagicString.prototype.indent = function indent (indentStr, options) {
+	var pattern = /^[^\r\n]/gm;
 
-		indentStr = indentStr !== undefined ? indentStr : ( this.indentStr || '\t' );
+	if (isObject(indentStr)) {
+		options = indentStr;
+		indentStr = undefined;
+	}
 
-		if ( indentStr === '' ) { return this; } // noop
+	indentStr = indentStr !== undefined ? indentStr : this.indentStr || '\t';
 
-		options = options || {};
+	if (indentStr === '') { return this; } // noop
 
-		// Process exclusion ranges
-		var isExcluded = {};
+	options = options || {};
 
-		if ( options.exclude ) {
-			var exclusions = typeof options.exclude[0] === 'number' ? [ options.exclude ] : options.exclude;
-			exclusions.forEach( function (exclusion) {
-				for ( var i = exclusion[0]; i < exclusion[1]; i += 1 ) {
-					isExcluded[i] = true;
-				}
-			});
-		}
+	// Process exclusion ranges
+	var isExcluded = {};
 
-		var shouldIndentNextCharacter = options.indentStart !== false;
-		var replacer = function (match) {
-			if ( shouldIndentNextCharacter ) { return ("" + indentStr + match); }
-			shouldIndentNextCharacter = true;
-			return match;
-		};
+	if (options.exclude) {
+		var exclusions =
+			typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
+		exclusions.forEach(function (exclusion) {
+			for (var i = exclusion[0]; i < exclusion[1]; i += 1) {
+				isExcluded[i] = true;
+			}
+		});
+	}
 
-		this.intro = this.intro.replace( pattern, replacer );
+	var shouldIndentNextCharacter = options.indentStart !== false;
+	var replacer = function (match) {
+		if (shouldIndentNextCharacter) { return ("" + indentStr + match); }
+		shouldIndentNextCharacter = true;
+		return match;
+	};
 
-		var charIndex = 0;
+	this.intro = this.intro.replace(pattern, replacer);
 
-		var chunk = this.firstChunk;
+	var charIndex = 0;
+	var chunk = this.firstChunk;
 
-		while ( chunk ) {
-			var end = chunk.end;
+	while (chunk) {
+		var end = chunk.end;
 
-			if ( chunk.edited ) {
-				if ( !isExcluded[ charIndex ] ) {
-					chunk.content = chunk.content.replace( pattern, replacer );
+		if (chunk.edited) {
+			if (!isExcluded[charIndex]) {
+				chunk.content = chunk.content.replace(pattern, replacer);
 
-					if ( chunk.content.length ) {
-						shouldIndentNextCharacter = chunk.content[ chunk.content.length - 1 ] === '\n';
-					}
+				if (chunk.content.length) {
+					shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n';
 				}
-			} else {
-				charIndex = chunk.start;
-
-				while ( charIndex < end ) {
-					if ( !isExcluded[ charIndex ] ) {
-						var char = this$1.original[ charIndex ];
-
-						if ( char === '\n' ) {
-							shouldIndentNextCharacter = true;
-						} else if ( char !== '\r' && shouldIndentNextCharacter ) {
-							shouldIndentNextCharacter = false;
-
-							if ( charIndex === chunk.start ) {
-								chunk.prependRight( indentStr );
-							} else {
-								this$1._splitChunk( chunk, charIndex );
-								chunk = chunk.next;
-								chunk.prependRight( indentStr );
-							}
+			}
+		} else {
+			charIndex = chunk.start;
+
+			while (charIndex < end) {
+				if (!isExcluded[charIndex]) {
+					var char = this.original[charIndex];
+
+					if (char === '\n') {
+						shouldIndentNextCharacter = true;
+					} else if (char !== '\r' && shouldIndentNextCharacter) {
+						shouldIndentNextCharacter = false;
+
+						if (charIndex === chunk.start) {
+							chunk.prependRight(indentStr);
+						} else {
+							this._splitChunk(chunk, charIndex);
+							chunk = chunk.next;
+							chunk.prependRight(indentStr);
 						}
 					}
-
-					charIndex += 1;
 				}
-			}
 
-			charIndex = chunk.end;
-			chunk = chunk.next;
+				charIndex += 1;
+			}
 		}
 
-		this.outro = this.outro.replace( pattern, replacer );
-
-		return this;
-	},
+		charIndex = chunk.end;
+		chunk = chunk.next;
+	}
 
-	insert: function insert () {
-		throw new Error( 'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)' );
-	},
+	this.outro = this.outro.replace(pattern, replacer);
 
-	insertLeft: function insertLeft ( index, content ) {
-		if ( !warned.insertLeft ) {
-			console.warn( 'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead' ); // eslint-disable-line no-console
-			warned.insertLeft = true;
-		}
+	return this;
+};
 
-		return this.appendLeft( index, content );
-	},
+MagicString.prototype.insert = function insert () {
+	throw new Error('magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)');
+};
 
-	insertRight: function insertRight ( index, content ) {
-		if ( !warned.insertRight ) {
-			console.warn( 'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead' ); // eslint-disable-line no-console
-			warned.insertRight = true;
-		}
+MagicString.prototype.insertLeft = function insertLeft (index, content) {
+	if (!warned.insertLeft) {
+		console.warn('magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead'); // eslint-disable-line no-console
+		warned.insertLeft = true;
+	}
 
-		return this.prependRight( index, content );
-	},
+	return this.appendLeft(index, content);
+};
 
-	move: function move ( start, end, index ) {
-		if ( index >= start && index <= end ) { throw new Error( 'Cannot move a selection inside itself' ); }
+MagicString.prototype.insertRight = function insertRight (index, content) {
+	if (!warned.insertRight) {
+		console.warn('magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead'); // eslint-disable-line no-console
+		warned.insertRight = true;
+	}
 
-		this._split( start );
-		this._split( end );
-		this._split( index );
+	return this.prependRight(index, content);
+};
 
-		var first = this.byStart[ start ];
-		var last = this.byEnd[ end ];
+MagicString.prototype.move = function move (start, end, index) {
+	if (index >= start && index <= end) { throw new Error('Cannot move a selection inside itself'); }
 
-		var oldLeft = first.previous;
-		var oldRight = last.next;
+	this._split(start);
+	this._split(end);
+	this._split(index);
 
-		var newRight = this.byStart[ index ];
-		if ( !newRight && last === this.lastChunk ) { return this; }
-		var newLeft = newRight ? newRight.previous : this.lastChunk;
+	var first = this.byStart[start];
+	var last = this.byEnd[end];
 
-		if ( oldLeft ) { oldLeft.next = oldRight; }
-		if ( oldRight ) { oldRight.previous = oldLeft; }
+	var oldLeft = first.previous;
+	var oldRight = last.next;
 
-		if ( newLeft ) { newLeft.next = first; }
-		if ( newRight ) { newRight.previous = last; }
+	var newRight = this.byStart[index];
+	if (!newRight && last === this.lastChunk) { return this; }
+	var newLeft = newRight ? newRight.previous : this.lastChunk;
 
-		if ( !first.previous ) { this.firstChunk = last.next; }
-		if ( !last.next ) {
-			this.lastChunk = first.previous;
-			this.lastChunk.next = null;
-		}
+	if (oldLeft) { oldLeft.next = oldRight; }
+	if (oldRight) { oldRight.previous = oldLeft; }
 
-		first.previous = newLeft;
-		last.next = newRight || null;
+	if (newLeft) { newLeft.next = first; }
+	if (newRight) { newRight.previous = last; }
 
-		if ( !newLeft ) { this.firstChunk = first; }
-		if ( !newRight ) { this.lastChunk = last; }
+	if (!first.previous) { this.firstChunk = last.next; }
+	if (!last.next) {
+		this.lastChunk = first.previous;
+		this.lastChunk.next = null;
+	}
 
-		return this;
-	},
+	first.previous = newLeft;
+	last.next = newRight || null;
 
-	overwrite: function overwrite ( start, end, content, options ) {
-		var this$1 = this;
+	if (!newLeft) { this.firstChunk = first; }
+	if (!newRight) { this.lastChunk = last; }
+	return this;
+};
 
-		if ( typeof content !== 'string' ) { throw new TypeError( 'replacement content must be a string' ); }
+MagicString.prototype.overwrite = function overwrite (start, end, content, options) {
+	if (typeof content !== 'string') { throw new TypeError('replacement content must be a string'); }
 
-		while ( start < 0 ) { start += this$1.original.length; }
-		while ( end < 0 ) { end += this$1.original.length; }
+	while (start < 0) { start += this.original.length; }
+	while (end < 0) { end += this.original.length; }
 
-		if ( end > this.original.length ) { throw new Error( 'end is out of bounds' ); }
-		if ( start === end ) { throw new Error( 'Cannot overwrite a zero-length range – use appendLeft or prependRight instead' ); }
+	if (end > this.original.length) { throw new Error('end is out of bounds'); }
+	if (start === end)
+		{ throw new Error('Cannot overwrite a zero-length range – use appendLeft or prependRight instead'); }
 
-		this._split( start );
-		this._split( end );
+	this._split(start);
+	this._split(end);
 
-		if ( options === true ) {
-			if ( !warned.storeName ) {
-				console.warn( 'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string' ); // eslint-disable-line no-console
-				warned.storeName = true;
-			}
-
-			options = { storeName: true };
+	if (options === true) {
+		if (!warned.storeName) {
+			console.warn('The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string'); // eslint-disable-line no-console
+			warned.storeName = true;
 		}
-		var storeName = options !== undefined ? options.storeName : false;
-		var contentOnly = options !== undefined ? options.contentOnly : false;
 
-		if ( storeName ) {
-			var original = this.original.slice( start, end );
-			this.storedNames[ original ] = true;
-		}
+		options = { storeName: true };
+	}
+	var storeName = options !== undefined ? options.storeName : false;
+	var contentOnly = options !== undefined ? options.contentOnly : false;
 
-		var first = this.byStart[ start ];
-		var last = this.byEnd[ end ];
+	if (storeName) {
+		var original = this.original.slice(start, end);
+		this.storedNames[original] = true;
+	}
 
-		if ( first ) {
-			if ( end > first.end && first.next !== this.byStart[ first.end ] ) {
-				throw new Error( 'Cannot overwrite across a split point' );
-			}
+	var first = this.byStart[start];
+	var last = this.byEnd[end];
 
-			first.edit( content, storeName, contentOnly );
+	if (first) {
+		if (end > first.end && first.next !== this.byStart[first.end]) {
+			throw new Error('Cannot overwrite across a split point');
+		}
 
-			if ( first !== last ) {
-				var chunk = first.next;
-				while ( chunk !== last ) {
-					chunk.edit( '', false );
-					chunk = chunk.next;
-				}
+		first.edit(content, storeName, contentOnly);
 
-				chunk.edit( '', false );
+		if (first !== last) {
+			var chunk = first.next;
+			while (chunk !== last) {
+				chunk.edit('', false);
+				chunk = chunk.next;
 			}
-		}
-
-		else {
-			// must be inserting at the end
-			var newChunk = new Chunk( start, end, '' ).edit( content, storeName );
 
-			// TODO last chunk in the array may not be the last chunk, if it's moved...
-			last.next = newChunk;
-			newChunk.previous = last;
+			chunk.edit('', false);
 		}
+	} else {
+		// must be inserting at the end
+		var newChunk = new Chunk(start, end, '').edit(content, storeName);
 
-		return this;
-	},
+		// TODO last chunk in the array may not be the last chunk, if it's moved...
+		last.next = newChunk;
+		newChunk.previous = last;
+	}
+	return this;
+};
 
-	prepend: function prepend ( content ) {
-		if ( typeof content !== 'string' ) { throw new TypeError( 'outro content must be a string' ); }
+MagicString.prototype.prepend = function prepend (content) {
+	if (typeof content !== 'string') { throw new TypeError('outro content must be a string'); }
 
-		this.intro = content + this.intro;
-		return this;
-	},
+	this.intro = content + this.intro;
+	return this;
+};
 
-	prependLeft: function prependLeft ( index, content ) {
-		if ( typeof content !== 'string' ) { throw new TypeError( 'inserted content must be a string' ); }
+MagicString.prototype.prependLeft = function prependLeft (index, content) {
+	if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); }
 
-		this._split( index );
+	this._split(index);
 
-		var chunk = this.byEnd[ index ];
+	var chunk = this.byEnd[index];
 
-		if ( chunk ) {
-			chunk.prependLeft( content );
-		} else {
-			this.intro = content + this.intro;
-		}
+	if (chunk) {
+		chunk.prependLeft(content);
+	} else {
+		this.intro = content + this.intro;
+	}
+	return this;
+};
 
-		return this;
-	},
+MagicString.prototype.prependRight = function prependRight (index, content) {
+	if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); }
 
-	prependRight: function prependRight ( index, content ) {
-		if ( typeof content !== 'string' ) { throw new TypeError( 'inserted content must be a string' ); }
+	this._split(index);
 
-		this._split( index );
+	var chunk = this.byStart[index];
 
-		var chunk = this.byStart[ index ];
+	if (chunk) {
+		chunk.prependRight(content);
+	} else {
+		this.outro = content + this.outro;
+	}
+	return this;
+};
 
-		if ( chunk ) {
-			chunk.prependRight( content );
-		} else {
-			this.outro = content + this.outro;
-		}
+MagicString.prototype.remove = function remove (start, end) {
+	while (start < 0) { start += this.original.length; }
+	while (end < 0) { end += this.original.length; }
 
-		return this;
-	},
+	if (start === end) { return this; }
 
-	remove: function remove ( start, end ) {
-		var this$1 = this;
+	if (start < 0 || end > this.original.length) { throw new Error('Character is out of bounds'); }
+	if (start > end) { throw new Error('end must be greater than start'); }
 
-		while ( start < 0 ) { start += this$1.original.length; }
-		while ( end < 0 ) { end += this$1.original.length; }
+	this._split(start);
+	this._split(end);
 
-		if ( start === end ) { return this; }
+	var chunk = this.byStart[start];
 
-		if ( start < 0 || end > this.original.length ) { throw new Error( 'Character is out of bounds' ); }
-		if ( start > end ) { throw new Error( 'end must be greater than start' ); }
+	while (chunk) {
+		chunk.intro = '';
+		chunk.outro = '';
+		chunk.edit('');
 
-		this._split( start );
-		this._split( end );
+		chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+	}
+	return this;
+};
 
-		var chunk = this.byStart[ start ];
+MagicString.prototype.lastChar = function lastChar () {
+	if (this.outro.length)
+		{ return this.outro[this.outro.length - 1]; }
+	var chunk = this.lastChunk;
+	do {
+		if (chunk.outro.length)
+			{ return chunk.outro[chunk.outro.length - 1]; }
+		if (chunk.content.length)
+			{ return chunk.content[chunk.content.length - 1]; }
+		if (chunk.intro.length)
+			{ return chunk.intro[chunk.intro.length - 1]; }
+	} while (chunk = chunk.previous);
+	if (this.intro.length)
+		{ return this.intro[this.intro.length - 1]; }
+	return '';
+};
 
-		while ( chunk ) {
-			chunk.intro = '';
-			chunk.outro = '';
-			chunk.edit( '' );
+MagicString.prototype.lastLine = function lastLine () {
+	var lineIndex = this.outro.lastIndexOf(n);
+	if (lineIndex !== -1)
+		{ return this.outro.substr(lineIndex + 1); }
+	var lineStr = this.outro;
+	var chunk = this.lastChunk;
+	do {
+		if (chunk.outro.length > 0) {
+			lineIndex = chunk.outro.lastIndexOf(n);
+			if (lineIndex !== -1)
+				{ return chunk.outro.substr(lineIndex + 1) + lineStr; }
+			lineStr = chunk.outro + lineStr;
+		}
 
-			chunk = end > chunk.end ? this$1.byStart[ chunk.end ] : null;
+		if (chunk.content.length > 0) {
+			lineIndex = chunk.content.lastIndexOf(n);
+			if (lineIndex !== -1)
+				{ return chunk.content.substr(lineIndex + 1) + lineStr; }
+			lineStr = chunk.content + lineStr;
 		}
 
-		return this;
-	},
+		if (chunk.intro.length > 0) {
+			lineIndex = chunk.intro.lastIndexOf(n);
+			if (lineIndex !== -1)
+				{ return chunk.intro.substr(lineIndex + 1) + lineStr; }
+			lineStr = chunk.intro + lineStr;
+		}
+	} while (chunk = chunk.previous);
+	lineIndex = this.intro.lastIndexOf(n);
+	if (lineIndex !== -1)
+		{ return this.intro.substr(lineIndex + 1) + lineStr; }
+	return this.intro + lineStr;
+};
 
-	slice: function slice ( start, end ) {
-		var this$1 = this;
+MagicString.prototype.slice = function slice (start, end) {
 		if ( start === void 0 ) start = 0;
 		if ( end === void 0 ) end = this.original.length;
 
-		while ( start < 0 ) { start += this$1.original.length; }
-		while ( end < 0 ) { end += this$1.original.length; }
+	while (start < 0) { start += this.original.length; }
+	while (end < 0) { end += this.original.length; }
 
-		var result = '';
+	var result = '';
 
-		// find start chunk
-		var chunk = this.firstChunk;
-		while ( chunk && ( chunk.start > start || chunk.end <= start ) ) {
-
-			// found end chunk before start
-			if ( chunk.start < end && chunk.end >= end ) {
-				return result;
-			}
-
-			chunk = chunk.next;
+	// find start chunk
+	var chunk = this.firstChunk;
+	while (chunk && (chunk.start > start || chunk.end <= start)) {
+		// found end chunk before start
+		if (chunk.start < end && chunk.end >= end) {
+			return result;
 		}
 
-		if ( chunk && chunk.edited && chunk.start !== start ) { throw new Error(("Cannot use replaced character " + start + " as slice start anchor.")); }
+		chunk = chunk.next;
+	}
 
-		var startChunk = chunk;
-		while ( chunk ) {
-			if ( chunk.intro && ( startChunk !== chunk || chunk.start === start ) ) {
-				result += chunk.intro;
-			}
+	if (chunk && chunk.edited && chunk.start !== start)
+		{ throw new Error(("Cannot use replaced character " + start + " as slice start anchor.")); }
 
-			var containsEnd = chunk.start < end && chunk.end >= end;
-			if ( containsEnd && chunk.edited && chunk.end !== end ) { throw new Error(("Cannot use replaced character " + end + " as slice end anchor.")); }
+	var startChunk = chunk;
+	while (chunk) {
+		if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
+			result += chunk.intro;
+		}
 
-			var sliceStart = startChunk === chunk ? start - chunk.start : 0;
-			var sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+		var containsEnd = chunk.start < end && chunk.end >= end;
+		if (containsEnd && chunk.edited && chunk.end !== end)
+			{ throw new Error(("Cannot use replaced character " + end + " as slice end anchor.")); }
 
-			result += chunk.content.slice( sliceStart, sliceEnd );
+		var sliceStart = startChunk === chunk ? start - chunk.start : 0;
+		var sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
 
-			if ( chunk.outro && ( !containsEnd || chunk.end === end ) ) {
-				result += chunk.outro;
-			}
+		result += chunk.content.slice(sliceStart, sliceEnd);
 
-			if ( containsEnd ) {
-				break;
-			}
+		if (chunk.outro && (!containsEnd || chunk.end === end)) {
+			result += chunk.outro;
+		}
 
-			chunk = chunk.next;
+		if (containsEnd) {
+			break;
 		}
 
-		return result;
-	},
+		chunk = chunk.next;
+	}
 
-	// TODO deprecate this? not really very useful
-	snip: function snip ( start, end ) {
-		var clone = this.clone();
-		clone.remove( 0, start );
-		clone.remove( end, clone.original.length );
+	return result;
+};
 
-		return clone;
-	},
+// TODO deprecate this? not really very useful
+MagicString.prototype.snip = function snip (start, end) {
+	var clone = this.clone();
+	clone.remove(0, start);
+	clone.remove(end, clone.original.length);
 
-	_split: function _split ( index ) {
-		var this$1 = this;
+	return clone;
+};
 
-		if ( this.byStart[ index ] || this.byEnd[ index ] ) { return; }
+MagicString.prototype._split = function _split (index) {
+	if (this.byStart[index] || this.byEnd[index]) { return; }
 
-		var chunk = this.lastSearchedChunk;
-		var searchForward = index > chunk.end;
+	var chunk = this.lastSearchedChunk;
+	var searchForward = index > chunk.end;
 
-		while ( true ) {
-			if ( chunk.contains( index ) ) { return this$1._splitChunk( chunk, index ); }
+	while (chunk) {
+		if (chunk.contains(index)) { return this._splitChunk(chunk, index); }
 
-			chunk = searchForward ?
-				this$1.byStart[ chunk.end ] :
-				this$1.byEnd[ chunk.start ];
-		}
-	},
+		chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
+	}
+};
 
-	_splitChunk: function _splitChunk ( chunk, index ) {
-		if ( chunk.edited && chunk.content.length ) { // zero-length edited chunks are a special case (overlapping replacements)
-			var loc = getLocator( this.original )( index );
-			throw new Error( ("Cannot split a chunk that has already been edited (" + (loc.line) + ":" + (loc.column) + " – \"" + (chunk.original) + "\")") );
-		}
+MagicString.prototype._splitChunk = function _splitChunk (chunk, index) {
+	if (chunk.edited && chunk.content.length) {
+		// zero-length edited chunks are a special case (overlapping replacements)
+		var loc = getLocator(this.original)(index);
+		throw new Error(
+			("Cannot split a chunk that has already been edited (" + (loc.line) + ":" + (loc.column) + " – \"" + (chunk.original) + "\")")
+		);
+	}
 
-		var newChunk = chunk.split( index );
+	var newChunk = chunk.split(index);
 
-		this.byEnd[ index ] = chunk;
-		this.byStart[ index ] = newChunk;
-		this.byEnd[ newChunk.end ] = newChunk;
+	this.byEnd[index] = chunk;
+	this.byStart[index] = newChunk;
+	this.byEnd[newChunk.end] = newChunk;
 
-		if ( chunk === this.lastChunk ) { this.lastChunk = newChunk; }
+	if (chunk === this.lastChunk) { this.lastChunk = newChunk; }
 
-		this.lastSearchedChunk = chunk;
-		return true;
-	},
+	this.lastSearchedChunk = chunk;
+	return true;
+};
 
-	toString: function toString () {
-		var str = this.intro;
+MagicString.prototype.toString = function toString () {
+	var str = this.intro;
 
-		var chunk = this.firstChunk;
-		while ( chunk ) {
-			str += chunk.toString();
-			chunk = chunk.next;
-		}
+	var chunk = this.firstChunk;
+	while (chunk) {
+		str += chunk.toString();
+		chunk = chunk.next;
+	}
 
-		return str + this.outro;
-	},
+	return str + this.outro;
+};
 
-	trimLines: function trimLines () {
-		return this.trim('[\\r\\n]');
-	},
+MagicString.prototype.isEmpty = function isEmpty () {
+	var chunk = this.firstChunk;
+	do {
+		if (chunk.intro.length && chunk.intro.trim() ||
+				chunk.content.length && chunk.content.trim() ||
+				chunk.outro.length && chunk.outro.trim())
+			{ return false; }
+	} while (chunk = chunk.next);
+	return true;
+};
 
-	trim: function trim ( charType ) {
-		return this.trimStart( charType ).trimEnd( charType );
-	},
+MagicString.prototype.length = function length () {
+	var chunk = this.firstChunk;
+	var length = 0;
+	do {
+		length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+	} while (chunk = chunk.next);
+	return length;
+};
 
-	trimEnd: function trimEnd ( charType ) {
-		var this$1 = this;
+MagicString.prototype.trimLines = function trimLines () {
+	return this.trim('[\\r\\n]');
+};
 
-		var rx = new RegExp( ( charType || '\\s' ) + '+$' );
+MagicString.prototype.trim = function trim (charType) {
+	return this.trimStart(charType).trimEnd(charType);
+};
 
-		this.outro = this.outro.replace( rx, '' );
-		if ( this.outro.length ) { return this; }
+MagicString.prototype.trimEndAborted = function trimEndAborted (charType) {
+	var rx = new RegExp((charType || '\\s') + '+$');
 
-		var chunk = this.lastChunk;
+	this.outro = this.outro.replace(rx, '');
+	if (this.outro.length) { return true; }
 
-		do {
-			var end = chunk.end;
-			var aborted = chunk.trimEnd( rx );
+	var chunk = this.lastChunk;
 
-			// if chunk was trimmed, we have a new lastChunk
-			if ( chunk.end !== end ) {
-				if ( this$1.lastChunk === chunk ) {
-					this$1.lastChunk = chunk.next;
-				}
+	do {
+		var end = chunk.end;
+		var aborted = chunk.trimEnd(rx);
 
-				this$1.byEnd[ chunk.end ] = chunk;
-				this$1.byStart[ chunk.next.start ] = chunk.next;
-				this$1.byEnd[ chunk.next.end ] = chunk.next;
+		// if chunk was trimmed, we have a new lastChunk
+		if (chunk.end !== end) {
+			if (this.lastChunk === chunk) {
+				this.lastChunk = chunk.next;
 			}
 
-			if ( aborted ) { return this$1; }
-			chunk = chunk.previous;
-		} while ( chunk );
+			this.byEnd[chunk.end] = chunk;
+			this.byStart[chunk.next.start] = chunk.next;
+			this.byEnd[chunk.next.end] = chunk.next;
+		}
 
-		return this;
-	},
+		if (aborted) { return true; }
+		chunk = chunk.previous;
+	} while (chunk);
 
-	trimStart: function trimStart ( charType ) {
-		var this$1 = this;
+	return false;
+};
 
-		var rx = new RegExp( '^' + ( charType || '\\s' ) + '+' );
+MagicString.prototype.trimEnd = function trimEnd (charType) {
+	this.trimEndAborted(charType);
+	return this;
+};
+MagicString.prototype.trimStartAborted = function trimStartAborted (charType) {
+	var rx = new RegExp('^' + (charType || '\\s') + '+');
 
-		this.intro = this.intro.replace( rx, '' );
-		if ( this.intro.length ) { return this; }
+	this.intro = this.intro.replace(rx, '');
+	if (this.intro.length) { return true; }
 
-		var chunk = this.firstChunk;
+	var chunk = this.firstChunk;
 
-		do {
-			var end = chunk.end;
-			var aborted = chunk.trimStart( rx );
+	do {
+		var end = chunk.end;
+		var aborted = chunk.trimStart(rx);
 
-			if ( chunk.end !== end ) {
-				// special case...
-				if ( chunk === this$1.lastChunk ) { this$1.lastChunk = chunk.next; }
+		if (chunk.end !== end) {
+			// special case...
+			if (chunk === this.lastChunk) { this.lastChunk = chunk.next; }
 
-				this$1.byEnd[ chunk.end ] = chunk;
-				this$1.byStart[ chunk.next.start ] = chunk.next;
-				this$1.byEnd[ chunk.next.end ] = chunk.next;
-			}
+			this.byEnd[chunk.end] = chunk;
+			this.byStart[chunk.next.start] = chunk.next;
+			this.byEnd[chunk.next.end] = chunk.next;
+		}
 
-			if ( aborted ) { return this$1; }
-			chunk = chunk.next;
-		} while ( chunk );
+		if (aborted) { return true; }
+		chunk = chunk.next;
+	} while (chunk);
 
-		return this;
-	}
+	return false;
+};
+
+MagicString.prototype.trimStart = function trimStart (charType) {
+	this.trimStartAborted(charType);
+	return this;
 };
 
 var hasOwnProp = Object.prototype.hasOwnProperty;
 
-function Bundle ( options ) {
+var Bundle = function Bundle(options) {
 	if ( options === void 0 ) options = {};
 
 	this.intro = options.intro || '';
 	this.separator = options.separator !== undefined ? options.separator : '\n';
-
 	this.sources = [];
-
 	this.uniqueSources = [];
 	this.uniqueSourceIndexByFilename = {};
-}
+};
 
-Bundle.prototype = {
-	addSource: function addSource ( source ) {
-		if ( source instanceof MagicString$1 ) {
-			return this.addSource({
-				content: source,
-				filename: source.filename,
-				separator: this.separator
-			});
-		}
+Bundle.prototype.addSource = function addSource (source) {
+	if (source instanceof MagicString) {
+		return this.addSource({
+			content: source,
+			filename: source.filename,
+			separator: this.separator
+		});
+	}
 
-		if ( !isObject( source ) || !source.content ) {
-			throw new Error( 'bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`' );
-		}
+	if (!isObject(source) || !source.content) {
+		throw new Error('bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`');
+	}
 
-		[ 'filename', 'indentExclusionRanges', 'separator' ].forEach( function (option) {
-			if ( !hasOwnProp.call( source, option ) ) { source[ option ] = source.content[ option ]; }
-		});
+	['filename', 'indentExclusionRanges', 'separator'].forEach(function (option) {
+		if (!hasOwnProp.call(source, option)) { source[option] = source.content[option]; }
+	});
 
-		if ( source.separator === undefined ) { // TODO there's a bunch of this sort of thing, needs cleaning up
-			source.separator = this.separator;
-		}
+	if (source.separator === undefined) {
+		// TODO there's a bunch of this sort of thing, needs cleaning up
+		source.separator = this.separator;
+	}
 
-		if ( source.filename ) {
-			if ( !hasOwnProp.call( this.uniqueSourceIndexByFilename, source.filename ) ) {
-				this.uniqueSourceIndexByFilename[ source.filename ] = this.uniqueSources.length;
-				this.uniqueSources.push({ filename: source.filename, content: source.content.original });
-			} else {
-				var uniqueSource = this.uniqueSources[ this.uniqueSourceIndexByFilename[ source.filename ] ];
-				if ( source.content.original !== uniqueSource.content ) {
-					throw new Error( ("Illegal source: same filename (" + (source.filename) + "), different contents") );
-				}
+	if (source.filename) {
+		if (!hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
+			this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
+			this.uniqueSources.push({ filename: source.filename, content: source.content.original });
+		} else {
+			var uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
+			if (source.content.original !== uniqueSource.content) {
+				throw new Error(("Illegal source: same filename (" + (source.filename) + "), different contents"));
 			}
 		}
+	}
 
-		this.sources.push( source );
-		return this;
-	},
+	this.sources.push(source);
+	return this;
+};
 
-	append: function append ( str, options ) {
-		this.addSource({
-			content: new MagicString$1( str ),
-			separator: ( options && options.separator ) || ''
-		});
+Bundle.prototype.append = function append (str, options) {
+	this.addSource({
+		content: new MagicString(str),
+		separator: (options && options.separator) || ''
+	});
 
-		return this;
-	},
+	return this;
+};
 
-	clone: function clone () {
-		var bundle = new Bundle({
-			intro: this.intro,
-			separator: this.separator
-		});
+Bundle.prototype.clone = function clone () {
+	var bundle = new Bundle({
+		intro: this.intro,
+		separator: this.separator
+	});
 
-		this.sources.forEach( function (source) {
-			bundle.addSource({
-				filename: source.filename,
-				content: source.content.clone(),
-				separator: source.separator
-			});
+	this.sources.forEach(function (source) {
+		bundle.addSource({
+			filename: source.filename,
+			content: source.content.clone(),
+			separator: source.separator
 		});
+	});
 
-		return bundle;
-	},
+	return bundle;
+};
 
-	generateMap: function generateMap ( options ) {
+Bundle.prototype.generateDecodedMap = function generateDecodedMap (options) {
 		var this$1 = this;
 		if ( options === void 0 ) options = {};
 
-		var names = [];
-		this.sources.forEach( function (source) {
-			Object.keys( source.content.storedNames ).forEach( function (name) {
-				if ( !~names.indexOf( name ) ) { names.push( name ); }
-			});
+	var names = [];
+	this.sources.forEach(function (source) {
+		Object.keys(source.content.storedNames).forEach(function (name) {
+			if (!~names.indexOf(name)) { names.push(name); }
 		});
+	});
 
-		var mappings = new Mappings( options.hires );
-
-		if ( this.intro ) {
-			mappings.advance( this.intro );
-		}
-
-		this.sources.forEach( function ( source, i ) {
-			if ( i > 0 ) {
-				mappings.advance( this$1.separator );
-			}
+	var mappings = new Mappings(options.hires);
 
-			var sourceIndex = source.filename ? this$1.uniqueSourceIndexByFilename[ source.filename ] : -1;
-			var magicString = source.content;
-			var locate = getLocator( magicString.original );
+	if (this.intro) {
+		mappings.advance(this.intro);
+	}
 
-			if ( magicString.intro ) {
-				mappings.advance( magicString.intro );
-			}
+	this.sources.forEach(function (source, i) {
+		if (i > 0) {
+			mappings.advance(this$1.separator);
+		}
 
-			magicString.firstChunk.eachNext( function (chunk) {
-				var loc = locate( chunk.start );
+		var sourceIndex = source.filename ? this$1.uniqueSourceIndexByFilename[source.filename] : -1;
+		var magicString = source.content;
+		var locate = getLocator(magicString.original);
 
-				if ( chunk.intro.length ) { mappings.advance( chunk.intro ); }
+		if (magicString.intro) {
+			mappings.advance(magicString.intro);
+		}
 
-				if ( source.filename ) {
-					if ( chunk.edited ) {
-						mappings.addEdit( sourceIndex, chunk.content, chunk.original, loc, chunk.storeName ? names.indexOf( chunk.original ) : -1 );
-					} else {
-						mappings.addUneditedChunk( sourceIndex, chunk, magicString.original, loc, magicString.sourcemapLocations );
-					}
+		magicString.firstChunk.eachNext(function (chunk) {
+			var loc = locate(chunk.start);
+
+			if (chunk.intro.length) { mappings.advance(chunk.intro); }
+
+			if (source.filename) {
+				if (chunk.edited) {
+					mappings.addEdit(
+						sourceIndex,
+						chunk.content,
+						loc,
+						chunk.storeName ? names.indexOf(chunk.original) : -1
+					);
+				} else {
+					mappings.addUneditedChunk(
+						sourceIndex,
+						chunk,
+						magicString.original,
+						loc,
+						magicString.sourcemapLocations
+					);
 				}
+			} else {
+				mappings.advance(chunk.content);
+			}
 
-				else {
-					mappings.advance( chunk.content );
-				}
+			if (chunk.outro.length) { mappings.advance(chunk.outro); }
+		});
 
-				if ( chunk.outro.length ) { mappings.advance( chunk.outro ); }
-			});
+		if (magicString.outro) {
+			mappings.advance(magicString.outro);
+		}
+	});
 
-			if ( magicString.outro ) {
-				mappings.advance( magicString.outro );
-			}
-		});
+	return {
+		file: options.file ? options.file.split(/[/\\]/).pop() : null,
+		sources: this.uniqueSources.map(function (source) {
+			return options.file ? getRelativePath(options.file, source.filename) : source.filename;
+		}),
+		sourcesContent: this.uniqueSources.map(function (source) {
+			return options.includeContent ? source.content : null;
+		}),
+		names: names,
+		mappings: mappings.raw
+	};
+};
 
-		return new SourceMap({
-			file: ( options.file ? options.file.split( /[\/\\]/ ).pop() : null ),
-			sources: this.uniqueSources.map( function (source) {
-				return options.file ? getRelativePath( options.file, source.filename ) : source.filename;
-			}),
-			sourcesContent: this.uniqueSources.map( function (source) {
-				return options.includeContent ? source.content : null;
-			}),
-			names: names,
-			mappings: mappings.encode()
-		});
-	},
+Bundle.prototype.generateMap = function generateMap (options) {
+	return new SourceMap(this.generateDecodedMap(options));
+};
 
-	getIndentString: function getIndentString () {
-		var indentStringCounts = {};
+Bundle.prototype.getIndentString = function getIndentString () {
+	var indentStringCounts = {};
 
-		this.sources.forEach( function (source) {
-			var indentStr = source.content.indentStr;
+	this.sources.forEach(function (source) {
+		var indentStr = source.content.indentStr;
 
-			if ( indentStr === null ) { return; }
+		if (indentStr === null) { return; }
 
-			if ( !indentStringCounts[ indentStr ] ) { indentStringCounts[ indentStr ] = 0; }
-			indentStringCounts[ indentStr ] += 1;
-		});
+		if (!indentStringCounts[indentStr]) { indentStringCounts[indentStr] = 0; }
+		indentStringCounts[indentStr] += 1;
+	});
 
-		return ( Object.keys( indentStringCounts ).sort( function ( a, b ) {
+	return (
+		Object.keys(indentStringCounts).sort(function (a, b) {
 			return indentStringCounts[a] - indentStringCounts[b];
-		})[0] ) || '\t';
-	},
+		})[0] || '\t'
+	);
+};
 
-	indent: function indent ( indentStr ) {
+Bundle.prototype.indent = function indent (indentStr) {
 		var this$1 = this;
 
-		if ( !arguments.length ) {
-			indentStr = this.getIndentString();
-		}
-
-		if ( indentStr === '' ) { return this; } // noop
+	if (!arguments.length) {
+		indentStr = this.getIndentString();
+	}
 
-		var trailingNewline = !this.intro || this.intro.slice( -1 ) === '\n';
+	if (indentStr === '') { return this; } // noop
 
-		this.sources.forEach( function ( source, i ) {
-			var separator = source.separator !== undefined ? source.separator : this$1.separator;
-			var indentStart = trailingNewline || ( i > 0 && /\r?\n$/.test( separator ) );
+	var trailingNewline = !this.intro || this.intro.slice(-1) === '\n';
 
-			source.content.indent( indentStr, {
-				exclude: source.indentExclusionRanges,
-				indentStart: indentStart//: trailingNewline || /\r?\n$/.test( separator )  //true///\r?\n/.test( separator )
-			});
+	this.sources.forEach(function (source, i) {
+		var separator = source.separator !== undefined ? source.separator : this$1.separator;
+		var indentStart = trailingNewline || (i > 0 && /\r?\n$/.test(separator));
 
-			// TODO this is a very slow way to determine this
-			trailingNewline = source.content.toString().slice( 0, -1 ) === '\n';
+		source.content.indent(indentStr, {
+			exclude: source.indentExclusionRanges,
+			indentStart: indentStart //: trailingNewline || /\r?\n$/.test( separator )  //true///\r?\n/.test( separator )
 		});
 
-		if ( this.intro ) {
-			this.intro = indentStr + this.intro.replace( /^[^\n]/gm, function ( match, index ) {
+		trailingNewline = source.content.lastChar() === '\n';
+	});
+
+	if (this.intro) {
+		this.intro =
+			indentStr +
+			this.intro.replace(/^[^\n]/gm, function (match, index) {
 				return index > 0 ? indentStr + match : match;
 			});
-		}
+	}
 
-		return this;
-	},
+	return this;
+};
 
-	prepend: function prepend ( str ) {
-		this.intro = str + this.intro;
-		return this;
-	},
+Bundle.prototype.prepend = function prepend (str) {
+	this.intro = str + this.intro;
+	return this;
+};
 
-	toString: function toString () {
+Bundle.prototype.toString = function toString () {
 		var this$1 = this;
 
-		var body = this.sources.map( function ( source, i ) {
+	var body = this.sources
+		.map(function (source, i) {
 			var separator = source.separator !== undefined ? source.separator : this$1.separator;
-			var str = ( i > 0 ? separator : '' ) + source.content.toString();
+			var str = (i > 0 ? separator : '') + source.content.toString();
 
 			return str;
-		}).join( '' );
-
-		return this.intro + body;
-	},
-
-	trimLines: function trimLines () {
-		return this.trim('[\\r\\n]');
-	},
-
-	trim: function trim ( charType ) {
-		return this.trimStart( charType ).trimEnd( charType );
-	},
+		})
+		.join('');
 
-	trimStart: function trimStart ( charType ) {
-		var this$1 = this;
-
-		var rx = new RegExp( '^' + ( charType || '\\s' ) + '+' );
-		this.intro = this.intro.replace( rx, '' );
-
-		if ( !this.intro ) {
-			var source;
-			var i = 0;
-
-			do {
-				source = this$1.sources[i];
+	return this.intro + body;
+};
 
-				if ( !source ) {
-					break;
-				}
+Bundle.prototype.isEmpty = function isEmpty () {
+	if (this.intro.length && this.intro.trim())
+		{ return false; }
+	if (this.sources.some(function (source) { return !source.content.isEmpty(); }))
+		{ return false; }
+	return true;
+};
 
-				source.content.trimStart( charType );
-				i += 1;
-			} while ( source.content.toString() === '' ); // TODO faster way to determine non-empty source?
-		}
+Bundle.prototype.length = function length () {
+	return this.sources.reduce(function (length, source) { return length + source.content.length(); }, this.intro.length);
+};
 
-		return this;
-	},
+Bundle.prototype.trimLines = function trimLines () {
+	return this.trim('[\\r\\n]');
+};
 
-	trimEnd: function trimEnd ( charType ) {
-		var this$1 = this;
+Bundle.prototype.trim = function trim (charType) {
+	return this.trimStart(charType).trimEnd(charType);
+};
 
-		var rx = new RegExp( ( charType || '\\s' ) + '+$' );
+Bundle.prototype.trimStart = function trimStart (charType) {
+	var rx = new RegExp('^' + (charType || '\\s') + '+');
+	this.intro = this.intro.replace(rx, '');
 
+	if (!this.intro) {
 		var source;
-		var i = this.sources.length - 1;
+		var i = 0;
 
 		do {
-			source = this$1.sources[i];
-
-			if ( !source ) {
-				this$1.intro = this$1.intro.replace( rx, '' );
+			source = this.sources[i++];
+			if (!source) {
 				break;
 			}
+		} while (!source.content.trimStartAborted(charType));
+	}
+
+	return this;
+};
 
-			source.content.trimEnd( charType );
-			i -= 1;
-		} while ( source.content.toString() === '' ); // TODO faster way to determine non-empty source?
+Bundle.prototype.trimEnd = function trimEnd (charType) {
+	var rx = new RegExp((charType || '\\s') + '+$');
 
-		return this;
-	}
+	var source;
+	var i = this.sources.length - 1;
+
+	do {
+		source = this.sources[i--];
+		if (!source) {
+			this.intro = this.intro.replace(rx, '');
+			break;
+		}
+	} while (!source.content.trimEndAborted(charType));
+
+	return this;
 };
 
-MagicString$1.Bundle = Bundle;
-MagicString$1.default = MagicString$1; // work around TypeScript bug https://github.com/Rich-Harris/magic-string/pull/121
+MagicString.Bundle = Bundle;
+MagicString.default = MagicString; // work around TypeScript bug https://github.com/Rich-Harris/magic-string/pull/121
 
-module.exports = MagicString$1;
+module.exports = MagicString;
 //# sourceMappingURL=magic-string.cjs.js.map