jass-vue 0.2.1

data/vendor/node_modules/magic-string/dist/magic-string.es.js

@@ -0,0 +1,1283 @@
+import { encode } from '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 = {
+	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.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.intro = '';
+		this.outro = '';
+		this.storeName = storeName;
+
+		this.edited = true;
+
+		return this;
+	},
+
+	prependLeft: function prependLeft ( content ) {
+		this.outro = content + this.outro;
+	},
+
+	prependRight: function prependRight ( 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 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 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 Mappings ( hires ) {
+	var this$1 = this;
+
+	var offsets = {
+		generatedCodeColumn: 0,
+		sourceIndex: 0,
+		sourceCodeLine: 0,
+		sourceCodeColumn: 0,
+		sourceCodeName: 0
+	};
+
+	var generatedCodeLine = 0;
+	var generatedCodeColumn = 0;
+
+	this.raw = [];
+	var rawSegments = this.raw[ generatedCodeLine ] = [];
+
+	var 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 );
+		}
+
+		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
+				]);
+			}
+
+			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;
+			}
+
+			originalCharIndex += 1;
+			first = false;
+		}
+
+		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;
+		} else {
+			generatedCodeColumn += lastLine.length;
+		}
+	};
+
+	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 encode( arr );
+			}).join( ',' );
+		}).join( ';' );
+	};
+}
+
+var Stats = function Stats () {
+	Object.defineProperties( this, {
+		startTimes: { value: {} }
+	});
+};
+
+Stats.prototype.time = function time ( label ) {
+	this.startTimes[ label ] = process.hrtime();
+};
+
+Stats.prototype.timeEnd = function timeEnd ( label ) {
+	var elapsed = process.hrtime( this.startTimes[ label ] );
+
+	if ( !this[ label ] ) { this[ label ] = 0; }
+	this[ label ] += elapsed[0] * 1e3 + elapsed[1] * 1e-6;
+};
+
+var warned = {
+	insertLeft: false,
+	insertRight: false
+};
+
+function MagicString$1 ( 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 ) }
+	});
+
+	this.byStart[ 0 ] = chunk;
+	this.byEnd[ string.length ] = chunk;
+}
+
+MagicString$1.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;
+	},
+
+	appendLeft: function appendLeft ( index, content ) {
+		if ( typeof content !== 'string' ) { throw new TypeError( 'inserted content must be a string' ); }
+
+		this._split( index );
+
+		var chunk = this.byEnd[ index ];
+
+		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' ); }
+
+		this._split( 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 });
+
+		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 ) {
+		var this$1 = this;
+
+		options = options || {};
+
+		var sourceIndex = 0;
+		var names = Object.keys( this.storedNames );
+		var mappings = new Mappings( options.hires );
+
+		var locate = getLocator( this.original );
+
+		if ( this.intro ) {
+			mappings.advance( this.intro );
+		}
+
+		this.firstChunk.eachNext( function (chunk) {
+			var loc = locate( chunk.start );
+
+			if ( chunk.intro.length ) { mappings.advance( chunk.intro ); }
+
+			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.outro.length ) { mappings.advance( chunk.outro ); }
+		});
+
+		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;
+	},
+
+	getIndentString: function getIndentString () {
+		return this.indentStr === null ? '\t' : this.indentStr;
+	},
+
+	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.prependRight( indentStr );
+							} else {
+								var rhs = chunk.split( charIndex );
+								rhs.prependRight( 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 ( !warned.insertLeft ) {
+			console.warn( 'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead' ); // eslint-disable-line no-console
+			warned.insertLeft = true;
+		}
+
+		return this.appendLeft( index, content );
+	},
+
+	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;
+		}
+
+		return this.prependRight( index, content );
+	},
+
+	move: function move ( start, end, index ) {
+		if ( index >= start && index <= end ) { throw new Error( 'Cannot move a selection inside itself' ); }
+
+		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; }
+
+		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' ); }
+
+		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 ) {
+			if ( end > first.end && first.next !== this.byStart[ first.end ] ) {
+				throw new Error( 'Cannot overwrite across a split point' );
+			}
+
+			first.edit( content, storeName );
+
+			if ( last ) {
+				first.next = last.next;
+			} else {
+				first.next = null;
+				this.lastChunk = first;
+			}
+
+			first.original = this.original.slice( start, end );
+			first.end = end;
+		}
+
+		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;
+		}
+
+		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;
+	},
+
+	prependLeft: function prependLeft ( index, content ) {
+		if ( typeof content !== 'string' ) { throw new TypeError( 'inserted content must be a string' ); }
+
+		this._split( index );
+
+		var chunk = this.byEnd[ index ];
+
+		if ( chunk ) {
+			chunk.prependLeft( content );
+		} else {
+			this.intro = content + this.intro;
+		}
+
+		return this;
+	},
+
+	prependRight: function prependRight ( index, content ) {
+		if ( typeof content !== 'string' ) { throw new TypeError( 'inserted content must be a string' ); }
+
+		this._split( index );
+
+		var chunk = this.byStart[ index ];
+
+		if ( chunk ) {
+			chunk.prependRight( content );
+		} else {
+			this.outro = content + this.outro;
+		}
+
+		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' ); }
+
+		this._split( start );
+		this._split( end );
+
+		var chunk = this.byStart[ start ];
+
+		while ( chunk ) {
+			chunk.intro = '';
+			chunk.outro = '';
+			chunk.edit( '' );
+
+			chunk = end > chunk.end ? this$1.byStart[ chunk.end ] : null;
+		}
+
+		return this;
+	},
+
+	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; }
+
+		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;
+		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$1 ) {
+			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$1( 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;
+		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 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 sourceIndex = source.filename ? this$1.uniqueSourceIndexByFilename[ source.filename ] : -1;
+			var magicString = source.content;
+			var locate = getLocator( magicString.original );
+
+			if ( magicString.intro ) {
+				mappings.advance( magicString.intro );
+			}
+
+			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, chunk.original, loc, chunk.storeName ? names.indexOf( chunk.original ) : -1 );
+					} else {
+						mappings.addUneditedChunk( sourceIndex, chunk, magicString.original, loc, magicString.sourcemapLocations );
+					}
+				}
+
+				else {
+					mappings.advance( chunk.content );
+				}
+
+				if ( chunk.outro.length ) { mappings.advance( chunk.outro ); }
+			});
+
+			if ( magicString.outro ) {
+				mappings.advance( magicString.outro );
+			}
+		});
+
+		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()
+		});
+	},
+
+	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;
+	}
+};
+
+export { Bundle };export default MagicString$1;
+//# sourceMappingURL=magic-string.es.js.map