jass-vue 0.2.1

data/vendor/node_modules/magic-string/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "magic-string",
+  "description": "Modify strings, generate sourcemaps",
+  "author": "Rich Harris",
+  "version": "0.19.1",
+  "repository": "https://github.com/rich-harris/magic-string",
+  "main": "dist/magic-string.cjs.js",
+  "module": "dist/magic-string.es.js",
+  "jsnext:main": "dist/magic-string.es.js",
+  "license": "MIT",
+  "dependencies": {
+    "vlq": "^0.2.1"
+  },
+  "devDependencies": {
+    "buble": "^0.14.0",
+    "codecov.io": "^0.1.6",
+    "console-group": "^0.3.2",
+    "eslint": "^3.7.1",
+    "istanbul": "^0.4.5",
+    "mocha": "^3.1.0",
+    "remap-istanbul": "^0.6.4",
+    "resolve": "^1.1.7",
+    "rollup": "^0.36.1",
+    "rollup-plugin-buble": "^0.14.0",
+    "rollup-plugin-node-resolve": "^2.0.0",
+    "rollup-plugin-replace": "^1.1.1",
+    "source-map": "^0.5.6",
+    "source-map-support": "^0.4.3"
+  },
+  "keywords": [
+    "string",
+    "string manipulation",
+    "sourcemap",
+    "templating",
+    "transpilation"
+  ],
+  "scripts": {
+    "test": "mocha",
+    "pretest": "npm run build:cjs",
+    "pretest-coverage": "npm run build:cjs",
+    "test-coverage": "rm -rf coverage/* && istanbul cover --report json node_modules/.bin/_mocha -- -u exports -R spec test/*.js",
+    "posttest-coverage": "remap-istanbul -i coverage/coverage-final.json -o coverage/coverage-remapped.json -b dist && remap-istanbul -i coverage/coverage-final.json -o coverage/coverage-remapped.lcov -t lcovonly -b dist && remap-istanbul -i coverage/coverage-final.json -o coverage/coverage-remapped -t html -b dist",
+    "ci": "npm run test-coverage && codecov < coverage/coverage-remapped.lcov",
+    "build:cjs": "rollup -c",
+    "build:es": "rollup -c --environment ES",
+    "build:umd": "rollup -c --environment DEPS",
+    "build": " npm run build:cjs && npm run build:es && npm run build:umd",
+    "prepublish": "rm -rf dist && npm test && npm run build:es && npm run build:umd",
+    "lint": "eslint src test",
+    "watch:cjs": "rollup -w -c",
+    "watch:es": "rollup -w -c --environment ES",
+    "watch:umd": "rollup -w -c --environment DEPS",
+    "watch": "npm run watch:es"
+  },
+  "files": [
+    "src/*",
+    "dist/*",
+    "README.md"
+  ]
+}

data/vendor/node_modules/magic-string/src/Bundle.js

