1990 lines
69 KiB
JavaScript
1990 lines
69 KiB
JavaScript
|
/**
|
||
|
|
* 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)
|
||
|
|
});
|