1235 lines
31 KiB
JavaScript
1235 lines
31 KiB
JavaScript
(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
|