(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global.MagicString = factory());
}(this, function () { 'use strict';

	function Chunk ( start, end, content ) {
		this.start = start;
		this.end = end;
		this.original = content;

		this.intro = '';
		this.outro = '';

		this.content = content;
		this.storeName = false;
		this.edited = false;

		// we make these non-enumerable, for sanity while debugging
		Object.defineProperties( this, {
			previous: { writable: true, value: null },
			next: { writable: true, value: null }
		});
	}

	Chunk.prototype = {
		append: function append ( content ) {
			this.outro += content;
		},

		clone: function clone () {
			var chunk = new Chunk( this.start, this.end, this.original );

			chunk.intro = this.intro;
			chunk.outro = this.outro;
			chunk.content = this.content;
			chunk.storeName = this.storeName;
			chunk.edited = this.edited;

			return chunk;
		},

		contains: function contains ( index ) {
			return this.start < index && index < this.end;
		},

		eachNext: function eachNext ( fn ) {
			var chunk = this;
			while ( chunk ) {
				fn( chunk );
				chunk = chunk.next;
			}
		},

		eachPrevious: function eachPrevious ( fn ) {
			var chunk = this;
			while ( chunk ) {
				fn( chunk );
				chunk = chunk.previous;
			}
		},

		edit: function edit ( content, storeName ) {
			this.content = content;
			this.storeName = storeName;

			this.edited = true;

			return this;
		},

		prepend: function prepend ( content ) {
			this.intro = content + this.intro;
		},

		split: function split ( index ) {
			var sliceIndex = index - this.start;

			var originalBefore = this.original.slice( 0, sliceIndex );
			var originalAfter = this.original.slice( sliceIndex );

			this.original = originalBefore;

			var newChunk = new Chunk( index, this.end, originalAfter );
			newChunk.outro = this.outro;
			this.outro = '';

			this.end = index;

			if ( this.edited ) {
				// TODO is this block necessary?...
				newChunk.edit( '', false );
				this.content = '';
			} else {
				this.content = originalBefore;
			}

			newChunk.next = this.next;
			if ( newChunk.next ) newChunk.next.previous = newChunk;
			newChunk.previous = this;
			this.next = newChunk;

			return newChunk;
		},

		toString: function toString () {
			return this.intro + this.content + this.outro;
		},

		trimEnd: function trimEnd ( rx ) {
			this.outro = this.outro.replace( rx, '' );
			if ( this.outro.length ) return true;

			var trimmed = this.content.replace( rx, '' );

			if ( trimmed.length ) {
				if ( trimmed !== this.content ) {
					this.split( this.start + trimmed.length ).edit( '', false );
				}

				return true;
			} else {
				this.edit( '', false );

				this.intro = this.intro.replace( rx, '' );
				if ( this.intro.length ) return true;
			}
		},

		trimStart: function trimStart ( rx ) {
			this.intro = this.intro.replace( rx, '' );
			if ( this.intro.length ) return true;

			var trimmed = this.content.replace( rx, '' );

			if ( trimmed.length ) {
				if ( trimmed !== this.content ) {
					this.split( this.end - trimmed.length );
					this.edit( '', false );
				}

				return true;
			} else {
				this.edit( '', false );

				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 = _btoa;

	function SourceMap ( properties ) {
		this.version = 3;

		this.file           = properties.file;
		this.sources        = properties.sources;
		this.sourcesContent = properties.sourcesContent;
		this.names          = properties.names;
		this.mappings       = properties.mappings;
	}

	SourceMap.prototype = {
		toString: function toString () {
			return JSON.stringify( this );
		},

		toUrl: function toUrl () {
			return 'data:application/json;charset=utf-8;base64,' + btoa( this.toString() );
		}
	};

	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 ); } );

		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 ) {
			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 );

		return new Array( min + 1 ).join( ' ' );
	}

	var charToInteger = {};
	var integerToChar = {};

	'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split( '' ).forEach( function ( char, i ) {
		charToInteger[ char ] = i;
		integerToChar[ i ] = char;
	});

	function encode ( value ) {
		var result, i;

		if ( typeof value === 'number' ) {
			result = encodeInteger( value );
		} else {
			result = '';
			for ( i = 0; i < value.length; i += 1 ) {
				result += encodeInteger( value[i] );
			}
		}

		return result;
	}

	function encodeInteger ( num ) {
		var result = '', clamped;

		if ( num < 0 ) {
			num = ( -num << 1 ) | 1;
		} else {
			num <<= 1;
		}

		do {
			clamped = num & 31;
			num >>= 5;

			if ( num > 0 ) {
				clamped |= 32;
			}

			result += integerToChar[ clamped ];
		} while ( num > 0 );

		return result;
	}

	function getLocator ( source ) {
		var originalLines = source.split( '\n' );

		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;
		}

		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];
			}
		};
	}

	function encodeMappings ( original, intro, chunk, hires, sourcemapLocations, sourceIndex, offsets, names ) {
		var rawLines = [];

		var generatedCodeLine = intro.split( '\n' ).length - 1;
		var rawSegments = rawLines[ generatedCodeLine ] = [];

		var generatedCodeColumn = 0;

		var locate = getLocator( original );

		function addEdit ( content, original, loc, nameIndex, i ) {
			if ( i || content.length ) {
				rawSegments.push({
					generatedCodeLine: generatedCodeLine,
					generatedCodeColumn: generatedCodeColumn,
					sourceCodeLine: loc.line,
					sourceCodeColumn: loc.column,
					sourceCodeName: nameIndex,
					sourceIndex: sourceIndex
				});
			}

			var lines = content.split( '\n' );
			var lastLine = lines.pop();

			if ( lines.length ) {
				generatedCodeLine += lines.length;
				rawLines[ generatedCodeLine ] = rawSegments = [];
				generatedCodeColumn = lastLine.length;
			} else {
				generatedCodeColumn += lastLine.length;
			}

			lines = original.split( '\n' );
			lastLine = lines.pop();

			if ( lines.length ) {
				loc.line += lines.length;
				loc.column = lastLine.length;
			} else {
				loc.column += lastLine.length;
			}
		}

		function addUneditedChunk ( chunk, loc ) {
			var originalCharIndex = chunk.start;
			var first = true;

			while ( originalCharIndex < chunk.end ) {
				if ( hires || first || sourcemapLocations[ originalCharIndex ] ) {
					rawSegments.push({
						generatedCodeLine: generatedCodeLine,
						generatedCodeColumn: generatedCodeColumn,
						sourceCodeLine: loc.line,
						sourceCodeColumn: loc.column,
						sourceCodeName: -1,
						sourceIndex: sourceIndex
					});
				}

				if ( original[ originalCharIndex ] === '\n' ) {
					loc.line += 1;
					loc.column = 0;
					generatedCodeLine += 1;
					rawLines[ generatedCodeLine ] = rawSegments = [];
					generatedCodeColumn = 0;
				} else {
					loc.column += 1;
					generatedCodeColumn += 1;
				}

				originalCharIndex += 1;
				first = false;
			}
		}

		while ( chunk ) {
			var loc = locate( chunk.start );

			if ( chunk.intro.length ) {
				addEdit( chunk.intro, '', loc, -1, !!chunk.previous );
			}

			if ( chunk.edited ) {
				addEdit( chunk.content, chunk.original, loc, chunk.storeName ? names.indexOf( chunk.original ) : -1, !!chunk.previous );
			} else {
				addUneditedChunk( chunk, loc );
			}

			if ( chunk.outro.length ) {
				addEdit( chunk.outro, '', loc, -1, !!chunk.previous );
			}

			var nextChunk = chunk.next;
			chunk = nextChunk;
		}

		offsets.sourceIndex = offsets.sourceIndex || 0;
		offsets.sourceCodeLine = offsets.sourceCodeLine || 0;
		offsets.sourceCodeColumn = offsets.sourceCodeColumn || 0;
		offsets.sourceCodeName = offsets.sourceCodeName || 0;

		var encoded = rawLines.map( function ( segments ) {
			var generatedCodeColumn = 0;

			return segments.map( function ( segment ) {
				var arr = [
					segment.generatedCodeColumn - generatedCodeColumn,
					segment.sourceIndex - offsets.sourceIndex,
					segment.sourceCodeLine - offsets.sourceCodeLine,
					segment.sourceCodeColumn - offsets.sourceCodeColumn
				];

				generatedCodeColumn = segment.generatedCodeColumn;
				offsets.sourceIndex = segment.sourceIndex;
				offsets.sourceCodeLine = segment.sourceCodeLine;
				offsets.sourceCodeColumn = segment.sourceCodeColumn;

				if ( ~segment.sourceCodeName ) {
					arr.push( segment.sourceCodeName - offsets.sourceCodeName );
					offsets.sourceCodeName = segment.sourceCodeName;
				}

				return encode( arr );
			}).join( ',' );
		}).join( ';' );

		return encoded;
	}

	function getRelativePath ( from, to ) {
		var fromParts = from.split( /[\/\\]/ );
		var toParts = to.split( /[\/\\]/ );

		fromParts.pop(); // get dirname

		while ( fromParts[0] === toParts[0] ) {
			fromParts.shift();
			toParts.shift();
		}

		if ( fromParts.length ) {
			var i = fromParts.length;
			while ( i-- ) fromParts[i] = '..';
		}

		return fromParts.concat( toParts ).join( '/' );
	}

	var toString = Object.prototype.toString;

	function isObject ( thing ) {
		return toString.call( thing ) === '[object Object]';
	}

	function MagicString ( string, options ) {
		if ( options === void 0 ) options = {};

		var chunk = new Chunk( 0, string.length, string );

		Object.defineProperties( this, {
			original:              { writable: true, value: string },
			outro:                 { writable: true, value: '' },
			intro:                 { writable: true, value: '' },
			firstChunk:            { writable: true, value: chunk },
			lastChunk:             { writable: true, value: chunk },
			lastSearchedChunk:     { writable: true, value: chunk },
			byStart:               { writable: true, value: {} },
			byEnd:                 { writable: true, value: {} },
			filename:              { writable: true, value: options.filename },
			indentExclusionRanges: { writable: true, value: options.indentExclusionRanges },
			sourcemapLocations:    { writable: true, value: {} },
			storedNames:           { writable: true, value: {} },
			indentStr:             { writable: true, value: guessIndent( string ) }
		});

		if ( false ) {}

		this.byStart[ 0 ] = chunk;
		this.byEnd[ string.length ] = chunk;
	}

	MagicString.prototype = {
		addSourcemapLocation: function addSourcemapLocation ( char ) {
			this.sourcemapLocations[ char ] = true;
		},

		append: function append ( content ) {
			if ( typeof content !== 'string' ) throw new TypeError( 'outro content must be a string' );

			this.outro += content;
			return this;
		},

		clone: function clone () {
			var cloned = new MagicString( this.original, { filename: this.filename });

			var originalChunk = this.firstChunk;
			var clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();

			while ( originalChunk ) {
				cloned.byStart[ clonedChunk.start ] = clonedChunk;
				cloned.byEnd[ clonedChunk.end ] = clonedChunk;

				var nextOriginalChunk = originalChunk.next;
				var nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();

				if ( nextClonedChunk ) {
					clonedChunk.next = nextClonedChunk;
					nextClonedChunk.previous = clonedChunk;

					clonedChunk = nextClonedChunk;
				}

				originalChunk = nextOriginalChunk;
			}

			cloned.lastChunk = clonedChunk;

			if ( this.indentExclusionRanges ) {
				cloned.indentExclusionRanges = typeof this.indentExclusionRanges[0] === 'number' ?
					[ this.indentExclusionRanges[0], this.indentExclusionRanges[1] ] :
					this.indentExclusionRanges.map( function ( range ) { return [ range.start, range.end ]; } );
			}

			Object.keys( this.sourcemapLocations ).forEach( function ( loc ) {
				cloned.sourcemapLocations[ loc ] = true;
			});

			return cloned;
		},

		generateMap: function generateMap ( options ) {
			options = options || {};

			var names = Object.keys( this.storedNames );

			if ( false ) {}
			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: this.getMappings( options.hires, 0, {}, names )
			});
			if ( false ) {}

			return map;
		},

		getIndentString: function getIndentString () {
			return this.indentStr === null ? '\t' : this.indentStr;
		},

		getMappings: function getMappings ( hires, sourceIndex, offsets, names ) {
			return encodeMappings( this.original, this.intro, this.firstChunk, hires, this.sourcemapLocations, sourceIndex, offsets, names );
		},

		indent: function indent ( indentStr, options ) {
			var this$1 = this;

			var pattern = /^[^\r\n]/gm;

			if ( isObject( indentStr ) ) {
				options = indentStr;
				indentStr = undefined;
			}

			indentStr = indentStr !== undefined ? indentStr : ( this.indentStr || '\t' );

			if ( indentStr === '' ) return this; // noop

			options = options || {};

			// Process exclusion ranges
			var isExcluded = {};

			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;
					}
				});
			}

			var shouldIndentNextCharacter = options.indentStart !== false;
			var replacer = function ( match ) {
				if ( shouldIndentNextCharacter ) return ("" + indentStr + match);
				shouldIndentNextCharacter = true;
				return match;
			};

			this.intro = this.intro.replace( pattern, replacer );

			var charIndex = 0;

			var chunk = this.firstChunk;

			while ( chunk ) {
				var end = chunk.end;

				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';
						}
					}
				} 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.prepend( indentStr );
								} else {
									var rhs = chunk.split( charIndex );
									rhs.prepend( indentStr );

									this$1.byStart[ charIndex ] = rhs;
									this$1.byEnd[ charIndex ] = chunk;

									chunk = rhs;
								}
							}
						}

						charIndex += 1;
					}
				}

				charIndex = chunk.end;
				chunk = chunk.next;
			}

			this.outro = this.outro.replace( pattern, replacer );

			return this;
		},

		insert: function insert () {
			throw new Error( 'magicString.insert(...) is deprecated. Use insertRight(...) or insertLeft(...)' );
		},

		insertLeft: function insertLeft ( index, content ) {
			if ( typeof content !== 'string' ) throw new TypeError( 'inserted content must be a string' );

			if ( false ) {}

			this._split( index );

			var chunk = this.byEnd[ index ];

			if ( chunk ) {
				chunk.append( content );
			} else {
				this.intro += content;
			}

			if ( false ) {}
			return this;
		},

		insertRight: function insertRight ( index, content ) {
			if ( typeof content !== 'string' ) throw new TypeError( 'inserted content must be a string' );

			if ( false ) {}

			this._split( index );

			var chunk = this.byStart[ index ];

			if ( chunk ) {
				chunk.prepend( content );
			} else {
				this.outro += content;
			}

			if ( false ) {}
			return this;
		},

		move: function move ( start, end, index ) {
			if ( index >= start && index <= end ) throw new Error( 'Cannot move a selection inside itself' );

			if ( false ) {}

			this._split( start );
			this._split( end );
			this._split( index );

			var first = this.byStart[ start ];
			var last = this.byEnd[ end ];

			var oldLeft = first.previous;
			var oldRight = last.next;

			var newRight = this.byStart[ index ];
			if ( !newRight && last === this.lastChunk ) return this;
			var newLeft = newRight ? newRight.previous : this.lastChunk;

			if ( oldLeft ) oldLeft.next = oldRight;
			if ( oldRight ) oldRight.previous = oldLeft;

			if ( newLeft ) newLeft.next = first;
			if ( newRight ) newRight.previous = last;

			if ( !first.previous ) this.firstChunk = last.next;
			if ( !last.next ) {
				this.lastChunk = first.previous;
				this.lastChunk.next = null;
			}

			first.previous = newLeft;
			last.next = newRight;

			if ( !newLeft ) this.firstChunk = first;
			if ( !newRight ) this.lastChunk = last;

			if ( false ) {}
			return this;
		},

		overwrite: function overwrite ( start, end, content, storeName ) {
			var this$1 = this;

			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;

			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 insertLeft or insertRight instead' );

			if ( false ) {}

			this._split( start );
			this._split( end );

			if ( storeName ) {
				var original = this.original.slice( start, end );
				this.storedNames[ original ] = true;
			}

			var first = this.byStart[ start ];
			var last = this.byEnd[ end ];

			if ( first ) {
				first.edit( content, storeName );

				if ( first !== last ) {
					first.outro = '';

					var chunk = first.next;
					while ( chunk !== last ) {
						chunk.edit( '', false );
						chunk.intro = chunk.outro = '';
						chunk = chunk.next;
					}

					chunk.edit( '', false );
					chunk.intro = '';
				}
			}

			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;
			}

			if ( false ) {}
			return this;
		},

		prepend: function prepend ( content ) {
			if ( typeof content !== 'string' ) throw new TypeError( 'outro content must be a string' );

			this.intro = content + this.intro;
			return this;
		},

		remove: function remove ( start, end ) {
			var this$1 = this;

			while ( start < 0 ) start += this$1.original.length;
			while ( end < 0 ) end += this$1.original.length;

			if ( start === end ) return 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' );

			return this.overwrite( start, end, '', false );
		},

		slice: function slice ( start, end ) {
			var this$1 = this;
			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;

			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;
			}

			if ( chunk && chunk.edited && chunk.start !== start ) throw new Error(("Cannot use replaced character " + start + " as slice start anchor."));

			var startChunk = chunk;
			while ( chunk ) {
				if ( chunk.intro && ( startChunk !== chunk || chunk.start === start ) ) {
					result += chunk.intro;
				}

				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 sliceStart = startChunk === chunk ? start - chunk.start : 0;
				var sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;

				result += chunk.content.slice( sliceStart, sliceEnd );

				if ( chunk.outro && ( !containsEnd || chunk.end === end ) ) {
					result += chunk.outro;
				}

				if ( containsEnd ) {
					break;
				}

				chunk = chunk.next;
			}

			return result;
		},

		// 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 clone;
		},

		_split: function _split ( index ) {
			var this$1 = this;

			if ( this.byStart[ index ] || this.byEnd[ index ] ) return;

			if ( false ) {}

			var chunk = this.lastSearchedChunk;
			var searchForward = index > chunk.end;

			while ( true ) {
				if ( chunk.contains( index ) ) return this$1._splitChunk( chunk, index );

				chunk = searchForward ?
					this$1.byStart[ chunk.end ] :
					this$1.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) + "\")") );
			}

			var newChunk = chunk.split( index );

			this.byEnd[ index ] = chunk;
			this.byStart[ index ] = newChunk;
			this.byEnd[ newChunk.end ] = newChunk;

			if ( chunk === this.lastChunk ) this.lastChunk = newChunk;

			this.lastSearchedChunk = chunk;
			if ( false ) {}
			return true;
		},

		toString: function toString () {
			var str = this.intro;

			var chunk = this.firstChunk;
			while ( chunk ) {
				str += chunk.toString();
				chunk = chunk.next;
			}

			return str + this.outro;
		},

		trimLines: function trimLines () {
			return this.trim('[\\r\\n]');
		},

		trim: function trim ( charType ) {
			return this.trimStart( charType ).trimEnd( charType );
		},

		trimEnd: function trimEnd ( charType ) {
			var this$1 = this;

			var rx = new RegExp( ( charType || '\\s' ) + '+$' );

			this.outro = this.outro.replace( rx, '' );
			if ( this.outro.length ) return this;

			var chunk = this.lastChunk;

			do {
				var end = chunk.end;
				var aborted = chunk.trimEnd( rx );

				// if chunk was trimmed, we have a new lastChunk
				if ( chunk.end !== end ) {
					this$1.lastChunk = chunk.next;

					this$1.byEnd[ chunk.end ] = chunk;
					this$1.byStart[ chunk.next.start ] = chunk.next;
				}

				if ( aborted ) return this$1;
				chunk = chunk.previous;
			} while ( chunk );

			return this;
		},

		trimStart: function trimStart ( charType ) {
			var this$1 = this;

			var rx = new RegExp( '^' + ( charType || '\\s' ) + '+' );

			this.intro = this.intro.replace( rx, '' );
			if ( this.intro.length ) return this;

			var chunk = this.firstChunk;

			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;

					this$1.byEnd[ chunk.end ] = chunk;
					this$1.byStart[ chunk.next.start ] = chunk.next;
				}

				if ( aborted ) return this$1;
				chunk = chunk.next;
			} while ( chunk );

			return this;
		}
	};

	var hasOwnProp = Object.prototype.hasOwnProperty;

	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 ) {
				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`' );
			}

			[ '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.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;
		},

		append: function append ( str, options ) {
			this.addSource({
				content: new MagicString( str ),
				separator: ( options && options.separator ) || ''
			});

			return this;
		},

		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
				});
			});

			return bundle;
		},

		generateMap: function generateMap ( options ) {
			var this$1 = this;

			var offsets = {};

			var names = [];
			this.sources.forEach( function ( source ) {
				Object.keys( source.content.storedNames ).forEach( function ( name ) {
					if ( !~names.indexOf( name ) ) names.push( name );
				});
			});

			var encoded = (
				getSemis( this.intro ) +
				this.sources.map( function ( source, i ) {
					var prefix = ( i > 0 ) ? ( getSemis( source.separator ) || ',' ) : '';
					var mappings;

					// we don't bother encoding sources without a filename
					if ( !source.filename ) {
						mappings = getSemis( source.content.toString() );
					} else {
						var sourceIndex = this$1.uniqueSourceIndexByFilename[ source.filename ];
						mappings = source.content.getMappings( options.hires, sourceIndex, offsets, names );
					}

					return prefix + mappings;
				}).join( '' )
			);

			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: encoded
			});
		},

		getIndentString: function getIndentString () {
			var indentStringCounts = {};

			this.sources.forEach( function ( source ) {
				var indentStr = source.content.indentStr;

				if ( indentStr === null ) return;

				if ( !indentStringCounts[ indentStr ] ) indentStringCounts[ indentStr ] = 0;
				indentStringCounts[ indentStr ] += 1;
			});

			return ( Object.keys( indentStringCounts ).sort( function ( a, b ) {
				return indentStringCounts[a] - indentStringCounts[b];
			})[0] ) || '\t';
		},

		indent: function indent ( indentStr ) {
			var this$1 = this;

			if ( !arguments.length ) {
				indentStr = this.getIndentString();
			}

			if ( indentStr === '' ) return this; // noop

			var trailingNewline = !this.intro || this.intro.slice( -1 ) === '\n';

			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 ) );

				source.content.indent( indentStr, {
					exclude: source.indentExclusionRanges,
					indentStart: indentStart//: trailingNewline || /\r?\n$/.test( separator )  //true///\r?\n/.test( separator )
				});

				// TODO this is a very slow way to determine this
				trailingNewline = source.content.toString().slice( 0, -1 ) === '\n';
			});

			if ( this.intro ) {
				this.intro = indentStr + this.intro.replace( /^[^\n]/gm, function ( match, index ) {
					return index > 0 ? indentStr + match : match;
				});
			}

			return this;
		},

		prepend: function prepend ( str ) {
			this.intro = str + this.intro;
			return this;
		},

		toString: function toString () {
			var this$1 = this;

			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();

				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 );
		},

		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];

					if ( !source ) {
						break;
					}

					source.content.trimStart( charType );
					i += 1;
				} while ( source.content.toString() === '' ); // TODO faster way to determine non-empty source?
			}

			return this;
		},

		trimEnd: function trimEnd ( charType ) {
			var this$1 = this;

			var rx = new RegExp( ( charType || '\\s' ) + '+$' );

			var source;
			var i = this.sources.length - 1;

			do {
				source = this$1.sources[i];

				if ( !source ) {
					this$1.intro = this$1.intro.replace( rx, '' );
					break;
				}

				source.content.trimEnd( charType );
				i -= 1;
			} while ( source.content.toString() === '' ); // TODO faster way to determine non-empty source?

			return this;
		}
	};

	function getSemis ( str ) {
		return new Array( str.split( '\n' ).length ).join( ';' );
	}

	MagicString.Bundle = Bundle;

	return MagicString;

}));
//# sourceMappingURL=magic-string.umd.js.map