cafe-grader-web

Location: cafe-grader-web/node_modules/magic-string/dist/magic-string.umd.js - annotation

Show More
Commit Description:
force log out when password change
Commit Description:
force log out when password change
References:
r884:490fbe2ccf0b tip algo
File last commit:
r789:8cd7e8db7e38 default
Show/Diff file:
Action:
node_modules/magic-string/dist/magic-string.umd.js | 1352 lines | 33.1 KiB | application/javascript | JavascriptLexer |
History | Source | Raw | Download
admin
move datatable to yarn
 r789 (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 = {
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, contentOnly ) {
this.content = content;
if ( !contentOnly ) {
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];
}
};
}
var charToInteger = {};
var integerToChar = {};
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split( '' ).forEach( function ( char, i ) {
charToInteger[ char ] = i;
integerToChar[ i ] = char;
});
function encode ( value ) {
var result;
if ( typeof value === 'number' ) {
result = encodeInteger( value );
} else {
result = '';
for ( var i = 0; i < value.length; i += 1 ) {
result += encodeInteger( value[i] );
}
}
return result;
}
function encodeInteger ( num ) {
var result = '';
if ( num < 0 ) {
num = ( -num << 1 ) | 1;
} else {
num <<= 1;
}
do {
var clamped = num & 31;
num >>= 5;
if ( num > 0 ) {
clamped |= 32;
}
result += integerToChar[ clamped ];
} while ( num > 0 );
return result;
}
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,
storeName: 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 = this.indentExclusionRanges.slice();
}
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 {
this$1._splitChunk( chunk, charIndex );
chunk = chunk.next;
chunk.prependRight( indentStr );
}
}
}
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 prependRight(...) or appendLeft(...)' );
},
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 || null;
if ( !newLeft ) { this.firstChunk = first; }
if ( !newRight ) { this.lastChunk = last; }
return this;
},
overwrite: function overwrite ( start, end, content, options ) {
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 appendLeft or prependRight instead' ); }
this._split( start );
this._split( end );
if ( options === true ) {
if ( !warned.storeName ) {
console.warn( 'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string' ); // eslint-disable-line no-console
warned.storeName = true;
}
options = { storeName: true };
}
var storeName = options !== undefined ? options.storeName : false;
var contentOnly = options !== undefined ? options.contentOnly : false;
if ( storeName ) {
var original = this.original.slice( start, end );
this.storedNames[ original ] = true;
}
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, contentOnly );
if ( first !== last ) {
var chunk = first.next;
while ( chunk !== last ) {
chunk.edit( '', false );
chunk = chunk.next;
}
chunk.edit( '', false );
}
}
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 ) {
if ( this$1.lastChunk === chunk ) {
this$1.lastChunk = chunk.next;
}
this$1.byEnd[ chunk.end ] = chunk;
this$1.byStart[ chunk.next.start ] = chunk.next;
this$1.byEnd[ chunk.next.end ] = chunk.next;
}
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;
this$1.byEnd[ chunk.next.end ] = 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;
}
};
MagicString$1.Bundle = Bundle;
MagicString$1.default = MagicString$1; // work around TypeScript bug https://github.com/Rich-Harris/magic-string/pull/121
return MagicString$1;
})));
//# sourceMappingURL=magic-string.umd.js.map