@@ -0,0 +1,263 @@
+import MagicString from './MagicString.js';
+import SourceMap from './utils/SourceMap.js';
+import getRelativePath from './utils/getRelativePath.js';
+import hasOwnProp from './utils/hasOwnProp.js';
+import isObject from './utils/isObject.js';
+import getLocator from './utils/getLocator.js';
+import Mappings from './utils/Mappings.js';
+
+export default function Bundle ( options = {} ) {
+	this.intro = options.intro || '';
+	this.separator = options.separator !== undefined ? options.separator : '\n';
+
+	this.sources = [];
+
+	this.uniqueSources = [];
+	this.uniqueSourceIndexByFilename = {};
+}
+
+Bundle.prototype = {
+	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( 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 {
+				const 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 ( str, options ) {
+		this.addSource({
+			content: new MagicString( str ),
+			separator: ( options && options.separator ) || ''
+		});
+
+		return this;
+	},
+
+	clone () {
+		const bundle = new Bundle({
+			intro: this.intro,
+			separator: this.separator
+		});
+
+		this.sources.forEach( source => {
+			bundle.addSource({
+				filename: source.filename,
+				content: source.content.clone(),
+				separator: source.separator
+			});
+		});
+
+		return bundle;
+	},
+
+	generateMap ( options = {} ) {
+		const names = [];
+		this.sources.forEach( source => {
+			Object.keys( source.content.storedNames ).forEach( name => {
+				if ( !~names.indexOf( name ) ) names.push( name );
+			});
+		});
+
+		const mappings = new Mappings( options.hires );
+
+		if ( this.intro ) {
+			mappings.advance( this.intro );
+		}
+
+		this.sources.forEach( ( source, i ) => {
+			if ( i > 0 ) {
+				mappings.advance( this.separator );
+			}
+
+			const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[ source.filename ] : -1;
+			const magicString = source.content;
+			const locate = getLocator( magicString.original );
+
+			if ( magicString.intro ) {
+				mappings.advance( magicString.intro );
+			}
+
+			magicString.firstChunk.eachNext( chunk => {
+				const 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( source => {
+				return options.file ? getRelativePath( options.file, source.filename ) : source.filename;
+			}),
+			sourcesContent: this.uniqueSources.map( source => {
+				return options.includeContent ? source.content : null;
+			}),
+			names,
+			mappings: mappings.encode()
+		});
+	},
+
+	getIndentString () {
+		const indentStringCounts = {};
+
+		this.sources.forEach( source => {
+			const indentStr = source.content.indentStr;
+
+			if ( indentStr === null ) return;
+
+			if ( !indentStringCounts[ indentStr ] ) indentStringCounts[ indentStr ] = 0;
+			indentStringCounts[ indentStr ] += 1;
+		});
+
+		return ( Object.keys( indentStringCounts ).sort( ( a, b ) => {
+			return indentStringCounts[a] - indentStringCounts[b];
+		})[0] ) || '\t';
+	},
+
+	indent ( indentStr ) {
+		if ( !arguments.length ) {
+			indentStr = this.getIndentString();
+		}
+
+		if ( indentStr === '' ) return this; // noop
+
+		let trailingNewline = !this.intro || this.intro.slice( -1 ) === '\n';
+
+		this.sources.forEach( ( source, i ) => {
+			const separator = source.separator !== undefined ? source.separator : this.separator;
+			const indentStart = trailingNewline || ( i > 0 && /\r?\n$/.test( separator ) );
+
+			source.content.indent( indentStr, {
+				exclude: source.indentExclusionRanges,
+				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, ( match, index ) => {
+				return index > 0 ? indentStr + match : match;
+			});
+		}
+
+		return this;
+	},
+
+	prepend ( str ) {
+		this.intro = str + this.intro;
+		return this;
+	},
+
+	toString () {
+		const body = this.sources.map( ( source, i ) => {
+			const separator = source.separator !== undefined ? source.separator : this.separator;
+			const str = ( i > 0 ? separator : '' ) + source.content.toString();
+
+			return str;
+		}).join( '' );
+
+		return this.intro + body;
+	},
+
+	trimLines () {
+		return this.trim('[\\r\\n]');
+	},
+
+	trim ( charType ) {
+		return this.trimStart( charType ).trimEnd( charType );
+	},
+
+	trimStart ( charType ) {
+		const rx = new RegExp( '^' + ( charType || '\\s' ) + '+' );
+		this.intro = this.intro.replace( rx, '' );
+
+		if ( !this.intro ) {
+			let source;
+			let i = 0;
+
+			do {
+				source = this.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 ( charType ) {
+		const rx = new RegExp( ( charType || '\\s' ) + '+$' );
+
+		let source;
+		let i = this.sources.length - 1;
+
+		do {
+			source = this.sources[i];
+
+			if ( !source ) {
+				this.intro = this.intro.replace( rx, '' );
+				break;
+			}
+
+			source.content.trimEnd( charType );
+			i -= 1;
+		} while ( source.content.toString() === '' ); // TODO faster way to determine non-empty source?
+
+		return this;
+	}
+};

data/vendor/node_modules/magic-string/src/Chunk.js

@@ -0,0 +1,154 @@
+export default 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 ( content ) {
+		this.outro += content;
+	},
+
+	appendRight ( content ) {
+		this.intro = this.intro + content;
+	},
+
+	clone () {
+		const 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 ( index ) {
+		return this.start < index && index < this.end;
+	},
+
+	eachNext ( fn ) {
+		let chunk = this;
+		while ( chunk ) {
+			fn( chunk );
+			chunk = chunk.next;
+		}
+	},
+
+	eachPrevious ( fn ) {
+		let chunk = this;
+		while ( chunk ) {
+			fn( chunk );
+			chunk = chunk.previous;
+		}
+	},
+
+	edit ( content, storeName ) {
+		this.content = content;
+		this.intro = '';
+		this.outro = '';
+		this.storeName = storeName;
+
+		this.edited = true;
+
+		return this;
+	},
+
+	prependLeft ( content ) {
+		this.outro = content + this.outro;
+	},
+
+	prependRight ( content ) {
+		this.intro = content + this.intro;
+	},
+
+	split ( index ) {
+		const sliceIndex = index - this.start;
+
+		const originalBefore = this.original.slice( 0, sliceIndex );
+		const originalAfter = this.original.slice( sliceIndex );
+
+		this.original = originalBefore;
+
+		const 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 () {
+		return this.intro + this.content + this.outro;
+	},
+
+	trimEnd ( rx ) {
+		this.outro = this.outro.replace( rx, '' );
+		if ( this.outro.length ) return true;
+
+		const 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 ( rx ) {
+		this.intro = this.intro.replace( rx, '' );
+		if ( this.intro.length ) return true;
+
+		const 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;
+		}
+	}
+};