jass 0.9.1

data/vendor/node_modules/magic-string/index.d.ts

@@ -0,0 +1,83 @@
+export interface BundleOptions {
+  intro?: string;
+  separator?: string;
+}
+
+export interface SourceMapOptions {
+  hires: boolean;
+  file: string;
+  source: string;
+  includeContent: boolean;
+}
+
+export interface SourceMap {
+  version: string;
+  file: string;
+  sources: string[];
+  sourcesContent: string[];
+  names: string[];
+  mappings: string;
+
+  toString(): string;
+  toUrl(): string;
+}
+
+export class Bundle {
+  constructor(options?: BundleOptions);
+  addSource(source: MagicString | { filename?: string, content: MagicString }): Bundle;
+  append(str: string, options?: BundleOptions): Bundle;
+  clone(): Bundle;
+  generateMap(options?: Partial<SourceMapOptions>): SourceMap;
+  getIndentString(): string;
+  indent(indentStr?: string): Bundle;
+  indentExclusionRanges: ExclusionRange | Array<ExclusionRange>;
+  prepend(str: string): Bundle;
+  toString(): string;
+  trimLines(): Bundle;
+  trim(charType?: string): Bundle;
+  trimStart(charType?: string): Bundle;
+  trimEnd(charType?: string): Bundle;
+}
+
+export type ExclusionRange = [ number, number ];
+
+export interface MagicStringOptions {
+  filename: string,
+  indentExclusionRanges: ExclusionRange | Array<ExclusionRange>;
+}
+
+export interface IndentOptions {
+  exclude: ExclusionRange | Array<ExclusionRange>;
+  indentStart: boolean;
+}
+
+export interface OverwriteOptions {
+  storeName?: boolean;
+  contentOnly?: boolean;
+}
+
+export default class MagicString {
+  constructor(str: string, options?: MagicStringOptions);
+  addSourcemapLocation(char: number): void;
+  append(content: string): MagicString;
+  appendLeft(index: number, content: string): MagicString;
+  appendRight(index: number, content: string): MagicString;
+  clone(): MagicString;
+  generateMap(options?: Partial<SourceMapOptions>): SourceMap;
+  getIndentString(): string;
+
+  indent(options?: IndentOptions): MagicString;
+  indent(indentStr?: string, options?: IndentOptions): MagicString;
+  indentExclusionRanges: ExclusionRange | Array<ExclusionRange>;
+
+  move(start: number, end: number, index: number): MagicString;
+  overwrite(start: number, end: number, content: string, options?: boolean | OverwriteOptions): MagicString;
+  prepend(content: string): MagicString;
+  prependLeft(index: number, content: string): MagicString;
+  prependRight(index: number, content: string): MagicString;
+  remove(start: number, end: number): MagicString;
+  slice(start: number, end: number): string;
+  snip(start: number, end: number): MagicString;
+
+  original: string;
+}

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

@@ -0,0 +1,91 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(factory((global.vlq = global.vlq || {})));
+}(this, (function (exports) { 'use strict';
+
+var charToInteger = {};
+var integerToChar = {};
+
+'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split( '' ).forEach( function ( char, i ) {
+	charToInteger[ char ] = i;
+	integerToChar[ i ] = char;
+});
+
+function decode ( string ) {
+	var result = [];
+	var shift = 0;
+	var value = 0;
+
+	for ( var i = 0; i < string.length; i += 1 ) {
+		var integer = charToInteger[ string[i] ];
+
+		if ( integer === undefined ) {
+			throw new Error( 'Invalid character (' + string[i] + ')' );
+		}
+
+		var hasContinuationBit = integer & 32;
+
+		integer &= 31;
+		value += integer << shift;
+
+		if ( hasContinuationBit ) {
+			shift += 5;
+		} else {
+			var shouldNegate = value & 1;
+			value >>= 1;
+
+			result.push( shouldNegate ? -value : value );
+
+			// reset
+			value = shift = 0;
+		}
+	}
+
+	return result;
+}
+
+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;
+}
+
+exports.decode = decode;
+exports.encode = encode;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

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

