diff options
Diffstat (limited to 'node_modules/call-matcher')
| -rw-r--r-- | node_modules/call-matcher/CHANGELOG.md | 22 | ||||
| -rw-r--r-- | node_modules/call-matcher/MIT-LICENSE.txt | 20 | ||||
| -rw-r--r-- | node_modules/call-matcher/README.md | 197 | ||||
| -rw-r--r-- | node_modules/call-matcher/dist/call-matcher.js | 1989 | ||||
| -rw-r--r-- | node_modules/call-matcher/index.js | 195 | ||||
| -rw-r--r-- | node_modules/call-matcher/package.json | 55 |
6 files changed, 2478 insertions, 0 deletions
diff --git a/node_modules/call-matcher/CHANGELOG.md b/node_modules/call-matcher/CHANGELOG.md new file mode 100644 index 000000000..3342ad1f3 --- /dev/null +++ b/node_modules/call-matcher/CHANGELOG.md @@ -0,0 +1,22 @@ +### [1.0.1](https://github.com/twada/call-matcher/releases/tag/v1.0.1) (2016-12-31) + + +#### Bug Fixes + + * make options argument optional ([271451cb](https://github.com/twada/call-matcher/commit/271451cb037832ff2f1bc8d950847c60761178c2)) + + +## [1.0.0](https://github.com/twada/call-matcher/releases/tag/v1.0.0) (2016-05-28) + + +#### Features + + * consolidate ponyfills into core-js ([a083946c](https://github.com/twada/call-matcher/commit/a083946c26cfd236122b5298c3ea5c1facb0baca)) + + +## [0.1.0](https://github.com/twada/call-matcher/releases/tag/v0.1.0) (2015-12-23) + + +#### Features + + * initial release (extract call-matcher from escallmatch) diff --git a/node_modules/call-matcher/MIT-LICENSE.txt b/node_modules/call-matcher/MIT-LICENSE.txt new file mode 100644 index 000000000..2efbb29eb --- /dev/null +++ b/node_modules/call-matcher/MIT-LICENSE.txt @@ -0,0 +1,20 @@ +Copyright (c) 2015-2016 Takuto Wada, https://github.com/twada/call-matcher + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/call-matcher/README.md b/node_modules/call-matcher/README.md new file mode 100644 index 000000000..b7ee0b28a --- /dev/null +++ b/node_modules/call-matcher/README.md @@ -0,0 +1,197 @@ +call-matcher +================================ + +ECMAScript CallExpression matcher made from function/method signature + +[![Build Status][travis-image]][travis-url] +[![NPM version][npm-image]][npm-url] +[![Dependency Status][depstat-image]][depstat-url] +[![License][license-image]][license-url] + + +EXAMPLE +--------------------------------------- + +Creating CallExpression matcher for method signature `'assert.equal(actual, expected, [message])'`. + +Then match against `path/to/some_test.js`. + +```javascript +var CallMatcher = require('call-matcher'); +var esprima = require('esprima'); +var estraverse = require('estraverse'); +var fs = require('fs'); + +var ast = esprima.parse('assert.equal(actual, expected, [message])'); +var expression = ast.body[0].expression; +var matcher = new CallMatcher(expression); + +estraverse.traverse(esprima.parse(fs.readFileSync('path/to/some_test.js')), { + enter: function (currentNode, parentNode) { + if (matcher.test(currentNode)) { + // currentNode is a CallExpression that matches to the signature + } + var argMatched = matcher.matchArgument(currentNode, parentNode); + if (argMatched) { + if (argMatched.kind === 'mandatory') { + // mandatory arg (in this case, `actual` or `expected`) + } else if (argMatched.kind === 'optional') { + // optional arg (in this case, `message`) + } + } + } +}); +``` + +where content of `path/to/some_test.js` is: + +```javascript +var assert = require('assert'); +var anotherAssert = assert; +var equal = assert.equal.bind(assert); +var foo = '2'; +var bar = 2; + +assert.equal(foo, bar); // matches +assert.equal(bar, foo); // matches +assert.equal(foo, bar, 'foo shoule be equal to bar'); // matches (with optional arg) + +assert.equal(); // does not match (less args) +assert.equal(foo); // does not match (less args) +assert.equal(foo, bar, 'hoge', 'fuga'); // does not match (too much args) + +assert.notEqual(foo, bar); // does not match (callee method name differs) +anotherAssert.equal(foo, bar); // does not match (callee object name differs) +equal(foo, bar); // does not match (callee does not match) +``` + +`call-matcher` is a spin-off product of [power-assert](https://github.com/twada/power-assert) project. + +Pull-requests, issue reports and patches are always welcomed. + + +API +--------------------------------------- + +### var matcher = new CallMatcher(signatureAst, [options]) + +Create matcher object for a given expression. + +```javascript +var ast = esprima.parse('assert.equal(actual, expected, [message])'); +var expression = ast.body[0].expression; +var matcher = new CallMatcher(expression); +``` + +Any signature string enclosed in bracket (for example, `[message]`) means optional parameters. Without bracket means mandatory parameters. + +Returns `matcher` object having four methods, `test`, `matchArgument`, `calleeAst`, and `argumentSignatures`. + + +#### options + +an `object` for configuration options. If not passed, default options will be used. + + +#### options.visitorKeys + +| type | default value | +|:---------|:--------------| +| `object` | (return value of `estraverse.VisitorKeys`) | + +VisitorKeys for AST traversal. See [estraverse.VisitorKeys](https://github.com/estools/estraverse/blob/4.0.0/estraverse.js#L217-L288) and [babel.types.VISITOR_KEYS](https://github.com/babel/babel/blob/v5.1.11/src/babel/types/visitor-keys.json). + + +#### options.astWhiteList + +| type | default value | +|:---------|:--------------| +| `object` | N/A | + +Type and property whitelist on creating AST clone. `astWhiteList` is an object containing NodeType as keys and properties as values. + +```js +{ + ArrayExpression: ['type', 'elements'], + ArrayPattern: ['type', 'elements'], + ArrowFunctionExpression: ['type', 'id', 'params', 'body', 'generator', 'expression'], + AssignmentExpression: ['type', 'operator', 'left', 'right'], + ... +``` + + +### var isMatched = matcher.test(node) + +Tests whether `node` matches the signature or not. + + - Returns `true` if matched. + - Returns `false` if not matched. + +`node` should be an AST node object defined in [The ESTree Spec](https://github.com/estree/estree) (formerly known as [Mozilla SpiderMonkey Parser API](https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API)). + + +### var argMatched = matcher.matchArgument(node, parentNode) + +Returns match result object representing whether `node` (and its `parentNode`) matches some argument of the signature or not. + + - Returns `null` if not matched. + - If matched, returns object like `{name: 'actual', kind: 'mandatory'}`, whose `name` is an argument name in the signature and `kind` is `'mandatory'` or `'optional'`. + +`node` and `parentNode` should be AST node objects defined in [The ESTree Spec](https://github.com/estree/estree) (formerly known as [Mozilla SpiderMonkey Parser API](https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API)). + + +### var calleeAst = matcher.calleeAst() + +Returns clone of callee AST object based on signature passed to `CallMatcher` function. Returned tree is one of AST node objects defined in [The ESTree Spec](https://github.com/estree/estree) (formerly known as [Mozilla SpiderMonkey Parser API](https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API)) (in most cases, `Identifier` or `MemberExpression`). + + +### var argSigs = matcher.argumentSignatures() + +Returns array of argument signature objects based on signature passed to `CallMatcher` function. Returns array of objects like `[{name: 'actual', kind: 'mandatory'}]`, whose `name` is an argument name in the signature and `kind` is `'mandatory'` or `'optional'`. + + + +INSTALL +--------------------------------------- + +### via npm + +Install + + $ npm install --save call-matcher + + +#### use call-matcher module on browser + +`CallMatcher` function is exported + + <script type="text/javascript" src="./path/to/node_modules/call-matcher/dist/call-matcher.js"></script> + + + +CHANGELOG +--------------------------------------- +See [CHANGELOG](https://github.com/twada/call-matcher/blob/master/CHANGELOG.md) + + +AUTHOR +--------------------------------------- +* [Takuto Wada](https://github.com/twada) + + +LICENSE +--------------------------------------- +Licensed under the [MIT](https://github.com/twada/call-matcher/blob/master/MIT-LICENSE.txt) license. + + +[npm-url]: https://npmjs.org/package/call-matcher +[npm-image]: https://badge.fury.io/js/call-matcher.svg + +[travis-url]: https://travis-ci.org/twada/call-matcher +[travis-image]: https://secure.travis-ci.org/twada/call-matcher.svg?branch=master + +[depstat-url]: https://gemnasium.com/twada/call-matcher +[depstat-image]: https://gemnasium.com/twada/call-matcher.svg + +[license-url]: https://github.com/twada/call-matcher/blob/master/MIT-LICENSE.txt +[license-image]: https://img.shields.io/badge/license-MIT-brightgreen.svg diff --git a/node_modules/call-matcher/dist/call-matcher.js b/node_modules/call-matcher/dist/call-matcher.js new file mode 100644 index 000000000..bcda83672 --- /dev/null +++ b/node_modules/call-matcher/dist/call-matcher.js @@ -0,0 +1,1989 @@ +/** + * Modules in this bundle + * @license + * + * call-matcher: + * license: MIT (http://opensource.org/licenses/MIT) + * author: Takuto Wada <takuto.wada@gmail.com> + * homepage: https://github.com/twada/call-matcher + * version: 1.0.1 + * + * core-js: + * license: MIT (http://opensource.org/licenses/MIT) + * maintainers: zloirock <zloirock@zloirock.ru> + * homepage: https://github.com/zloirock/core-js#readme + * version: 2.4.1 + * + * deep-equal: + * license: MIT (http://opensource.org/licenses/MIT) + * author: James Halliday <mail@substack.net> + * maintainers: substack <mail@substack.net> + * homepage: https://github.com/substack/node-deep-equal#readme + * version: 1.0.1 + * + * espurify: + * license: MIT (http://opensource.org/licenses/MIT) + * author: Takuto Wada <takuto.wada@gmail.com> + * maintainers: twada <takuto.wada@gmail.com> + * homepage: https://github.com/estools/espurify + * version: 1.6.0 + * + * estraverse: + * license: BSD-2-Clause (http://opensource.org/licenses/BSD-2-Clause) + * maintainers: constellation <utatane.tea@gmail.com>, michaelficarra <npm@michael.ficarra.me>, nzakas <nicholas@nczconsulting.com> + * homepage: https://github.com/estools/estraverse + * version: 4.2.0 + * + * This header is generated by licensify (https://github.com/twada/licensify) + */ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.CallMatcher = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw (f.code="MODULE_NOT_FOUND", f)}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){ +/** + * call-matcher: + * ECMAScript CallExpression matcher made from function/method signature + * + * https://github.com/twada/call-matcher + * + * Copyright (c) 2015-2016 Takuto Wada + * Licensed under the MIT license. + * https://github.com/twada/call-matcher/blob/master/MIT-LICENSE.txt + */ +'use strict'; +/* jshint -W024 */ + +var estraverse = _dereq_('estraverse'); +var espurify = _dereq_('espurify'); +var syntax = estraverse.Syntax; +var hasOwn = Object.prototype.hasOwnProperty; +var forEach = _dereq_('core-js/library/fn/array/for-each'); +var map = _dereq_('core-js/library/fn/array/map'); +var filter = _dereq_('core-js/library/fn/array/filter'); +var reduce = _dereq_('core-js/library/fn/array/reduce'); +var indexOf = _dereq_('core-js/library/fn/array/index-of'); +var deepEqual = _dereq_('deep-equal'); +var notCallExprMessage = 'Argument should be in the form of CallExpression'; +var duplicatedArgMessage = 'Duplicate argument name: '; +var invalidFormMessage = 'Argument should be in the form of `name` or `[name]`'; + +function CallMatcher (signatureAst, options) { + validateApiExpression(signatureAst); + options = options || {}; + this.visitorKeys = options.visitorKeys || estraverse.VisitorKeys; + if (options.astWhiteList) { + this.purifyAst = espurify.cloneWithWhitelist(options.astWhiteList); + } else { + this.purifyAst = espurify; + } + this.signatureAst = signatureAst; + this.signatureCalleeDepth = astDepth(signatureAst.callee, this.visitorKeys); + this.numMaxArgs = this.signatureAst.arguments.length; + this.numMinArgs = filter(this.signatureAst.arguments, identifiers).length; +} + +CallMatcher.prototype.test = function (currentNode) { + var calleeMatched = this.isCalleeMatched(currentNode); + var numArgs; + if (calleeMatched) { + numArgs = currentNode.arguments.length; + return this.numMinArgs <= numArgs && numArgs <= this.numMaxArgs; + } + return false; +}; + +CallMatcher.prototype.matchArgument = function (currentNode, parentNode) { + if (isCalleeOfParent(currentNode, parentNode)) { + return null; + } + if (this.test(parentNode)) { + var indexOfCurrentArg = indexOf(parentNode.arguments, currentNode); + var numOptional = parentNode.arguments.length - this.numMinArgs; + var matchedSignatures = reduce(this.argumentSignatures(), function (accum, argSig) { + if (argSig.kind === 'mandatory') { + accum.push(argSig); + } + if (argSig.kind === 'optional' && 0 < numOptional) { + numOptional -= 1; + accum.push(argSig); + } + return accum; + }, []); + return matchedSignatures[indexOfCurrentArg]; + } + return null; +}; + +CallMatcher.prototype.calleeAst = function () { + return this.purifyAst(this.signatureAst.callee); +}; + +CallMatcher.prototype.argumentSignatures = function () { + return map(this.signatureAst.arguments, toArgumentSignature); +}; + +CallMatcher.prototype.isCalleeMatched = function (node) { + if (!isCallExpression(node)) { + return false; + } + if (!this.isSameDepthAsSignatureCallee(node.callee)) { + return false; + } + return deepEqual(this.purifyAst(this.signatureAst.callee), this.purifyAst(node.callee)); +}; + +CallMatcher.prototype.isSameDepthAsSignatureCallee = function (ast) { + var depth = this.signatureCalleeDepth; + var currentDepth = 0; + estraverse.traverse(ast, { + keys: this.visitorKeys, + enter: function (currentNode, parentNode) { + var path = this.path(); + var pathDepth = path ? path.length : 0; + if (currentDepth < pathDepth) { + currentDepth = pathDepth; + } + if (depth < currentDepth) { + this['break'](); + } + } + }); + return (depth === currentDepth); +}; + +function toArgumentSignature (argSignatureNode) { + switch(argSignatureNode.type) { + case syntax.Identifier: + return { + name: argSignatureNode.name, + kind: 'mandatory' + }; + case syntax.ArrayExpression: + return { + name: argSignatureNode.elements[0].name, + kind: 'optional' + }; + default: + return null; + } +} + +function astDepth (ast, visitorKeys) { + var maxDepth = 0; + estraverse.traverse(ast, { + keys: visitorKeys, + enter: function (currentNode, parentNode) { + var path = this.path(); + var pathDepth = path ? path.length : 0; + if (maxDepth < pathDepth) { + maxDepth = pathDepth; + } + } + }); + return maxDepth; +} + +function isCallExpression (node) { + return node && node.type === syntax.CallExpression; +} + +function isCalleeOfParent(currentNode, parentNode) { + return parentNode && currentNode && + parentNode.type === syntax.CallExpression && + parentNode.callee === currentNode; +} + +function identifiers (node) { + return node.type === syntax.Identifier; +} + +function validateApiExpression (callExpression) { + if (!callExpression || !callExpression.type) { + throw new Error(notCallExprMessage); + } + if (callExpression.type !== syntax.CallExpression) { + throw new Error(notCallExprMessage); + } + var names = {}; + forEach(callExpression.arguments, function (arg) { + var name = validateArg(arg); + if (hasOwn.call(names, name)) { + throw new Error(duplicatedArgMessage + name); + } else { + names[name] = name; + } + }); +} + +function validateArg (arg) { + var inner; + switch(arg.type) { + case syntax.Identifier: + return arg.name; + case syntax.ArrayExpression: + if (arg.elements.length !== 1) { + throw new Error(invalidFormMessage); + } + inner = arg.elements[0]; + if (inner.type !== syntax.Identifier) { + throw new Error(invalidFormMessage); + } + return inner.name; + default: + throw new Error(invalidFormMessage); + } +} + +module.exports = CallMatcher; + +},{"core-js/library/fn/array/filter":2,"core-js/library/fn/array/for-each":3,"core-js/library/fn/array/index-of":4,"core-js/library/fn/array/map":6,"core-js/library/fn/array/reduce":7,"deep-equal":60,"espurify":63,"estraverse":67}],2:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.array.filter'); +module.exports = _dereq_('../../modules/_core').Array.filter; +},{"../../modules/_core":18,"../../modules/es6.array.filter":52}],3:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.array.for-each'); +module.exports = _dereq_('../../modules/_core').Array.forEach; +},{"../../modules/_core":18,"../../modules/es6.array.for-each":53}],4:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.array.index-of'); +module.exports = _dereq_('../../modules/_core').Array.indexOf; +},{"../../modules/_core":18,"../../modules/es6.array.index-of":54}],5:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.array.is-array'); +module.exports = _dereq_('../../modules/_core').Array.isArray; +},{"../../modules/_core":18,"../../modules/es6.array.is-array":55}],6:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.array.map'); +module.exports = _dereq_('../../modules/_core').Array.map; +},{"../../modules/_core":18,"../../modules/es6.array.map":56}],7:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.array.reduce'); +module.exports = _dereq_('../../modules/_core').Array.reduce; +},{"../../modules/_core":18,"../../modules/es6.array.reduce":57}],8:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.object.assign'); +module.exports = _dereq_('../../modules/_core').Object.assign; +},{"../../modules/_core":18,"../../modules/es6.object.assign":58}],9:[function(_dereq_,module,exports){ +_dereq_('../../modules/es6.object.keys'); +module.exports = _dereq_('../../modules/_core').Object.keys; +},{"../../modules/_core":18,"../../modules/es6.object.keys":59}],10:[function(_dereq_,module,exports){ +module.exports = function(it){ + if(typeof it != 'function')throw TypeError(it + ' is not a function!'); + return it; +}; +},{}],11:[function(_dereq_,module,exports){ +var isObject = _dereq_('./_is-object'); +module.exports = function(it){ + if(!isObject(it))throw TypeError(it + ' is not an object!'); + return it; +}; +},{"./_is-object":32}],12:[function(_dereq_,module,exports){ +// false -> Array#indexOf +// true -> Array#includes +var toIObject = _dereq_('./_to-iobject') + , toLength = _dereq_('./_to-length') + , toIndex = _dereq_('./_to-index'); +module.exports = function(IS_INCLUDES){ + return function($this, el, fromIndex){ + var O = toIObject($this) + , length = toLength(O.length) + , index = toIndex(fromIndex, length) + , value; + // Array#includes uses SameValueZero equality algorithm + if(IS_INCLUDES && el != el)while(length > index){ + value = O[index++]; + if(value != value)return true; + // Array#toIndex ignores holes, Array#includes - not + } else for(;length > index; index++)if(IS_INCLUDES || index in O){ + if(O[index] === el)return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; +},{"./_to-index":44,"./_to-iobject":46,"./_to-length":47}],13:[function(_dereq_,module,exports){ +// 0 -> Array#forEach +// 1 -> Array#map +// 2 -> Array#filter +// 3 -> Array#some +// 4 -> Array#every +// 5 -> Array#find +// 6 -> Array#findIndex +var ctx = _dereq_('./_ctx') + , IObject = _dereq_('./_iobject') + , toObject = _dereq_('./_to-object') + , toLength = _dereq_('./_to-length') + , asc = _dereq_('./_array-species-create'); +module.exports = function(TYPE, $create){ + var IS_MAP = TYPE == 1 + , IS_FILTER = TYPE == 2 + , IS_SOME = TYPE == 3 + , IS_EVERY = TYPE == 4 + , IS_FIND_INDEX = TYPE == 6 + , NO_HOLES = TYPE == 5 || IS_FIND_INDEX + , create = $create || asc; + return function($this, callbackfn, that){ + var O = toObject($this) + , self = IObject(O) + , f = ctx(callbackfn, that, 3) + , length = toLength(self.length) + , index = 0 + , result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined + , val, res; + for(;length > index; index++)if(NO_HOLES || index in self){ + val = self[index]; + res = f(val, index, O); + if(TYPE){ + if(IS_MAP)result[index] = res; // map + else if(res)switch(TYPE){ + case 3: return true; // some + case 5: return val; // find + case 6: return index; // findIndex + case 2: result.push(val); // filter + } else if(IS_EVERY)return false; // every + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result; + }; +}; +},{"./_array-species-create":16,"./_ctx":19,"./_iobject":30,"./_to-length":47,"./_to-object":48}],14:[function(_dereq_,module,exports){ +var aFunction = _dereq_('./_a-function') + , toObject = _dereq_('./_to-object') + , IObject = _dereq_('./_iobject') + , toLength = _dereq_('./_to-length'); + +module.exports = function(that, callbackfn, aLen, memo, isRight){ + aFunction(callbackfn); + var O = toObject(that) + , self = IObject(O) + , length = toLength(O.length) + , index = isRight ? length - 1 : 0 + , i = isRight ? -1 : 1; + if(aLen < 2)for(;;){ + if(index in self){ + memo = self[index]; + index += i; + break; + } + index += i; + if(isRight ? index < 0 : length <= index){ + throw TypeError('Reduce of empty array with no initial value'); + } + } + for(;isRight ? index >= 0 : length > index; index += i)if(index in self){ + memo = callbackfn(memo, self[index], index, O); + } + return memo; +}; +},{"./_a-function":10,"./_iobject":30,"./_to-length":47,"./_to-object":48}],15:[function(_dereq_,module,exports){ +var isObject = _dereq_('./_is-object') + , isArray = _dereq_('./_is-array') + , SPECIES = _dereq_('./_wks')('species'); + +module.exports = function(original){ + var C; + if(isArray(original)){ + C = original.constructor; + // cross-realm fallback + if(typeof C == 'function' && (C === Array || isArray(C.prototype)))C = undefined; + if(isObject(C)){ + C = C[SPECIES]; + if(C === null)C = undefined; + } + } return C === undefined ? Array : C; +}; +},{"./_is-array":31,"./_is-object":32,"./_wks":51}],16:[function(_dereq_,module,exports){ +// 9.4.2.3 ArraySpeciesCreate(originalArray, length) +var speciesConstructor = _dereq_('./_array-species-constructor'); + +module.exports = function(original, length){ + return new (speciesConstructor(original))(length); +}; +},{"./_array-species-constructor":15}],17:[function(_dereq_,module,exports){ +var toString = {}.toString; + +module.exports = function(it){ + return toString.call(it).slice(8, -1); +}; +},{}],18:[function(_dereq_,module,exports){ +var core = module.exports = {version: '2.4.0'}; +if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef +},{}],19:[function(_dereq_,module,exports){ +// optional / simple context binding +var aFunction = _dereq_('./_a-function'); +module.exports = function(fn, that, length){ + aFunction(fn); + if(that === undefined)return fn; + switch(length){ + case 1: return function(a){ + return fn.call(that, a); + }; + case 2: return function(a, b){ + return fn.call(that, a, b); + }; + case 3: return function(a, b, c){ + return fn.call(that, a, b, c); + }; + } + return function(/* ...args */){ + return fn.apply(that, arguments); + }; +}; +},{"./_a-function":10}],20:[function(_dereq_,module,exports){ +// 7.2.1 RequireObjectCoercible(argument) +module.exports = function(it){ + if(it == undefined)throw TypeError("Can't call method on " + it); + return it; +}; +},{}],21:[function(_dereq_,module,exports){ +// Thank's IE8 for his funny defineProperty +module.exports = !_dereq_('./_fails')(function(){ + return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7; +}); +},{"./_fails":25}],22:[function(_dereq_,module,exports){ +var isObject = _dereq_('./_is-object') + , document = _dereq_('./_global').document + // in old IE typeof document.createElement is 'object' + , is = isObject(document) && isObject(document.createElement); +module.exports = function(it){ + return is ? document.createElement(it) : {}; +}; +},{"./_global":26,"./_is-object":32}],23:[function(_dereq_,module,exports){ +// IE 8- don't enum bug keys +module.exports = ( + 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' +).split(','); +},{}],24:[function(_dereq_,module,exports){ +var global = _dereq_('./_global') + , core = _dereq_('./_core') + , ctx = _dereq_('./_ctx') + , hide = _dereq_('./_hide') + , PROTOTYPE = 'prototype'; + +var $export = function(type, name, source){ + var IS_FORCED = type & $export.F + , IS_GLOBAL = type & $export.G + , IS_STATIC = type & $export.S + , IS_PROTO = type & $export.P + , IS_BIND = type & $export.B + , IS_WRAP = type & $export.W + , exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) + , expProto = exports[PROTOTYPE] + , target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE] + , key, own, out; + if(IS_GLOBAL)source = name; + for(key in source){ + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + if(own && key in exports)continue; + // export native or passed + out = own ? target[key] : source[key]; + // prevent global pollution for namespaces + exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] + // bind timers to global for call from export context + : IS_BIND && own ? ctx(out, global) + // wrap global constructors for prevent change them in library + : IS_WRAP && target[key] == out ? (function(C){ + var F = function(a, b, c){ + if(this instanceof C){ + switch(arguments.length){ + case 0: return new C; + case 1: return new C(a); + case 2: return new C(a, b); + } return new C(a, b, c); + } return C.apply(this, arguments); + }; + F[PROTOTYPE] = C[PROTOTYPE]; + return F; + // make static versions for prototype methods + })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + // export proto methods to core.%CONSTRUCTOR%.methods.%NAME% + if(IS_PROTO){ + (exports.virtual || (exports.virtual = {}))[key] = out; + // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME% + if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out); + } + } +}; +// type bitmap +$export.F = 1; // forced +$export.G = 2; // global +$export.S = 4; // static +$export.P = 8; // proto +$export.B = 16; // bind +$export.W = 32; // wrap +$export.U = 64; // safe +$export.R = 128; // real proto method for `library` +module.exports = $export; +},{"./_core":18,"./_ctx":19,"./_global":26,"./_hide":28}],25:[function(_dereq_,module,exports){ +module.exports = function(exec){ + try { + return !!exec(); + } catch(e){ + return true; + } +}; +},{}],26:[function(_dereq_,module,exports){ +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); +if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef +},{}],27:[function(_dereq_,module,exports){ +var hasOwnProperty = {}.hasOwnProperty; +module.exports = function(it, key){ + return hasOwnProperty.call(it, key); +}; +},{}],28:[function(_dereq_,module,exports){ +var dP = _dereq_('./_object-dp') + , createDesc = _dereq_('./_property-desc'); +module.exports = _dereq_('./_descriptors') ? function(object, key, value){ + return dP.f(object, key, createDesc(1, value)); +} : function(object, key, value){ + object[key] = value; + return object; +}; +},{"./_descriptors":21,"./_object-dp":34,"./_property-desc":40}],29:[function(_dereq_,module,exports){ +module.exports = !_dereq_('./_descriptors') && !_dereq_('./_fails')(function(){ + return Object.defineProperty(_dereq_('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7; +}); +},{"./_descriptors":21,"./_dom-create":22,"./_fails":25}],30:[function(_dereq_,module,exports){ +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var cof = _dereq_('./_cof'); +module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){ + return cof(it) == 'String' ? it.split('') : Object(it); +}; +},{"./_cof":17}],31:[function(_dereq_,module,exports){ +// 7.2.2 IsArray(argument) +var cof = _dereq_('./_cof'); +module.exports = Array.isArray || function isArray(arg){ + return cof(arg) == 'Array'; +}; +},{"./_cof":17}],32:[function(_dereq_,module,exports){ +module.exports = function(it){ + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; +},{}],33:[function(_dereq_,module,exports){ +'use strict'; +// 19.1.2.1 Object.assign(target, source, ...) +var getKeys = _dereq_('./_object-keys') + , gOPS = _dereq_('./_object-gops') + , pIE = _dereq_('./_object-pie') + , toObject = _dereq_('./_to-object') + , IObject = _dereq_('./_iobject') + , $assign = Object.assign; + +// should work with symbols and should have deterministic property order (V8 bug) +module.exports = !$assign || _dereq_('./_fails')(function(){ + var A = {} + , B = {} + , S = Symbol() + , K = 'abcdefghijklmnopqrst'; + A[S] = 7; + K.split('').forEach(function(k){ B[k] = k; }); + return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K; +}) ? function assign(target, source){ // eslint-disable-line no-unused-vars + var T = toObject(target) + , aLen = arguments.length + , index = 1 + , getSymbols = gOPS.f + , isEnum = pIE.f; + while(aLen > index){ + var S = IObject(arguments[index++]) + , keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S) + , length = keys.length + , j = 0 + , key; + while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key]; + } return T; +} : $assign; +},{"./_fails":25,"./_iobject":30,"./_object-gops":35,"./_object-keys":37,"./_object-pie":38,"./_to-object":48}],34:[function(_dereq_,module,exports){ +var anObject = _dereq_('./_an-object') + , IE8_DOM_DEFINE = _dereq_('./_ie8-dom-define') + , toPrimitive = _dereq_('./_to-primitive') + , dP = Object.defineProperty; + +exports.f = _dereq_('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){ + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if(IE8_DOM_DEFINE)try { + return dP(O, P, Attributes); + } catch(e){ /* empty */ } + if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!'); + if('value' in Attributes)O[P] = Attributes.value; + return O; +}; +},{"./_an-object":11,"./_descriptors":21,"./_ie8-dom-define":29,"./_to-primitive":49}],35:[function(_dereq_,module,exports){ +exports.f = Object.getOwnPropertySymbols; +},{}],36:[function(_dereq_,module,exports){ +var has = _dereq_('./_has') + , toIObject = _dereq_('./_to-iobject') + , arrayIndexOf = _dereq_('./_array-includes')(false) + , IE_PROTO = _dereq_('./_shared-key')('IE_PROTO'); + +module.exports = function(object, names){ + var O = toIObject(object) + , i = 0 + , result = [] + , key; + for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while(names.length > i)if(has(O, key = names[i++])){ + ~arrayIndexOf(result, key) || result.push(key); + } + return result; +}; +},{"./_array-includes":12,"./_has":27,"./_shared-key":41,"./_to-iobject":46}],37:[function(_dereq_,module,exports){ +// 19.1.2.14 / 15.2.3.14 Object.keys(O) +var $keys = _dereq_('./_object-keys-internal') + , enumBugKeys = _dereq_('./_enum-bug-keys'); + +module.exports = Object.keys || function keys(O){ + return $keys(O, enumBugKeys); +}; +},{"./_enum-bug-keys":23,"./_object-keys-internal":36}],38:[function(_dereq_,module,exports){ +exports.f = {}.propertyIsEnumerable; +},{}],39:[function(_dereq_,module,exports){ +// most Object methods by ES6 should accept primitives +var $export = _dereq_('./_export') + , core = _dereq_('./_core') + , fails = _dereq_('./_fails'); +module.exports = function(KEY, exec){ + var fn = (core.Object || {})[KEY] || Object[KEY] + , exp = {}; + exp[KEY] = exec(fn); + $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp); +}; +},{"./_core":18,"./_export":24,"./_fails":25}],40:[function(_dereq_,module,exports){ +module.exports = function(bitmap, value){ + return { + enumerable : !(bitmap & 1), + configurable: !(bitmap & 2), + writable : !(bitmap & 4), + value : value + }; +}; +},{}],41:[function(_dereq_,module,exports){ +var shared = _dereq_('./_shared')('keys') + , uid = _dereq_('./_uid'); +module.exports = function(key){ + return shared[key] || (shared[key] = uid(key)); +}; +},{"./_shared":42,"./_uid":50}],42:[function(_dereq_,module,exports){ +var global = _dereq_('./_global') + , SHARED = '__core-js_shared__' + , store = global[SHARED] || (global[SHARED] = {}); +module.exports = function(key){ + return store[key] || (store[key] = {}); +}; +},{"./_global":26}],43:[function(_dereq_,module,exports){ +var fails = _dereq_('./_fails'); + +module.exports = function(method, arg){ + return !!method && fails(function(){ + arg ? method.call(null, function(){}, 1) : method.call(null); + }); +}; +},{"./_fails":25}],44:[function(_dereq_,module,exports){ +var toInteger = _dereq_('./_to-integer') + , max = Math.max + , min = Math.min; +module.exports = function(index, length){ + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); +}; +},{"./_to-integer":45}],45:[function(_dereq_,module,exports){ +// 7.1.4 ToInteger +var ceil = Math.ceil + , floor = Math.floor; +module.exports = function(it){ + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); +}; +},{}],46:[function(_dereq_,module,exports){ +// to indexed object, toObject with fallback for non-array-like ES3 strings +var IObject = _dereq_('./_iobject') + , defined = _dereq_('./_defined'); +module.exports = function(it){ + return IObject(defined(it)); +}; +},{"./_defined":20,"./_iobject":30}],47:[function(_dereq_,module,exports){ +// 7.1.15 ToLength +var toInteger = _dereq_('./_to-integer') + , min = Math.min; +module.exports = function(it){ + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 +}; +},{"./_to-integer":45}],48:[function(_dereq_,module,exports){ +// 7.1.13 ToObject(argument) +var defined = _dereq_('./_defined'); +module.exports = function(it){ + return Object(defined(it)); +}; +},{"./_defined":20}],49:[function(_dereq_,module,exports){ +// 7.1.1 ToPrimitive(input [, PreferredType]) +var isObject = _dereq_('./_is-object'); +// instead of the ES6 spec version, we didn't implement @@toPrimitive case +// and the second argument - flag - preferred type is a string +module.exports = function(it, S){ + if(!isObject(it))return it; + var fn, val; + if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val; + if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val; + throw TypeError("Can't convert object to primitive value"); +}; +},{"./_is-object":32}],50:[function(_dereq_,module,exports){ +var id = 0 + , px = Math.random(); +module.exports = function(key){ + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); +}; +},{}],51:[function(_dereq_,module,exports){ +var store = _dereq_('./_shared')('wks') + , uid = _dereq_('./_uid') + , Symbol = _dereq_('./_global').Symbol + , USE_SYMBOL = typeof Symbol == 'function'; + +var $exports = module.exports = function(name){ + return store[name] || (store[name] = + USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name)); +}; + +$exports.store = store; +},{"./_global":26,"./_shared":42,"./_uid":50}],52:[function(_dereq_,module,exports){ +'use strict'; +var $export = _dereq_('./_export') + , $filter = _dereq_('./_array-methods')(2); + +$export($export.P + $export.F * !_dereq_('./_strict-method')([].filter, true), 'Array', { + // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg]) + filter: function filter(callbackfn /* , thisArg */){ + return $filter(this, callbackfn, arguments[1]); + } +}); +},{"./_array-methods":13,"./_export":24,"./_strict-method":43}],53:[function(_dereq_,module,exports){ +'use strict'; +var $export = _dereq_('./_export') + , $forEach = _dereq_('./_array-methods')(0) + , STRICT = _dereq_('./_strict-method')([].forEach, true); + +$export($export.P + $export.F * !STRICT, 'Array', { + // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg]) + forEach: function forEach(callbackfn /* , thisArg */){ + return $forEach(this, callbackfn, arguments[1]); + } +}); +},{"./_array-methods":13,"./_export":24,"./_strict-method":43}],54:[function(_dereq_,module,exports){ +'use strict'; +var $export = _dereq_('./_export') + , $indexOf = _dereq_('./_array-includes')(false) + , $native = [].indexOf + , NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0; + +$export($export.P + $export.F * (NEGATIVE_ZERO || !_dereq_('./_strict-method')($native)), 'Array', { + // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex]) + indexOf: function indexOf(searchElement /*, fromIndex = 0 */){ + return NEGATIVE_ZERO + // convert -0 to +0 + ? $native.apply(this, arguments) || 0 + : $indexOf(this, searchElement, arguments[1]); + } +}); +},{"./_array-includes":12,"./_export":24,"./_strict-method":43}],55:[function(_dereq_,module,exports){ +// 22.1.2.2 / 15.4.3.2 Array.isArray(arg) +var $export = _dereq_('./_export'); + +$export($export.S, 'Array', {isArray: _dereq_('./_is-array')}); +},{"./_export":24,"./_is-array":31}],56:[function(_dereq_,module,exports){ +'use strict'; +var $export = _dereq_('./_export') + , $map = _dereq_('./_array-methods')(1); + +$export($export.P + $export.F * !_dereq_('./_strict-method')([].map, true), 'Array', { + // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg]) + map: function map(callbackfn /* , thisArg */){ + return $map(this, callbackfn, arguments[1]); + } +}); +},{"./_array-methods":13,"./_export":24,"./_strict-method":43}],57:[function(_dereq_,module,exports){ +'use strict'; +var $export = _dereq_('./_export') + , $reduce = _dereq_('./_array-reduce'); + +$export($export.P + $export.F * !_dereq_('./_strict-method')([].reduce, true), 'Array', { + // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue]) + reduce: function reduce(callbackfn /* , initialValue */){ + return $reduce(this, callbackfn, arguments.length, arguments[1], false); + } +}); +},{"./_array-reduce":14,"./_export":24,"./_strict-method":43}],58:[function(_dereq_,module,exports){ +// 19.1.3.1 Object.assign(target, source) +var $export = _dereq_('./_export'); + +$export($export.S + $export.F, 'Object', {assign: _dereq_('./_object-assign')}); +},{"./_export":24,"./_object-assign":33}],59:[function(_dereq_,module,exports){ +// 19.1.2.14 Object.keys(O) +var toObject = _dereq_('./_to-object') + , $keys = _dereq_('./_object-keys'); + +_dereq_('./_object-sap')('keys', function(){ + return function keys(it){ + return $keys(toObject(it)); + }; +}); +},{"./_object-keys":37,"./_object-sap":39,"./_to-object":48}],60:[function(_dereq_,module,exports){ +var pSlice = Array.prototype.slice; +var objectKeys = _dereq_('./lib/keys.js'); +var isArguments = _dereq_('./lib/is_arguments.js'); + +var deepEqual = module.exports = function (actual, expected, opts) { + if (!opts) opts = {}; + // 7.1. All identical values are equivalent, as determined by ===. + if (actual === expected) { + return true; + + } else if (actual instanceof Date && expected instanceof Date) { + return actual.getTime() === expected.getTime(); + + // 7.3. Other pairs that do not both pass typeof value == 'object', + // equivalence is determined by ==. + } else if (!actual || !expected || typeof actual != 'object' && typeof expected != 'object') { + return opts.strict ? actual === expected : actual == expected; + + // 7.4. For all other Object pairs, including Array objects, equivalence is + // determined by having the same number of owned properties (as verified + // with Object.prototype.hasOwnProperty.call), the same set of keys + // (although not necessarily the same order), equivalent values for every + // corresponding key, and an identical 'prototype' property. Note: this + // accounts for both named and indexed properties on Arrays. + } else { + return objEquiv(actual, expected, opts); + } +} + +function isUndefinedOrNull(value) { + return value === null || value === undefined; +} + +function isBuffer (x) { + if (!x || typeof x !== 'object' || typeof x.length !== 'number') return false; + if (typeof x.copy !== 'function' || typeof x.slice !== 'function') { + return false; + } + if (x.length > 0 && typeof x[0] !== 'number') return false; + return true; +} + +function objEquiv(a, b, opts) { + var i, key; + if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) + return false; + // an identical 'prototype' property. + if (a.prototype !== b.prototype) return false; + //~~~I've managed to break Object.keys through screwy arguments passing. + // Converting to array solves the problem. + if (isArguments(a)) { + if (!isArguments(b)) { + return false; + } + a = pSlice.call(a); + b = pSlice.call(b); + return deepEqual(a, b, opts); + } + if (isBuffer(a)) { + if (!isBuffer(b)) { + return false; + } + if (a.length !== b.length) return false; + for (i = 0; i < a.length; i++) { + if (a[i] !== b[i]) return false; + } + return true; + } + try { + var ka = objectKeys(a), + kb = objectKeys(b); + } catch (e) {//happens when one is a string literal and the other isn't + return false; + } + // having the same number of owned properties (keys incorporates + // hasOwnProperty) + if (ka.length != kb.length) + return false; + //the same set of keys (although not necessarily the same order), + ka.sort(); + kb.sort(); + //~~~cheap key test + for (i = ka.length - 1; i >= 0; i--) { + if (ka[i] != kb[i]) + return false; + } + //equivalent values for every corresponding key, and + //~~~possibly expensive deep test + for (i = ka.length - 1; i >= 0; i--) { + key = ka[i]; + if (!deepEqual(a[key], b[key], opts)) return false; + } + return typeof a === typeof b; +} + +},{"./lib/is_arguments.js":61,"./lib/keys.js":62}],61:[function(_dereq_,module,exports){ +var supportsArgumentsClass = (function(){ + return Object.prototype.toString.call(arguments) +})() == '[object Arguments]'; + +exports = module.exports = supportsArgumentsClass ? supported : unsupported; + +exports.supported = supported; +function supported(object) { + return Object.prototype.toString.call(object) == '[object Arguments]'; +}; + +exports.unsupported = unsupported; +function unsupported(object){ + return object && + typeof object == 'object' && + typeof object.length == 'number' && + Object.prototype.hasOwnProperty.call(object, 'callee') && + !Object.prototype.propertyIsEnumerable.call(object, 'callee') || + false; +}; + +},{}],62:[function(_dereq_,module,exports){ +exports = module.exports = typeof Object.keys === 'function' + ? Object.keys : shim; + +exports.shim = shim; +function shim (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +} + +},{}],63:[function(_dereq_,module,exports){ +/** + * espurify - Clone new AST without extra properties + * + * https://github.com/estools/espurify + * + * Copyright (c) 2014-2016 Takuto Wada + * Licensed under the MIT license. + * https://github.com/estools/espurify/blob/master/MIT-LICENSE.txt + */ +'use strict'; + +var createWhitelist = _dereq_('./lib/create-whitelist'); +var cloneWithWhitelist = _dereq_('./lib/clone-ast'); + +function createCloneFunction (options) { + return cloneWithWhitelist(createWhitelist(options)); +} + +var espurify = createCloneFunction(); +espurify.customize = createCloneFunction; +espurify.cloneWithWhitelist = cloneWithWhitelist; +module.exports = espurify; + +},{"./lib/clone-ast":65,"./lib/create-whitelist":66}],64:[function(_dereq_,module,exports){ +module.exports = { + ArrayExpression: ['type', 'elements'], + ArrayPattern: ['type', 'elements'], + ArrowFunctionExpression: ['type', 'id', 'params', 'body', 'generator', 'expression'], + AssignmentExpression: ['type', 'operator', 'left', 'right'], + AssignmentPattern: ['type', 'left', 'right'], + BinaryExpression: ['type', 'operator', 'left', 'right'], + BlockStatement: ['type', 'body'], + BreakStatement: ['type', 'label'], + CallExpression: ['type', 'callee', 'arguments'], + CatchClause: ['type', 'param', 'guard', 'body'], + ClassBody: ['type', 'body'], + ClassDeclaration: ['type', 'id', 'superClass', 'body'], + ClassExpression: ['type', 'id', 'superClass', 'body'], + ConditionalExpression: ['type', 'test', 'alternate', 'consequent'], + ContinueStatement: ['type', 'label'], + DebuggerStatement: ['type'], + DoWhileStatement: ['type', 'body', 'test'], + EmptyStatement: ['type'], + ExportAllDeclaration: ['type', 'source'], + ExportDefaultDeclaration: ['type', 'declaration'], + ExportNamedDeclaration: ['type', 'declaration', 'specifiers', 'source'], + ExportSpecifier: ['type', 'exported', 'local'], + ExpressionStatement: ['type', 'expression'], + ForInStatement: ['type', 'left', 'right', 'body'], + ForOfStatement: ['type', 'left', 'right', 'body'], + ForStatement: ['type', 'init', 'test', 'update', 'body'], + FunctionDeclaration: ['type', 'id', 'params', 'body', 'generator'], + FunctionExpression: ['type', 'id', 'params', 'body', 'generator'], + Identifier: ['type', 'name'], + IfStatement: ['type', 'test', 'consequent', 'alternate'], + ImportDeclaration: ['type', 'specifiers', 'source'], + ImportDefaultSpecifier: ['type', 'local'], + ImportNamespaceSpecifier: ['type', 'local'], + ImportSpecifier: ['type', 'imported', 'local'], + LabeledStatement: ['type', 'label', 'body'], + Literal: ['type', 'value', 'regex'], + LogicalExpression: ['type', 'operator', 'left', 'right'], + MemberExpression: ['type', 'object', 'property', 'computed'], + MetaProperty: ['type', 'meta', 'property'], + MethodDefinition: ['type', 'key', 'value', 'kind', 'computed', 'static'], + NewExpression: ['type', 'callee', 'arguments'], + ObjectExpression: ['type', 'properties'], + ObjectPattern: ['type', 'properties'], + Program: ['type', 'body', 'sourceType'], + Property: ['type', 'key', 'value', 'kind', 'method', 'shorthand', 'computed'], + RestElement: ['type', 'argument'], + ReturnStatement: ['type', 'argument'], + SequenceExpression: ['type', 'expressions'], + SpreadElement: ['type', 'argument'], + Super: ['type'], + SwitchCase: ['type', 'test', 'consequent'], + SwitchStatement: ['type', 'discriminant', 'cases', 'lexical'], + TaggedTemplateExpression: ['type', 'tag', 'quasi'], + TemplateElement: ['type', 'tail', 'value'], + TemplateLiteral: ['type', 'quasis', 'expressions'], + ThisExpression: ['type'], + ThrowStatement: ['type', 'argument'], + TryStatement: ['type', 'block', 'handler', 'finalizer'], + UnaryExpression: ['type', 'operator', 'prefix', 'argument'], + UpdateExpression: ['type', 'operator', 'argument', 'prefix'], + VariableDeclaration: ['type', 'declarations', 'kind'], + VariableDeclarator: ['type', 'id', 'init'], + WhileStatement: ['type', 'test', 'body'], + WithStatement: ['type', 'object', 'body'], + YieldExpression: ['type', 'argument', 'delegate'] +}; + +},{}],65:[function(_dereq_,module,exports){ +'use strict'; + +var isArray = _dereq_('core-js/library/fn/array/is-array'); +var objectKeys = _dereq_('core-js/library/fn/object/keys'); +var indexOf = _dereq_('core-js/library/fn/array/index-of'); +var reduce = _dereq_('core-js/library/fn/array/reduce'); + +module.exports = function cloneWithWhitelist (astWhiteList) { + var whitelist = reduce(objectKeys(astWhiteList), function (props, key) { + var propNames = astWhiteList[key]; + var prepend = (indexOf(propNames, 'type') === -1) ? ['type'] : []; + props[key] = prepend.concat(propNames); + return props; + }, {}); + + function cloneNodeOrObject (obj) { + var props = obj.type ? whitelist[obj.type] : null; + if (props) { + return cloneNode(obj, props); + } else { + return cloneObject(obj); + } + } + + function cloneArray (ary) { + var i = ary.length, clone = []; + while (i--) { + clone[i] = cloneOf(ary[i]); + } + return clone; + } + + function cloneNode (node, props) { + var i, len, key, clone = {}; + for (i = 0, len = props.length; i < len; i += 1) { + key = props[i]; + if (node.hasOwnProperty(key)) { + clone[key] = cloneOf(node[key]); + } + } + return clone; + } + + function cloneObject (obj) { + var props = objectKeys(obj); + var i, len, key, clone = {}; + for (i = 0, len = props.length; i < len; i += 1) { + key = props[i]; + clone[key] = cloneOf(obj[key]); + } + return clone; + } + + function cloneOf (val) { + if (typeof val === 'object' && val !== null) { + if (val instanceof RegExp) { + return new RegExp(val); + } else if (isArray(val)) { + return cloneArray(val); + } else { + return cloneNodeOrObject(val); + } + } else { + return val; + } + } + + return cloneNodeOrObject; +}; + +},{"core-js/library/fn/array/index-of":4,"core-js/library/fn/array/is-array":5,"core-js/library/fn/array/reduce":7,"core-js/library/fn/object/keys":9}],66:[function(_dereq_,module,exports){ +'use strict'; + +var defaultProps = _dereq_('./ast-properties'); +var objectKeys = _dereq_('core-js/library/fn/object/keys'); +var assign = _dereq_('core-js/library/fn/object/assign'); + +module.exports = function createWhitelist (options) { + var opts = assign({}, options); + var typeName, i, len; + var keys = objectKeys(defaultProps); + var result = {}; + for (i = 0, len = keys.length; i < len; i += 1) { + typeName = keys[i]; + result[typeName] = defaultProps[typeName].concat(opts.extra); + } + return result; +}; + +},{"./ast-properties":64,"core-js/library/fn/object/assign":8,"core-js/library/fn/object/keys":9}],67:[function(_dereq_,module,exports){ +/* + Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com> + Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com> + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/*jslint vars:false, bitwise:true*/ +/*jshint indent:4*/ +/*global exports:true*/ +(function clone(exports) { + 'use strict'; + + var Syntax, + isArray, + VisitorOption, + VisitorKeys, + objectCreate, + objectKeys, + BREAK, + SKIP, + REMOVE; + + function ignoreJSHintError() { } + + isArray = Array.isArray; + if (!isArray) { + isArray = function isArray(array) { + return Object.prototype.toString.call(array) === '[object Array]'; + }; + } + + function deepCopy(obj) { + var ret = {}, key, val; + for (key in obj) { + if (obj.hasOwnProperty(key)) { + val = obj[key]; + if (typeof val === 'object' && val !== null) { + ret[key] = deepCopy(val); + } else { + ret[key] = val; + } + } + } + return ret; + } + + function shallowCopy(obj) { + var ret = {}, key; + for (key in obj) { + if (obj.hasOwnProperty(key)) { + ret[key] = obj[key]; + } + } + return ret; + } + ignoreJSHintError(shallowCopy); + + // based on LLVM libc++ upper_bound / lower_bound + // MIT License + + function upperBound(array, func) { + var diff, len, i, current; + + len = array.length; + i = 0; + + while (len) { + diff = len >>> 1; + current = i + diff; + if (func(array[current])) { + len = diff; + } else { + i = current + 1; + len -= diff + 1; + } + } + return i; + } + + function lowerBound(array, func) { + var diff, len, i, current; + + len = array.length; + i = 0; + + while (len) { + diff = len >>> 1; + current = i + diff; + if (func(array[current])) { + i = current + 1; + len -= diff + 1; + } else { + len = diff; + } + } + return i; + } + ignoreJSHintError(lowerBound); + + objectCreate = Object.create || (function () { + function F() { } + + return function (o) { + F.prototype = o; + return new F(); + }; + })(); + + objectKeys = Object.keys || function (o) { + var keys = [], key; + for (key in o) { + keys.push(key); + } + return keys; + }; + + function extend(to, from) { + var keys = objectKeys(from), key, i, len; + for (i = 0, len = keys.length; i < len; i += 1) { + key = keys[i]; + to[key] = from[key]; + } + return to; + } + + Syntax = { + AssignmentExpression: 'AssignmentExpression', + AssignmentPattern: 'AssignmentPattern', + ArrayExpression: 'ArrayExpression', + ArrayPattern: 'ArrayPattern', + ArrowFunctionExpression: 'ArrowFunctionExpression', + AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7. + BlockStatement: 'BlockStatement', + BinaryExpression: 'BinaryExpression', + BreakStatement: 'BreakStatement', + CallExpression: 'CallExpression', + CatchClause: 'CatchClause', + ClassBody: 'ClassBody', + ClassDeclaration: 'ClassDeclaration', + ClassExpression: 'ClassExpression', + ComprehensionBlock: 'ComprehensionBlock', // CAUTION: It's deferred to ES7. + ComprehensionExpression: 'ComprehensionExpression', // CAUTION: It's deferred to ES7. + ConditionalExpression: 'ConditionalExpression', + ContinueStatement: 'ContinueStatement', + DebuggerStatement: 'DebuggerStatement', + DirectiveStatement: 'DirectiveStatement', + DoWhileStatement: 'DoWhileStatement', + EmptyStatement: 'EmptyStatement', + ExportAllDeclaration: 'ExportAllDeclaration', + ExportDefaultDeclaration: 'ExportDefaultDeclaration', + ExportNamedDeclaration: 'ExportNamedDeclaration', + ExportSpecifier: 'ExportSpecifier', + ExpressionStatement: 'ExpressionStatement', + ForStatement: 'ForStatement', + ForInStatement: 'ForInStatement', + ForOfStatement: 'ForOfStatement', + FunctionDeclaration: 'FunctionDeclaration', + FunctionExpression: 'FunctionExpression', + GeneratorExpression: 'GeneratorExpression', // CAUTION: It's deferred to ES7. + Identifier: 'Identifier', + IfStatement: 'IfStatement', + ImportDeclaration: 'ImportDeclaration', + ImportDefaultSpecifier: 'ImportDefaultSpecifier', + ImportNamespaceSpecifier: 'ImportNamespaceSpecifier', + ImportSpecifier: 'ImportSpecifier', + Literal: 'Literal', + LabeledStatement: 'LabeledStatement', + LogicalExpression: 'LogicalExpression', + MemberExpression: 'MemberExpression', + MetaProperty: 'MetaProperty', + MethodDefinition: 'MethodDefinition', + ModuleSpecifier: 'ModuleSpecifier', + NewExpression: 'NewExpression', + ObjectExpression: 'ObjectExpression', + ObjectPattern: 'ObjectPattern', + Program: 'Program', + Property: 'Property', + RestElement: 'RestElement', + ReturnStatement: 'ReturnStatement', + SequenceExpression: 'SequenceExpression', + SpreadElement: 'SpreadElement', + Super: 'Super', + SwitchStatement: 'SwitchStatement', + SwitchCase: 'SwitchCase', + TaggedTemplateExpression: 'TaggedTemplateExpression', + TemplateElement: 'TemplateElement', + TemplateLiteral: 'TemplateLiteral', + ThisExpression: 'ThisExpression', + ThrowStatement: 'ThrowStatement', + TryStatement: 'TryStatement', + UnaryExpression: 'UnaryExpression', + UpdateExpression: 'UpdateExpression', + VariableDeclaration: 'VariableDeclaration', + VariableDeclarator: 'VariableDeclarator', + WhileStatement: 'WhileStatement', + WithStatement: 'WithStatement', + YieldExpression: 'YieldExpression' + }; + + VisitorKeys = { + AssignmentExpression: ['left', 'right'], + AssignmentPattern: ['left', 'right'], + ArrayExpression: ['elements'], + ArrayPattern: ['elements'], + ArrowFunctionExpression: ['params', 'body'], + AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7. + BlockStatement: ['body'], + BinaryExpression: ['left', 'right'], + BreakStatement: ['label'], + CallExpression: ['callee', 'arguments'], + CatchClause: ['param', 'body'], + ClassBody: ['body'], + ClassDeclaration: ['id', 'superClass', 'body'], + ClassExpression: ['id', 'superClass', 'body'], + ComprehensionBlock: ['left', 'right'], // CAUTION: It's deferred to ES7. + ComprehensionExpression: ['blocks', 'filter', 'body'], // CAUTION: It's deferred to ES7. + ConditionalExpression: ['test', 'consequent', 'alternate'], + ContinueStatement: ['label'], + DebuggerStatement: [], + DirectiveStatement: [], + DoWhileStatement: ['body', 'test'], + EmptyStatement: [], + ExportAllDeclaration: ['source'], + ExportDefaultDeclaration: ['declaration'], + ExportNamedDeclaration: ['declaration', 'specifiers', 'source'], + ExportSpecifier: ['exported', 'local'], + ExpressionStatement: ['expression'], + ForStatement: ['init', 'test', 'update', 'body'], + ForInStatement: ['left', 'right', 'body'], + ForOfStatement: ['left', 'right', 'body'], + FunctionDeclaration: ['id', 'params', 'body'], + FunctionExpression: ['id', 'params', 'body'], + GeneratorExpression: ['blocks', 'filter', 'body'], // CAUTION: It's deferred to ES7. + Identifier: [], + IfStatement: ['test', 'consequent', 'alternate'], + ImportDeclaration: ['specifiers', 'source'], + ImportDefaultSpecifier: ['local'], + ImportNamespaceSpecifier: ['local'], + ImportSpecifier: ['imported', 'local'], + Literal: [], + LabeledStatement: ['label', 'body'], + LogicalExpression: ['left', 'right'], + MemberExpression: ['object', 'property'], + MetaProperty: ['meta', 'property'], + MethodDefinition: ['key', 'value'], + ModuleSpecifier: [], + NewExpression: ['callee', 'arguments'], + ObjectExpression: ['properties'], + ObjectPattern: ['properties'], + Program: ['body'], + Property: ['key', 'value'], + RestElement: [ 'argument' ], + ReturnStatement: ['argument'], + SequenceExpression: ['expressions'], + SpreadElement: ['argument'], + Super: [], + SwitchStatement: ['discriminant', 'cases'], + SwitchCase: ['test', 'consequent'], + TaggedTemplateExpression: ['tag', 'quasi'], + TemplateElement: [], + TemplateLiteral: ['quasis', 'expressions'], + ThisExpression: [], + ThrowStatement: ['argument'], + TryStatement: ['block', 'handler', 'finalizer'], + UnaryExpression: ['argument'], + UpdateExpression: ['argument'], + VariableDeclaration: ['declarations'], + VariableDeclarator: ['id', 'init'], + WhileStatement: ['test', 'body'], + WithStatement: ['object', 'body'], + YieldExpression: ['argument'] + }; + + // unique id + BREAK = {}; + SKIP = {}; + REMOVE = {}; + + VisitorOption = { + Break: BREAK, + Skip: SKIP, + Remove: REMOVE + }; + + function Reference(parent, key) { + this.parent = parent; + this.key = key; + } + + Reference.prototype.replace = function replace(node) { + this.parent[this.key] = node; + }; + + Reference.prototype.remove = function remove() { + if (isArray(this.parent)) { + this.parent.splice(this.key, 1); + return true; + } else { + this.replace(null); + return false; + } + }; + + function Element(node, path, wrap, ref) { + this.node = node; + this.path = path; + this.wrap = wrap; + this.ref = ref; + } + + function Controller() { } + + // API: + // return property path array from root to current node + Controller.prototype.path = function path() { + var i, iz, j, jz, result, element; + + function addToPath(result, path) { + if (isArray(path)) { + for (j = 0, jz = path.length; j < jz; ++j) { + result.push(path[j]); + } + } else { + result.push(path); + } + } + + // root node + if (!this.__current.path) { + return null; + } + + // first node is sentinel, second node is root element + result = []; + for (i = 2, iz = this.__leavelist.length; i < iz; ++i) { + element = this.__leavelist[i]; + addToPath(result, element.path); + } + addToPath(result, this.__current.path); + return result; + }; + + // API: + // return type of current node + Controller.prototype.type = function () { + var node = this.current(); + return node.type || this.__current.wrap; + }; + + // API: + // return array of parent elements + Controller.prototype.parents = function parents() { + var i, iz, result; + + // first node is sentinel + result = []; + for (i = 1, iz = this.__leavelist.length; i < iz; ++i) { + result.push(this.__leavelist[i].node); + } + + return result; + }; + + // API: + // return current node + Controller.prototype.current = function current() { + return this.__current.node; + }; + + Controller.prototype.__execute = function __execute(callback, element) { + var previous, result; + + result = undefined; + + previous = this.__current; + this.__current = element; + this.__state = null; + if (callback) { + result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node); + } + this.__current = previous; + + return result; + }; + + // API: + // notify control skip / break + Controller.prototype.notify = function notify(flag) { + this.__state = flag; + }; + + // API: + // skip child nodes of current node + Controller.prototype.skip = function () { + this.notify(SKIP); + }; + + // API: + // break traversals + Controller.prototype['break'] = function () { + this.notify(BREAK); + }; + + // API: + // remove node + Controller.prototype.remove = function () { + this.notify(REMOVE); + }; + + Controller.prototype.__initialize = function(root, visitor) { + this.visitor = visitor; + this.root = root; + this.__worklist = []; + this.__leavelist = []; + this.__current = null; + this.__state = null; + this.__fallback = null; + if (visitor.fallback === 'iteration') { + this.__fallback = objectKeys; + } else if (typeof visitor.fallback === 'function') { + this.__fallback = visitor.fallback; + } + + this.__keys = VisitorKeys; + if (visitor.keys) { + this.__keys = extend(objectCreate(this.__keys), visitor.keys); + } + }; + + function isNode(node) { + if (node == null) { + return false; + } + return typeof node === 'object' && typeof node.type === 'string'; + } + + function isProperty(nodeType, key) { + return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key; + } + + Controller.prototype.traverse = function traverse(root, visitor) { + var worklist, + leavelist, + element, + node, + nodeType, + ret, + key, + current, + current2, + candidates, + candidate, + sentinel; + + this.__initialize(root, visitor); + + sentinel = {}; + + // reference + worklist = this.__worklist; + leavelist = this.__leavelist; + + // initialize + worklist.push(new Element(root, null, null, null)); + leavelist.push(new Element(null, null, null, null)); + + while (worklist.length) { + element = worklist.pop(); + + if (element === sentinel) { + element = leavelist.pop(); + + ret = this.__execute(visitor.leave, element); + + if (this.__state === BREAK || ret === BREAK) { + return; + } + continue; + } + + if (element.node) { + + ret = this.__execute(visitor.enter, element); + + if (this.__state === BREAK || ret === BREAK) { + return; + } + + worklist.push(sentinel); + leavelist.push(element); + + if (this.__state === SKIP || ret === SKIP) { + continue; + } + + node = element.node; + nodeType = node.type || element.wrap; + candidates = this.__keys[nodeType]; + if (!candidates) { + if (this.__fallback) { + candidates = this.__fallback(node); + } else { + throw new Error('Unknown node type ' + nodeType + '.'); + } + } + + current = candidates.length; + while ((current -= 1) >= 0) { + key = candidates[current]; + candidate = node[key]; + if (!candidate) { + continue; + } + + if (isArray(candidate)) { + current2 = candidate.length; + while ((current2 -= 1) >= 0) { + if (!candidate[current2]) { + continue; + } + if (isProperty(nodeType, candidates[current])) { + element = new Element(candidate[current2], [key, current2], 'Property', null); + } else if (isNode(candidate[current2])) { + element = new Element(candidate[current2], [key, current2], null, null); + } else { + continue; + } + worklist.push(element); + } + } else if (isNode(candidate)) { + worklist.push(new Element(candidate, key, null, null)); + } + } + } + } + }; + + Controller.prototype.replace = function replace(root, visitor) { + var worklist, + leavelist, + node, + nodeType, + target, + element, + current, + current2, + candidates, + candidate, + sentinel, + outer, + key; + + function removeElem(element) { + var i, + key, + nextElem, + parent; + + if (element.ref.remove()) { + // When the reference is an element of an array. + key = element.ref.key; + parent = element.ref.parent; + + // If removed from array, then decrease following items' keys. + i = worklist.length; + while (i--) { + nextElem = worklist[i]; + if (nextElem.ref && nextElem.ref.parent === parent) { + if (nextElem.ref.key < key) { + break; + } + --nextElem.ref.key; + } + } + } + } + + this.__initialize(root, visitor); + + sentinel = {}; + + // reference + worklist = this.__worklist; + leavelist = this.__leavelist; + + // initialize + outer = { + root: root + }; + element = new Element(root, null, null, new Reference(outer, 'root')); + worklist.push(element); + leavelist.push(element); + + while (worklist.length) { + element = worklist.pop(); + + if (element === sentinel) { + element = leavelist.pop(); + + target = this.__execute(visitor.leave, element); + + // node may be replaced with null, + // so distinguish between undefined and null in this place + if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) { + // replace + element.ref.replace(target); + } + + if (this.__state === REMOVE || target === REMOVE) { + removeElem(element); + } + + if (this.__state === BREAK || target === BREAK) { + return outer.root; + } + continue; + } + + target = this.__execute(visitor.enter, element); + + // node may be replaced with null, + // so distinguish between undefined and null in this place + if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) { + // replace + element.ref.replace(target); + element.node = target; + } + + if (this.__state === REMOVE || target === REMOVE) { + removeElem(element); + element.node = null; + } + + if (this.__state === BREAK || target === BREAK) { + return outer.root; + } + + // node may be null + node = element.node; + if (!node) { + continue; + } + + worklist.push(sentinel); + leavelist.push(element); + + if (this.__state === SKIP || target === SKIP) { + continue; + } + + nodeType = node.type || element.wrap; + candidates = this.__keys[nodeType]; + if (!candidates) { + if (this.__fallback) { + candidates = this.__fallback(node); + } else { + throw new Error('Unknown node type ' + nodeType + '.'); + } + } + + current = candidates.length; + while ((current -= 1) >= 0) { + key = candidates[current]; + candidate = node[key]; + if (!candidate) { + continue; + } + + if (isArray(candidate)) { + current2 = candidate.length; + while ((current2 -= 1) >= 0) { + if (!candidate[current2]) { + continue; + } + if (isProperty(nodeType, candidates[current])) { + element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2)); + } else if (isNode(candidate[current2])) { + element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2)); + } else { + continue; + } + worklist.push(element); + } + } else if (isNode(candidate)) { + worklist.push(new Element(candidate, key, null, new Reference(node, key))); + } + } + } + + return outer.root; + }; + + function traverse(root, visitor) { + var controller = new Controller(); + return controller.traverse(root, visitor); + } + + function replace(root, visitor) { + var controller = new Controller(); + return controller.replace(root, visitor); + } + + function extendCommentRange(comment, tokens) { + var target; + + target = upperBound(tokens, function search(token) { + return token.range[0] > comment.range[0]; + }); + + comment.extendedRange = [comment.range[0], comment.range[1]]; + + if (target !== tokens.length) { + comment.extendedRange[1] = tokens[target].range[0]; + } + + target -= 1; + if (target >= 0) { + comment.extendedRange[0] = tokens[target].range[1]; + } + + return comment; + } + + function attachComments(tree, providedComments, tokens) { + // At first, we should calculate extended comment ranges. + var comments = [], comment, len, i, cursor; + + if (!tree.range) { + throw new Error('attachComments needs range information'); + } + + // tokens array is empty, we attach comments to tree as 'leadingComments' + if (!tokens.length) { + if (providedComments.length) { + for (i = 0, len = providedComments.length; i < len; i += 1) { + comment = deepCopy(providedComments[i]); + comment.extendedRange = [0, tree.range[0]]; + comments.push(comment); + } + tree.leadingComments = comments; + } + return tree; + } + + for (i = 0, len = providedComments.length; i < len; i += 1) { + comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens)); + } + + // This is based on John Freeman's implementation. + cursor = 0; + traverse(tree, { + enter: function (node) { + var comment; + + while (cursor < comments.length) { + comment = comments[cursor]; + if (comment.extendedRange[1] > node.range[0]) { + break; + } + + if (comment.extendedRange[1] === node.range[0]) { + if (!node.leadingComments) { + node.leadingComments = []; + } + node.leadingComments.push(comment); + comments.splice(cursor, 1); + } else { + cursor += 1; + } + } + + // already out of owned node + if (cursor === comments.length) { + return VisitorOption.Break; + } + + if (comments[cursor].extendedRange[0] > node.range[1]) { + return VisitorOption.Skip; + } + } + }); + + cursor = 0; + traverse(tree, { + leave: function (node) { + var comment; + + while (cursor < comments.length) { + comment = comments[cursor]; + if (node.range[1] < comment.extendedRange[0]) { + break; + } + + if (node.range[1] === comment.extendedRange[0]) { + if (!node.trailingComments) { + node.trailingComments = []; + } + node.trailingComments.push(comment); + comments.splice(cursor, 1); + } else { + cursor += 1; + } + } + + // already out of owned node + if (cursor === comments.length) { + return VisitorOption.Break; + } + + if (comments[cursor].extendedRange[0] > node.range[1]) { + return VisitorOption.Skip; + } + } + }); + + return tree; + } + + exports.version = _dereq_('./package.json').version; + exports.Syntax = Syntax; + exports.traverse = traverse; + exports.replace = replace; + exports.attachComments = attachComments; + exports.VisitorKeys = VisitorKeys; + exports.VisitorOption = VisitorOption; + exports.Controller = Controller; + exports.cloneEnvironment = function () { return clone({}); }; + + return exports; +}(exports)); +/* vim: set sw=4 ts=4 et tw=80 : */ + +},{"./package.json":68}],68:[function(_dereq_,module,exports){ +module.exports={"name":"estraverse","version":"4.2.0"} +},{}]},{},[1])(1) +}); diff --git a/node_modules/call-matcher/index.js b/node_modules/call-matcher/index.js new file mode 100644 index 000000000..24163e354 --- /dev/null +++ b/node_modules/call-matcher/index.js @@ -0,0 +1,195 @@ +/** + * call-matcher: + * ECMAScript CallExpression matcher made from function/method signature + * + * https://github.com/twada/call-matcher + * + * Copyright (c) 2015-2016 Takuto Wada + * Licensed under the MIT license. + * https://github.com/twada/call-matcher/blob/master/MIT-LICENSE.txt + */ +'use strict'; +/* jshint -W024 */ + +var estraverse = require('estraverse'); +var espurify = require('espurify'); +var syntax = estraverse.Syntax; +var hasOwn = Object.prototype.hasOwnProperty; +var forEach = require('core-js/library/fn/array/for-each'); +var map = require('core-js/library/fn/array/map'); +var filter = require('core-js/library/fn/array/filter'); +var reduce = require('core-js/library/fn/array/reduce'); +var indexOf = require('core-js/library/fn/array/index-of'); +var deepEqual = require('deep-equal'); +var notCallExprMessage = 'Argument should be in the form of CallExpression'; +var duplicatedArgMessage = 'Duplicate argument name: '; +var invalidFormMessage = 'Argument should be in the form of `name` or `[name]`'; + +function CallMatcher (signatureAst, options) { + validateApiExpression(signatureAst); + options = options || {}; + this.visitorKeys = options.visitorKeys || estraverse.VisitorKeys; + if (options.astWhiteList) { + this.purifyAst = espurify.cloneWithWhitelist(options.astWhiteList); + } else { + this.purifyAst = espurify; + } + this.signatureAst = signatureAst; + this.signatureCalleeDepth = astDepth(signatureAst.callee, this.visitorKeys); + this.numMaxArgs = this.signatureAst.arguments.length; + this.numMinArgs = filter(this.signatureAst.arguments, identifiers).length; +} + +CallMatcher.prototype.test = function (currentNode) { + var calleeMatched = this.isCalleeMatched(currentNode); + var numArgs; + if (calleeMatched) { + numArgs = currentNode.arguments.length; + return this.numMinArgs <= numArgs && numArgs <= this.numMaxArgs; + } + return false; +}; + +CallMatcher.prototype.matchArgument = function (currentNode, parentNode) { + if (isCalleeOfParent(currentNode, parentNode)) { + return null; + } + if (this.test(parentNode)) { + var indexOfCurrentArg = indexOf(parentNode.arguments, currentNode); + var numOptional = parentNode.arguments.length - this.numMinArgs; + var matchedSignatures = reduce(this.argumentSignatures(), function (accum, argSig) { + if (argSig.kind === 'mandatory') { + accum.push(argSig); + } + if (argSig.kind === 'optional' && 0 < numOptional) { + numOptional -= 1; + accum.push(argSig); + } + return accum; + }, []); + return matchedSignatures[indexOfCurrentArg]; + } + return null; +}; + +CallMatcher.prototype.calleeAst = function () { + return this.purifyAst(this.signatureAst.callee); +}; + +CallMatcher.prototype.argumentSignatures = function () { + return map(this.signatureAst.arguments, toArgumentSignature); +}; + +CallMatcher.prototype.isCalleeMatched = function (node) { + if (!isCallExpression(node)) { + return false; + } + if (!this.isSameDepthAsSignatureCallee(node.callee)) { + return false; + } + return deepEqual(this.purifyAst(this.signatureAst.callee), this.purifyAst(node.callee)); +}; + +CallMatcher.prototype.isSameDepthAsSignatureCallee = function (ast) { + var depth = this.signatureCalleeDepth; + var currentDepth = 0; + estraverse.traverse(ast, { + keys: this.visitorKeys, + enter: function (currentNode, parentNode) { + var path = this.path(); + var pathDepth = path ? path.length : 0; + if (currentDepth < pathDepth) { + currentDepth = pathDepth; + } + if (depth < currentDepth) { + this['break'](); + } + } + }); + return (depth === currentDepth); +}; + +function toArgumentSignature (argSignatureNode) { + switch(argSignatureNode.type) { + case syntax.Identifier: + return { + name: argSignatureNode.name, + kind: 'mandatory' + }; + case syntax.ArrayExpression: + return { + name: argSignatureNode.elements[0].name, + kind: 'optional' + }; + default: + return null; + } +} + +function astDepth (ast, visitorKeys) { + var maxDepth = 0; + estraverse.traverse(ast, { + keys: visitorKeys, + enter: function (currentNode, parentNode) { + var path = this.path(); + var pathDepth = path ? path.length : 0; + if (maxDepth < pathDepth) { + maxDepth = pathDepth; + } + } + }); + return maxDepth; +} + +function isCallExpression (node) { + return node && node.type === syntax.CallExpression; +} + +function isCalleeOfParent(currentNode, parentNode) { + return parentNode && currentNode && + parentNode.type === syntax.CallExpression && + parentNode.callee === currentNode; +} + +function identifiers (node) { + return node.type === syntax.Identifier; +} + +function validateApiExpression (callExpression) { + if (!callExpression || !callExpression.type) { + throw new Error(notCallExprMessage); + } + if (callExpression.type !== syntax.CallExpression) { + throw new Error(notCallExprMessage); + } + var names = {}; + forEach(callExpression.arguments, function (arg) { + var name = validateArg(arg); + if (hasOwn.call(names, name)) { + throw new Error(duplicatedArgMessage + name); + } else { + names[name] = name; + } + }); +} + +function validateArg (arg) { + var inner; + switch(arg.type) { + case syntax.Identifier: + return arg.name; + case syntax.ArrayExpression: + if (arg.elements.length !== 1) { + throw new Error(invalidFormMessage); + } + inner = arg.elements[0]; + if (inner.type !== syntax.Identifier) { + throw new Error(invalidFormMessage); + } + return inner.name; + default: + throw new Error(invalidFormMessage); + } +} + +module.exports = CallMatcher; diff --git a/node_modules/call-matcher/package.json b/node_modules/call-matcher/package.json new file mode 100644 index 000000000..f4d392f1d --- /dev/null +++ b/node_modules/call-matcher/package.json @@ -0,0 +1,55 @@ +{ + "name": "call-matcher", + "description": "ECMAScript CallExpression matcher made from function/method signature", + "version": "1.0.1", + "author": { + "name": "Takuto Wada", + "email": "takuto.wada@gmail.com", + "url": "https://github.com/twada" + }, + "bugs": "https://github.com/twada/call-matcher/issues", + "dependencies": { + "core-js": "^2.0.0", + "deep-equal": "^1.0.0", + "espurify": "^1.6.0", + "estraverse": "^4.0.0" + }, + "devDependencies": { + "babel-types": "^6.3.21", + "babylon": "^6.3.21", + "browserify": "^13.0.0", + "derequire": "^2.0.2", + "dereserve": "^1.0.0", + "esprima": "^3.0.0", + "jshint": "^2.8.0", + "licensify": "^3.1.1", + "mocha": "^3.0.0", + "package-json-filterify": "^1.0.4" + }, + "files": [ + "CHANGELOG.md", + "MIT-LICENSE.txt", + "README.md", + "index.js", + "dist/call-matcher.js" + ], + "homepage": "https://github.com/twada/call-matcher", + "keywords": [ + "ast", + "estree", + "ecmascript" + ], + "license": "MIT", + "main": "index.js", + "repository": { + "type": "git", + "url": "git://github.com/twada/call-matcher.git" + }, + "scripts": { + "dist": "mkdir -p dist && browserify index.js --plugin licensify --global-transform package-json-filterify --standalone CallMatcher | dereserve | derequire > ./dist/call-matcher.js", + "lint": "jshint index.js", + "preversion": "npm test", + "test": "npm run lint && mocha test", + "version": "npm run dist && git add -A dist" + } +} |