text: 'use strict';
  
  var vlq = require('vlq');
  
  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( ' ' );
  }
  
  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 vlq.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;
  
  module.exports = MagicString;
  //# sourceMappingURL=magic-string.cjs.js.map