@@ -0,0 +1,27 @@
+{
+  "name": "vlq",
+  "description": "Generate, and decode, base64 VLQ mappings for source maps and other uses",
+  "author": "Rich Harris",
+  "repository": "https://github.com/Rich-Harris/vlq",
+  "license": "MIT",
+  "version": "0.2.3",
+  "main": "dist/vlq.js",
+  "module": "src/vlq.js",
+  "files": [
+    "README.md",
+    "LICENSE",
+    "src/vlq.js",
+    "dist/vlq.js"
+  ],
+  "devDependencies": {
+    "eslint": "^3.19.0",
+    "rollup": "^0.41.6"
+  },
+  "scripts": {
+    "build": "rollup src/vlq.js -n vlq -f umd > dist/vlq.js",
+    "lint": "eslint src",
+    "test": "node test",
+    "pretest": "npm run build",
+    "prepublish": "npm test"
+  }
+}

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

@@ -0,0 +1,78 @@
+var charToInteger = {};
+var integerToChar = {};
+
+'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split( '' ).forEach( function ( char, i ) {
+	charToInteger[ char ] = i;
+	integerToChar[ i ] = char;
+});
+
+export function decode ( string ) {
+	var result = [];
+	var shift = 0;
+	var value = 0;
+
+	for ( var i = 0; i < string.length; i += 1 ) {
+		var integer = charToInteger[ string[i] ];
+
+		if ( integer === undefined ) {
+			throw new Error( 'Invalid character (' + string[i] + ')' );
+		}
+
+		var hasContinuationBit = integer & 32;
+
+		integer &= 31;
+		value += integer << shift;
+
+		if ( hasContinuationBit ) {
+			shift += 5;
+		} else {
+			var shouldNegate = value & 1;
+			value >>= 1;
+
+			result.push( shouldNegate ? -value : value );
+
+			// reset
+			value = shift = 0;
+		}
+	}
+
+	return result;
+}
+
+export 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;
+}

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

@@ -0,0 +1,55 @@
+{
+  "name": "magic-string",
+  "description": "Modify strings, generate sourcemaps",
+  "author": "Rich Harris",
+  "version": "0.22.5",
+  "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",
+  "typings": "index.d.ts",
+  "license": "MIT",
+  "dependencies": {
+    "vlq": "^0.2.2"
+  },
+  "devDependencies": {
+    "buble": "^0.15.2",
+    "codecov.io": "^0.1.6",
+    "console-group": "^0.3.3",
+    "eslint": "^4.5.0",
+    "istanbul": "^0.4.5",
+    "mocha": "^3.5.0",
+    "remap-istanbul": "^0.9.5",
+    "resolve": "^1.4.0",
+    "rollup": "^0.48.0",
+    "rollup-plugin-buble": "^0.15.0",
+    "rollup-plugin-node-resolve": "^3.0.0",
+    "rollup-plugin-replace": "^1.1.1",
+    "source-map": "^0.5.6",
+    "source-map-support": "^0.4.16"
+  },
+  "keywords": [
+    "string",
+    "string manipulation",
+    "sourcemap",
+    "templating",
+    "transpilation"
+  ],
+  "scripts": {
+    "test": "mocha",
+    "pretest": "npm run build",
+    "pretest-coverage": "npm run build",
+    "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": "rollup -c",
+    "prepublish": "rm -rf dist && npm test",
+    "lint": "eslint src test",
+    "watch": "rollup -cw"
+  },
+  "files": [
+    "dist/*",
+    "index.d.ts",
+    "README.md"
+  ]
+}

data/vendor/node_modules/micromatch/index.js

@@ -0,0 +1,431 @@
+/*!
+ * micromatch <https://github.com/jonschlinkert/micromatch>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+var expand = require('./lib/expand');
+var utils = require('./lib/utils');
+
+/**
+ * The main function. Pass an array of filepaths,
+ * and a string or array of glob patterns
+ *
+ * @param  {Array|String} `files`
+ * @param  {Array|String} `patterns`
+ * @param  {Object} `opts`
+ * @return {Array} Array of matches
+ */
+
+function micromatch(files, patterns, opts) {
+  if (!files || !patterns) return [];
+  opts = opts || {};
+
+  if (typeof opts.cache === 'undefined') {
+    opts.cache = true;
+  }
+
+  if (!Array.isArray(patterns)) {
+    return match(files, patterns, opts);
+  }
+
+  var len = patterns.length, i = 0;
+  var omit = [], keep = [];
+
+  while (len--) {
+    var glob = patterns[i++];
+    if (typeof glob === 'string' && glob.charCodeAt(0) === 33 /* ! */) {
+      omit.push.apply(omit, match(files, glob.slice(1), opts));
+    } else {
+      keep.push.apply(keep, match(files, glob, opts));
+    }
+  }
+  return utils.diff(keep, omit);
+}
+
+/**
+ * Return an array of files that match the given glob pattern.
+ *
+ * This function is called by the main `micromatch` function If you only
+ * need to pass a single pattern you might get very minor speed improvements
+ * using this function.
+ *
+ * @param  {Array} `files`
+ * @param  {String} `pattern`
+ * @param  {Object} `options`
+ * @return {Array}
+ */
+
+function match(files, pattern, opts) {
+  if (utils.typeOf(files) !== 'string' && !Array.isArray(files)) {
+    throw new Error(msg('match', 'files', 'a string or array'));
+  }
+
+  files = utils.arrayify(files);
+  opts = opts || {};
+
+  var negate = opts.negate || false;
+  var orig = pattern;
+
+  if (typeof pattern === 'string') {
+    negate = pattern.charAt(0) === '!';
+    if (negate) {
+      pattern = pattern.slice(1);
+    }
+
+    // we need to remove the character regardless,
+    // so the above logic is still needed
+    if (opts.nonegate === true) {
+      negate = false;
+    }
+  }
+
+  var _isMatch = matcher(pattern, opts);
+  var len = files.length, i = 0;
+  var res = [];
+
+  while (i < len) {
+    var file = files[i++];
+    var fp = utils.unixify(file, opts);
+
+    if (!_isMatch(fp)) { continue; }
+    res.push(fp);
+  }
+
+  if (res.length === 0) {
+    if (opts.failglob === true) {
+      throw new Error('micromatch.match() found no matches for: "' + orig + '".');
+    }
+
+    if (opts.nonull || opts.nullglob) {
+      res.push(utils.unescapeGlob(orig));
+    }
+  }
+
+  // if `negate` was defined, diff negated files
+  if (negate) { res = utils.diff(files, res); }
+
+  // if `ignore` was defined, diff ignored filed
+  if (opts.ignore && opts.ignore.length) {
+    pattern = opts.ignore;
+    opts = utils.omit(opts, ['ignore']);
+    res = utils.diff(res, micromatch(res, pattern, opts));
+  }
+
+  if (opts.nodupes) {
+    return utils.unique(res);
+  }
+  return res;
+}
+
+/**
+ * Returns a function that takes a glob pattern or array of glob patterns
+ * to be used with `Array#filter()`. (Internally this function generates
+ * the matching function using the [matcher] method).
+ *
+ * ```js
+ * var fn = mm.filter('[a-c]');
+ * ['a', 'b', 'c', 'd', 'e'].filter(fn);
+ * //=> ['a', 'b', 'c']
+ * ```
+ * @param  {String|Array} `patterns` Can be a glob or array of globs.
+ * @param  {Options} `opts` Options to pass to the [matcher] method.
+ * @return {Function} Filter function to be passed to `Array#filter()`.
+ */
+
+function filter(patterns, opts) {
+  if (!Array.isArray(patterns) && typeof patterns !== 'string') {
+    throw new TypeError(msg('filter', 'patterns', 'a string or array'));
+  }
+
+  patterns = utils.arrayify(patterns);
+  var len = patterns.length, i = 0;
+  var patternMatchers = Array(len);
+  while (i < len) {
+    patternMatchers[i] = matcher(patterns[i++], opts);
+  }
+
+  return function(fp) {
+    if (fp == null) return [];
+    var len = patternMatchers.length, i = 0;
+    var res = true;
+
+    fp = utils.unixify(fp, opts);
+    while (i < len) {
+      var fn = patternMatchers[i++];
+      if (!fn(fp)) {
+        res = false;
+        break;
+      }
+    }
+    return res;
+  };
+}
+
+/**
+ * Returns true if the filepath contains the given
+ * pattern. Can also return a function for matching.
+ *
+ * ```js
+ * isMatch('foo.md', '*.md', {});
+ * //=> true
+ *
+ * isMatch('*.md', {})('foo.md')
+ * //=> true
+ * ```
+ * @param  {String} `fp`
+ * @param  {String} `pattern`
+ * @param  {Object} `opts`
+ * @return {Boolean}
+ */
+
+function isMatch(fp, pattern, opts) {
+  if (typeof fp !== 'string') {
+    throw new TypeError(msg('isMatch', 'filepath', 'a string'));
+  }
+
+  fp = utils.unixify(fp, opts);
+  if (utils.typeOf(pattern) === 'object') {
+    return matcher(fp, pattern);
+  }
+  return matcher(pattern, opts)(fp);
+}
+
+/**
+ * Returns true if the filepath matches the
+ * given pattern.
+ */
+
+function contains(fp, pattern, opts) {
+  if (typeof fp !== 'string') {
+    throw new TypeError(msg('contains', 'pattern', 'a string'));
+  }
+
+  opts = opts || {};
+  opts.contains = (pattern !== '');
+  fp = utils.unixify(fp, opts);
+
+  if (opts.contains && !utils.isGlob(pattern)) {
+    return fp.indexOf(pattern) !== -1;
+  }
+  return matcher(pattern, opts)(fp);
+}
+
+/**
+ * Returns true if a file path matches any of the
+ * given patterns.
+ *
+ * @param  {String} `fp` The filepath to test.
+ * @param  {String|Array} `patterns` Glob patterns to use.
+ * @param  {Object} `opts` Options to pass to the `matcher()` function.
+ * @return {String}
+ */
+
+function any(fp, patterns, opts) {
+  if (!Array.isArray(patterns) && typeof patterns !== 'string') {
+    throw new TypeError(msg('any', 'patterns', 'a string or array'));
+  }
+
+  patterns = utils.arrayify(patterns);
+  var len = patterns.length;
+
+  fp = utils.unixify(fp, opts);
+  while (len--) {
+    var isMatch = matcher(patterns[len], opts);
+    if (isMatch(fp)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Filter the keys of an object with the given `glob` pattern
+ * and `options`
+ *
+ * @param  {Object} `object`
+ * @param  {Pattern} `object`
+ * @return {Array}
+ */
+
+function matchKeys(obj, glob, options) {
+  if (utils.typeOf(obj) !== 'object') {
+    throw new TypeError(msg('matchKeys', 'first argument', 'an object'));
+  }
+
+  var fn = matcher(glob, options);
+  var res = {};
+
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key) && fn(key)) {
+      res[key] = obj[key];
+    }
+  }
+  return res;
+}
+
+/**
+ * Return a function for matching based on the
+ * given `pattern` and `options`.
+ *
+ * @param  {String} `pattern`
+ * @param  {Object} `options`
+ * @return {Function}
+ */
+
+function matcher(pattern, opts) {
+  // pattern is a function
+  if (typeof pattern === 'function') {
+    return pattern;
+  }
+  // pattern is a regex
+  if (pattern instanceof RegExp) {
+    return function(fp) {
+      return pattern.test(fp);
+    };
+  }
+
+  if (typeof pattern !== 'string') {
+    throw new TypeError(msg('matcher', 'pattern', 'a string, regex, or function'));
+  }
+
+  // strings, all the way down...
+  pattern = utils.unixify(pattern, opts);
+
+  // pattern is a non-glob string
+  if (!utils.isGlob(pattern)) {
+    return utils.matchPath(pattern, opts);
+  }
+  // pattern is a glob string
+  var re = makeRe(pattern, opts);
+
+  // `matchBase` is defined
+  if (opts && opts.matchBase) {
+    return utils.hasFilename(re, opts);
+  }
+  // `matchBase` is not defined
+  return function(fp) {
+    fp = utils.unixify(fp, opts);
+    return re.test(fp);
+  };
+}
+
+/**
+ * Create and cache a regular expression for matching
+ * file paths.
+ *
+ * If the leading character in the `glob` is `!`, a negation
+ * regex is returned.
+ *
+ * @param  {String} `glob`
+ * @param  {Object} `options`
+ * @return {RegExp}
+ */
+
+function toRegex(glob, options) {
+  // clone options to prevent  mutating the original object
+  var opts = Object.create(options || {});
+  var flags = opts.flags || '';
+  if (opts.nocase && flags.indexOf('i') === -1) {
+    flags += 'i';
+  }
+
+  var parsed = expand(glob, opts);
+
+  // pass in tokens to avoid parsing more than once
+  opts.negated = opts.negated || parsed.negated;
+  opts.negate = opts.negated;
+  glob = wrapGlob(parsed.pattern, opts);
+  var re;
+
+  try {
+    re = new RegExp(glob, flags);
+    return re;
+  } catch (err) {
+    err.reason = 'micromatch invalid regex: (' + re + ')';
+    if (opts.strict) throw new SyntaxError(err);
+  }
+
+  // we're only here if a bad pattern was used and the user
+  // passed `options.silent`, so match nothing
+  return /$^/;
+}
+
+/**
+ * Create the regex to do the matching. If the leading
+ * character in the `glob` is `!` a negation regex is returned.
+ *
+ * @param {String} `glob`
+ * @param {Boolean} `negate`
+ */
+
+function wrapGlob(glob, opts) {
+  var prefix = (opts && !opts.contains) ? '^' : '';
+  var after = (opts && !opts.contains) ? '$' : '';
+  glob = ('(?:' + glob + ')' + after);
+  if (opts && opts.negate) {
+    return prefix + ('(?!^' + glob + ').*$');
+  }
+  return prefix + glob;
+}
+
+/**
+ * Create and cache a regular expression for matching file paths.
+ * If the leading character in the `glob` is `!`, a negation
+ * regex is returned.
+ *
+ * @param  {String} `glob`
+ * @param  {Object} `options`
+ * @return {RegExp}
+ */
+
+function makeRe(glob, opts) {
+  if (utils.typeOf(glob) !== 'string') {
+    throw new Error(msg('makeRe', 'glob', 'a string'));
+  }
+  return utils.cache(toRegex, glob, opts);
+}
+
+/**
+ * Make error messages consistent. Follows this format:
+ *
+ * ```js
+ * msg(methodName, argNumber, nativeType);
+ * // example:
+ * msg('matchKeys', 'first', 'an object');
+ * ```
+ *
+ * @param  {String} `method`
+ * @param  {String} `num`
+ * @param  {String} `type`
+ * @return {String}
+ */
+
+function msg(method, what, type) {
+  return 'micromatch.' + method + '(): ' + what + ' should be ' + type + '.';
+}
+
+/**
+ * Public methods
+ */
+
+/* eslint no-multi-spaces: 0 */
+micromatch.any       = any;
+micromatch.braces    = micromatch.braceExpand = utils.braces;
+micromatch.contains  = contains;
+micromatch.expand    = expand;
+micromatch.filter    = filter;
+micromatch.isMatch   = isMatch;
+micromatch.makeRe    = makeRe;
+micromatch.match     = match;
+micromatch.matcher   = matcher;
+micromatch.matchKeys = matchKeys;
+
+/**
+ * Expose `micromatch`
+ */
+
+module.exports = micromatch;