steal
Version:
Gets JavaScript.
1,683 lines (1,386 loc) • 1.86 MB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["Babel"] = factory();
else
root["Babel"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ((function(modules) {
// Check all modules for deduplicated modules
for(var i in modules) {
if(Object.prototype.hasOwnProperty.call(modules, i)) {
switch(typeof modules[i]) {
case "function": break;
case "object":
// Module can be created from a template
modules[i] = (function(_m) {
var args = _m.slice(1), fn = modules[_m[0]];
return function (a,b,c) {
fn.apply(this, [a,b,c].concat(args));
};
}(modules[i]));
break;
default:
// Module is a copy of another module
modules[i] = modules[modules[i]];
break;
}
}
}
return modules;
}([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.version = exports.availablePresets = exports.availablePlugins = undefined;
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
exports.transform = transform;
exports.transformFromAst = transformFromAst;
exports.registerPlugin = registerPlugin;
exports.registerPlugins = registerPlugins;
exports.registerPreset = registerPreset;
exports.registerPresets = registerPresets;
exports.transformScriptTags = transformScriptTags;
exports.disableScriptTags = disableScriptTags;
var _babelCore = __webpack_require__(286);
var Babel = _interopRequireWildcard(_babelCore);
var _transformScriptTags = __webpack_require__(620);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
var isArray = Array.isArray || function (arg) {
return Object.prototype.toString.call(arg) === '[object Array]';
};
/**
* Loads the given name (or [name, options] pair) from the given table object
* holding the available presets or plugins.
*
* Returns undefined if the preset or plugin is not available; passes through
* name unmodified if it (or the first element of the pair) is not a string.
*/
function loadBuiltin(builtinTable, name) {
if (isArray(name) && typeof name[0] === 'string') {
if (builtinTable.hasOwnProperty(name[0])) {
return [builtinTable[name[0]]].concat(name.slice(1));
}
return;
} else if (typeof name === 'string') {
return builtinTable[name];
}
// Could be an actual preset/plugin module
return name;
}
/**
* Parses plugin names and presets from the specified options.
*/
function processOptions(options) {
// Parse preset names
var presets = (options.presets || []).map(function (presetName) {
var preset = loadBuiltin(availablePresets, presetName);
if (preset) {
// workaround for babel issue
// at some point, babel copies the preset, losing the non-enumerable
// buildPreset key; convert it into an enumerable key.
if (isArray(preset) && _typeof(preset[0]) === 'object' && preset[0].hasOwnProperty('buildPreset')) {
preset[0] = _extends({}, preset[0], { buildPreset: preset[0].buildPreset });
}
} else {
throw new Error('Invalid preset specified in Babel options: "' + presetName + '"');
}
return preset;
});
// Parse plugin names
var plugins = (options.plugins || []).map(function (pluginName) {
var plugin = loadBuiltin(availablePlugins, pluginName);
if (!plugin) {
throw new Error('Invalid plugin specified in Babel options: "' + pluginName + '"');
}
return plugin;
});
return _extends({
babelrc: false
}, options, {
presets: presets,
plugins: plugins
});
}
function transform(code, options) {
return Babel.transform(code, processOptions(options));
}
function transformFromAst(ast, code, options) {
return Babel.transformFromAst(ast, code, processOptions(options));
}
var availablePlugins = exports.availablePlugins = {};
var availablePresets = exports.availablePresets = {};
/**
* Registers a named plugin for use with Babel.
*/
function registerPlugin(name, plugin) {
if (availablePlugins.hasOwnProperty(name)) {
console.warn('A plugin named "' + name + '" is already registered, it will be overridden');
}
availablePlugins[name] = plugin;
}
/**
* Registers multiple plugins for use with Babel. `newPlugins` should be an object where the key
* is the name of the plugin, and the value is the plugin itself.
*/
function registerPlugins(newPlugins) {
Object.keys(newPlugins).forEach(function (name) {
return registerPlugin(name, newPlugins[name]);
});
}
/**
* Registers a named preset for use with Babel.
*/
function registerPreset(name, preset) {
if (availablePresets.hasOwnProperty(name)) {
console.warn('A preset named "' + name + '" is already registered, it will be overridden');
}
availablePresets[name] = preset;
}
/**
* Registers multiple presets for use with Babel. `newPresets` should be an object where the key
* is the name of the preset, and the value is the preset itself.
*/
function registerPresets(newPresets) {
Object.keys(newPresets).forEach(function (name) {
return registerPreset(name, newPresets[name]);
});
}
// All the plugins we should bundle
registerPlugins({
'check-es2015-constants': __webpack_require__(64),
'external-helpers': __webpack_require__(318),
'inline-replace-variables': __webpack_require__(319),
'syntax-async-functions': __webpack_require__(65),
'syntax-async-generators': __webpack_require__(191),
'syntax-class-constructor-call': __webpack_require__(192),
'syntax-class-properties': __webpack_require__(193),
'syntax-decorators': __webpack_require__(123),
'syntax-do-expressions': __webpack_require__(194),
'syntax-exponentiation-operator': __webpack_require__(195),
'syntax-export-extensions': __webpack_require__(196),
'syntax-flow': __webpack_require__(124),
'syntax-function-bind': __webpack_require__(197),
'syntax-function-sent': __webpack_require__(321),
'syntax-jsx': __webpack_require__(125),
'syntax-object-rest-spread': __webpack_require__(198),
'syntax-trailing-function-commas': __webpack_require__(126),
'transform-async-functions': __webpack_require__(322),
'transform-async-to-generator': __webpack_require__(127),
'transform-async-to-module-method': __webpack_require__(324),
'transform-class-constructor-call': __webpack_require__(199),
'transform-class-properties': __webpack_require__(200),
'transform-decorators': __webpack_require__(201),
'transform-decorators-legacy': __webpack_require__(325).default, // <- No clue. Nope.
'transform-do-expressions': __webpack_require__(202),
'transform-es2015-arrow-functions': __webpack_require__(66),
'transform-es2015-block-scoped-functions': __webpack_require__(67),
'transform-es2015-block-scoping': __webpack_require__(68),
'transform-es2015-classes': __webpack_require__(69),
'transform-es2015-computed-properties': __webpack_require__(70),
'transform-es2015-destructuring': __webpack_require__(71),
'transform-es2015-duplicate-keys': __webpack_require__(128),
'transform-es2015-for-of': __webpack_require__(72),
'transform-es2015-function-name': __webpack_require__(73),
'transform-es2015-instanceof': __webpack_require__(328),
'transform-es2015-literals': __webpack_require__(74),
'transform-es2015-modules-amd': __webpack_require__(129),
'transform-es2015-modules-commonjs': __webpack_require__(75),
'transform-es2015-modules-systemjs': __webpack_require__(204),
'transform-es2015-modules-umd': __webpack_require__(205),
'transform-es2015-object-super': __webpack_require__(76),
'transform-es2015-parameters': __webpack_require__(77),
'transform-es2015-shorthand-properties': __webpack_require__(78),
'transform-es2015-spread': __webpack_require__(79),
'transform-es2015-sticky-regex': __webpack_require__(80),
'transform-es2015-template-literals': __webpack_require__(81),
'transform-es2015-typeof-symbol': __webpack_require__(82),
'transform-es2015-unicode-regex': __webpack_require__(83),
'transform-es3-member-expression-literals': __webpack_require__(332),
'transform-es3-property-literals': __webpack_require__(333),
'transform-es5-property-mutators': __webpack_require__(334),
'transform-eval': __webpack_require__(335),
'transform-exponentiation-operator': __webpack_require__(130),
'transform-export-extensions': __webpack_require__(206),
'transform-flow-comments': __webpack_require__(336),
'transform-flow-strip-types': __webpack_require__(207),
'transform-function-bind': __webpack_require__(208),
'transform-jscript': __webpack_require__(337),
'transform-object-assign': __webpack_require__(338),
'transform-object-rest-spread': __webpack_require__(209),
'transform-object-set-prototype-of-to-assign': __webpack_require__(339),
'transform-proto-to-assign': __webpack_require__(340),
'transform-react-constant-elements': __webpack_require__(341),
'transform-react-display-name': __webpack_require__(210),
'transform-react-inline-elements': __webpack_require__(342),
'transform-react-jsx': __webpack_require__(211),
'transform-react-jsx-compat': __webpack_require__(343),
'transform-react-jsx-self': __webpack_require__(345),
'transform-react-jsx-source': __webpack_require__(346),
'transform-regenerator': __webpack_require__(84),
'transform-runtime': __webpack_require__(349),
'transform-strict-mode': __webpack_require__(212),
'undeclared-variables-check': __webpack_require__(350)
});
// All the presets we should bundle
registerPresets({
es2015: __webpack_require__(213),
es2016: __webpack_require__(214),
es2017: __webpack_require__(215),
latest: __webpack_require__(352),
react: __webpack_require__(353),
'stage-0': __webpack_require__(354),
'stage-1': __webpack_require__(216),
'stage-2': __webpack_require__(217),
'stage-3': __webpack_require__(218),
// ES2015 preset with es2015-modules-commonjs removed
// Plugin list copied from babel-preset-es2015/index.js
'es2015-no-commonjs': {
plugins: [__webpack_require__(81), __webpack_require__(74), __webpack_require__(73), __webpack_require__(66), __webpack_require__(67), __webpack_require__(69), __webpack_require__(76), __webpack_require__(78), __webpack_require__(70), __webpack_require__(72), __webpack_require__(80), __webpack_require__(83), __webpack_require__(64), __webpack_require__(79), __webpack_require__(77), __webpack_require__(71), __webpack_require__(68), __webpack_require__(82), [__webpack_require__(84), { async: false, asyncGenerators: false }]]
},
// ES2015 preset with plugins set to loose mode.
// Based off https://github.com/bkonkle/babel-preset-es2015-loose/blob/master/index.js
'es2015-loose': {
plugins: [[__webpack_require__(81), { loose: true }], __webpack_require__(74), __webpack_require__(73), __webpack_require__(66), __webpack_require__(67), [__webpack_require__(69), { loose: true }], __webpack_require__(76), __webpack_require__(78), __webpack_require__(128), [__webpack_require__(70), { loose: true }], [__webpack_require__(72), { loose: true }], __webpack_require__(80), __webpack_require__(83), __webpack_require__(64), [__webpack_require__(79), { loose: true }], __webpack_require__(77), [__webpack_require__(71), { loose: true }], __webpack_require__(68), __webpack_require__(82), [__webpack_require__(75), { loose: true }], [__webpack_require__(84), { async: false, asyncGenerators: false }]]
}
});
var version = exports.version = ("6.24.2");
// Listen for load event if we're in a browser and then kick off finding and
// running of scripts with "text/babel" type.
if (typeof window !== 'undefined' && window && window.addEventListener) {
window.addEventListener('DOMContentLoaded', function () {
return transformScriptTags();
}, false);
}
/**
* Transform <script> tags with "text/babel" type.
* @param {Array} scriptTags specify script tags to transform, transform all in the <head> if not given
*/
function transformScriptTags(scriptTags) {
(0, _transformScriptTags.runScripts)(transform, scriptTags);
}
/**
* Disables automatic transformation of <script> tags with "text/babel" type.
*/
function disableScriptTags() {
window.removeEventListener('DOMContentLoaded', transformScriptTags);
}
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
exports.createTypeAnnotationBasedOnTypeof = exports.removeTypeDuplicates = exports.createUnionTypeAnnotation = exports.valueToNode = exports.toBlock = exports.toExpression = exports.toStatement = exports.toBindingIdentifierName = exports.toIdentifier = exports.toKeyAlias = exports.toSequenceExpression = exports.toComputedKey = exports.isNodesEquivalent = exports.isImmutable = exports.isScope = exports.isSpecifierDefault = exports.isVar = exports.isBlockScoped = exports.isLet = exports.isValidIdentifier = exports.isReferenced = exports.isBinding = exports.getOuterBindingIdentifiers = exports.getBindingIdentifiers = exports.TYPES = exports.react = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = undefined;
var _getOwnPropertySymbols = __webpack_require__(356);
var _getOwnPropertySymbols2 = _interopRequireDefault(_getOwnPropertySymbols);
var _getIterator2 = __webpack_require__(2);
var _getIterator3 = _interopRequireDefault(_getIterator2);
var _keys = __webpack_require__(13);
var _keys2 = _interopRequireDefault(_keys);
var _stringify = __webpack_require__(34);
var _stringify2 = _interopRequireDefault(_stringify);
var _constants = __webpack_require__(133);
Object.defineProperty(exports, "STATEMENT_OR_BLOCK_KEYS", {
enumerable: true,
get: function get() {
return _constants.STATEMENT_OR_BLOCK_KEYS;
}
});
Object.defineProperty(exports, "FLATTENABLE_KEYS", {
enumerable: true,
get: function get() {
return _constants.FLATTENABLE_KEYS;
}
});
Object.defineProperty(exports, "FOR_INIT_KEYS", {
enumerable: true,
get: function get() {
return _constants.FOR_INIT_KEYS;
}
});
Object.defineProperty(exports, "COMMENT_KEYS", {
enumerable: true,
get: function get() {
return _constants.COMMENT_KEYS;
}
});
Object.defineProperty(exports, "LOGICAL_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.LOGICAL_OPERATORS;
}
});
Object.defineProperty(exports, "UPDATE_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.UPDATE_OPERATORS;
}
});
Object.defineProperty(exports, "BOOLEAN_NUMBER_BINARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.BOOLEAN_NUMBER_BINARY_OPERATORS;
}
});
Object.defineProperty(exports, "EQUALITY_BINARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.EQUALITY_BINARY_OPERATORS;
}
});
Object.defineProperty(exports, "COMPARISON_BINARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.COMPARISON_BINARY_OPERATORS;
}
});
Object.defineProperty(exports, "BOOLEAN_BINARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.BOOLEAN_BINARY_OPERATORS;
}
});
Object.defineProperty(exports, "NUMBER_BINARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.NUMBER_BINARY_OPERATORS;
}
});
Object.defineProperty(exports, "BINARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.BINARY_OPERATORS;
}
});
Object.defineProperty(exports, "BOOLEAN_UNARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.BOOLEAN_UNARY_OPERATORS;
}
});
Object.defineProperty(exports, "NUMBER_UNARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.NUMBER_UNARY_OPERATORS;
}
});
Object.defineProperty(exports, "STRING_UNARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.STRING_UNARY_OPERATORS;
}
});
Object.defineProperty(exports, "UNARY_OPERATORS", {
enumerable: true,
get: function get() {
return _constants.UNARY_OPERATORS;
}
});
Object.defineProperty(exports, "INHERIT_KEYS", {
enumerable: true,
get: function get() {
return _constants.INHERIT_KEYS;
}
});
Object.defineProperty(exports, "BLOCK_SCOPED_SYMBOL", {
enumerable: true,
get: function get() {
return _constants.BLOCK_SCOPED_SYMBOL;
}
});
Object.defineProperty(exports, "NOT_LOCAL_BINDING", {
enumerable: true,
get: function get() {
return _constants.NOT_LOCAL_BINDING;
}
});
exports.is = is;
exports.isType = isType;
exports.validate = validate;
exports.shallowEqual = shallowEqual;
exports.appendToMemberExpression = appendToMemberExpression;
exports.prependToMemberExpression = prependToMemberExpression;
exports.ensureBlock = ensureBlock;
exports.clone = clone;
exports.cloneWithoutLoc = cloneWithoutLoc;
exports.cloneDeep = cloneDeep;
exports.buildMatchMemberExpression = buildMatchMemberExpression;
exports.removeComments = removeComments;
exports.inheritsComments = inheritsComments;
exports.inheritTrailingComments = inheritTrailingComments;
exports.inheritLeadingComments = inheritLeadingComments;
exports.inheritInnerComments = inheritInnerComments;
exports.inherits = inherits;
exports.assertNode = assertNode;
exports.isNode = isNode;
exports.traverseFast = traverseFast;
exports.removeProperties = removeProperties;
exports.removePropertiesDeep = removePropertiesDeep;
var _retrievers = __webpack_require__(222);
Object.defineProperty(exports, "getBindingIdentifiers", {
enumerable: true,
get: function get() {
return _retrievers.getBindingIdentifiers;
}
});
Object.defineProperty(exports, "getOuterBindingIdentifiers", {
enumerable: true,
get: function get() {
return _retrievers.getOuterBindingIdentifiers;
}
});
var _validators = __webpack_require__(391);
Object.defineProperty(exports, "isBinding", {
enumerable: true,
get: function get() {
return _validators.isBinding;
}
});
Object.defineProperty(exports, "isReferenced", {
enumerable: true,
get: function get() {
return _validators.isReferenced;
}
});
Object.defineProperty(exports, "isValidIdentifier", {
enumerable: true,
get: function get() {
return _validators.isValidIdentifier;
}
});
Object.defineProperty(exports, "isLet", {
enumerable: true,
get: function get() {
return _validators.isLet;
}
});
Object.defineProperty(exports, "isBlockScoped", {
enumerable: true,
get: function get() {
return _validators.isBlockScoped;
}
});
Object.defineProperty(exports, "isVar", {
enumerable: true,
get: function get() {
return _validators.isVar;
}
});
Object.defineProperty(exports, "isSpecifierDefault", {
enumerable: true,
get: function get() {
return _validators.isSpecifierDefault;
}
});
Object.defineProperty(exports, "isScope", {
enumerable: true,
get: function get() {
return _validators.isScope;
}
});
Object.defineProperty(exports, "isImmutable", {
enumerable: true,
get: function get() {
return _validators.isImmutable;
}
});
Object.defineProperty(exports, "isNodesEquivalent", {
enumerable: true,
get: function get() {
return _validators.isNodesEquivalent;
}
});
var _converters = __webpack_require__(381);
Object.defineProperty(exports, "toComputedKey", {
enumerable: true,
get: function get() {
return _converters.toComputedKey;
}
});
Object.defineProperty(exports, "toSequenceExpression", {
enumerable: true,
get: function get() {
return _converters.toSequenceExpression;
}
});
Object.defineProperty(exports, "toKeyAlias", {
enumerable: true,
get: function get() {
return _converters.toKeyAlias;
}
});
Object.defineProperty(exports, "toIdentifier", {
enumerable: true,
get: function get() {
return _converters.toIdentifier;
}
});
Object.defineProperty(exports, "toBindingIdentifierName", {
enumerable: true,
get: function get() {
return _converters.toBindingIdentifierName;
}
});
Object.defineProperty(exports, "toStatement", {
enumerable: true,
get: function get() {
return _converters.toStatement;
}
});
Object.defineProperty(exports, "toExpression", {
enumerable: true,
get: function get() {
return _converters.toExpression;
}
});
Object.defineProperty(exports, "toBlock", {
enumerable: true,
get: function get() {
return _converters.toBlock;
}
});
Object.defineProperty(exports, "valueToNode", {
enumerable: true,
get: function get() {
return _converters.valueToNode;
}
});
var _flow = __webpack_require__(389);
Object.defineProperty(exports, "createUnionTypeAnnotation", {
enumerable: true,
get: function get() {
return _flow.createUnionTypeAnnotation;
}
});
Object.defineProperty(exports, "removeTypeDuplicates", {
enumerable: true,
get: function get() {
return _flow.removeTypeDuplicates;
}
});
Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
enumerable: true,
get: function get() {
return _flow.createTypeAnnotationBasedOnTypeof;
}
});
var _toFastProperties = __webpack_require__(615);
var _toFastProperties2 = _interopRequireDefault(_toFastProperties);
var _clone = __webpack_require__(108);
var _clone2 = _interopRequireDefault(_clone);
var _uniq = __webpack_require__(591);
var _uniq2 = _interopRequireDefault(_uniq);
__webpack_require__(386);
var _definitions = __webpack_require__(26);
var _react2 = __webpack_require__(390);
var _react = _interopRequireWildcard(_react2);
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj;
} else {
var newObj = {};if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
}
}newObj.default = obj;return newObj;
}
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
var t = exports;
function registerType(type) {
var is = t["is" + type];
if (!is) {
is = t["is" + type] = function (node, opts) {
return t.is(type, node, opts);
};
}
t["assert" + type] = function (node, opts) {
opts = opts || {};
if (!is(node, opts)) {
throw new Error("Expected type " + (0, _stringify2.default)(type) + " with option " + (0, _stringify2.default)(opts));
}
};
}
exports.VISITOR_KEYS = _definitions.VISITOR_KEYS;
exports.ALIAS_KEYS = _definitions.ALIAS_KEYS;
exports.NODE_FIELDS = _definitions.NODE_FIELDS;
exports.BUILDER_KEYS = _definitions.BUILDER_KEYS;
exports.DEPRECATED_KEYS = _definitions.DEPRECATED_KEYS;
exports.react = _react;
for (var type in t.VISITOR_KEYS) {
registerType(type);
}
t.FLIPPED_ALIAS_KEYS = {};
(0, _keys2.default)(t.ALIAS_KEYS).forEach(function (type) {
t.ALIAS_KEYS[type].forEach(function (alias) {
var types = t.FLIPPED_ALIAS_KEYS[alias] = t.FLIPPED_ALIAS_KEYS[alias] || [];
types.push(type);
});
});
(0, _keys2.default)(t.FLIPPED_ALIAS_KEYS).forEach(function (type) {
t[type.toUpperCase() + "_TYPES"] = t.FLIPPED_ALIAS_KEYS[type];
registerType(type);
});
var TYPES = exports.TYPES = (0, _keys2.default)(t.VISITOR_KEYS).concat((0, _keys2.default)(t.FLIPPED_ALIAS_KEYS)).concat((0, _keys2.default)(t.DEPRECATED_KEYS));
function is(type, node, opts) {
if (!node) return false;
var matches = isType(node.type, type);
if (!matches) return false;
if (typeof opts === "undefined") {
return true;
} else {
return t.shallowEqual(node, opts);
}
}
function isType(nodeType, targetType) {
if (nodeType === targetType) return true;
if (t.ALIAS_KEYS[targetType]) return false;
var aliases = t.FLIPPED_ALIAS_KEYS[targetType];
if (aliases) {
if (aliases[0] === nodeType) return true;
for (var _iterator = aliases, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var alias = _ref;
if (nodeType === alias) return true;
}
}
return false;
}
(0, _keys2.default)(t.BUILDER_KEYS).forEach(function (type) {
var keys = t.BUILDER_KEYS[type];
function builder() {
if (arguments.length > keys.length) {
throw new Error("t." + type + ": Too many arguments passed. Received " + arguments.length + " but can receive " + ("no more than " + keys.length));
}
var node = {};
node.type = type;
var i = 0;
for (var _iterator2 = keys, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
var _ref2;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref2 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref2 = _i2.value;
}
var _key = _ref2;
var field = t.NODE_FIELDS[type][_key];
var arg = arguments[i++];
if (arg === undefined) arg = (0, _clone2.default)(field.default);
node[_key] = arg;
}
for (var key in node) {
validate(node, key, node[key]);
}
return node;
}
t[type] = builder;
t[type[0].toLowerCase() + type.slice(1)] = builder;
});
var _loop = function _loop(_type) {
var newType = t.DEPRECATED_KEYS[_type];
function proxy(fn) {
return function () {
console.trace("The node type " + _type + " has been renamed to " + newType);
return fn.apply(this, arguments);
};
}
t[_type] = t[_type[0].toLowerCase() + _type.slice(1)] = proxy(t[newType]);
t["is" + _type] = proxy(t["is" + newType]);
t["assert" + _type] = proxy(t["assert" + newType]);
};
for (var _type in t.DEPRECATED_KEYS) {
_loop(_type);
}
function validate(node, key, val) {
if (!node) return;
var fields = t.NODE_FIELDS[node.type];
if (!fields) return;
var field = fields[key];
if (!field || !field.validate) return;
if (field.optional && val == null) return;
field.validate(node, key, val);
}
function shallowEqual(actual, expected) {
var keys = (0, _keys2.default)(expected);
for (var _iterator3 = keys, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
var _ref3;
if (_isArray3) {
if (_i3 >= _iterator3.length) break;
_ref3 = _iterator3[_i3++];
} else {
_i3 = _iterator3.next();
if (_i3.done) break;
_ref3 = _i3.value;
}
var key = _ref3;
if (actual[key] !== expected[key]) {
return false;
}
}
return true;
}
function appendToMemberExpression(member, append, computed) {
member.object = t.memberExpression(member.object, member.property, member.computed);
member.property = append;
member.computed = !!computed;
return member;
}
function prependToMemberExpression(member, prepend) {
member.object = t.memberExpression(prepend, member.object);
return member;
}
function ensureBlock(node) {
var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "body";
return node[key] = t.toBlock(node[key], node);
}
function clone(node) {
if (!node) return node;
var newNode = {};
for (var key in node) {
if (key[0] === "_") continue;
newNode[key] = node[key];
}
return newNode;
}
function cloneWithoutLoc(node) {
var newNode = clone(node);
delete newNode.loc;
return newNode;
}
function cloneDeep(node) {
if (!node) return node;
var newNode = {};
for (var key in node) {
if (key[0] === "_") continue;
var val = node[key];
if (val) {
if (val.type) {
val = t.cloneDeep(val);
} else if (Array.isArray(val)) {
val = val.map(t.cloneDeep);
}
}
newNode[key] = val;
}
return newNode;
}
function buildMatchMemberExpression(match, allowPartial) {
var parts = match.split(".");
return function (member) {
if (!t.isMemberExpression(member)) return false;
var search = [member];
var i = 0;
while (search.length) {
var node = search.shift();
if (allowPartial && i === parts.length) {
return true;
}
if (t.isIdentifier(node)) {
if (parts[i] !== node.name) return false;
} else if (t.isStringLiteral(node)) {
if (parts[i] !== node.value) return false;
} else if (t.isMemberExpression(node)) {
if (node.computed && !t.isStringLiteral(node.property)) {
return false;
} else {
search.push(node.object);
search.push(node.property);
continue;
}
} else {
return false;
}
if (++i > parts.length) {
return false;
}
}
return true;
};
}
function removeComments(node) {
for (var _iterator4 = t.COMMENT_KEYS, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) {
var _ref4;
if (_isArray4) {
if (_i4 >= _iterator4.length) break;
_ref4 = _iterator4[_i4++];
} else {
_i4 = _iterator4.next();
if (_i4.done) break;
_ref4 = _i4.value;
}
var key = _ref4;
delete node[key];
}
return node;
}
function inheritsComments(child, parent) {
inheritTrailingComments(child, parent);
inheritLeadingComments(child, parent);
inheritInnerComments(child, parent);
return child;
}
function inheritTrailingComments(child, parent) {
_inheritComments("trailingComments", child, parent);
}
function inheritLeadingComments(child, parent) {
_inheritComments("leadingComments", child, parent);
}
function inheritInnerComments(child, parent) {
_inheritComments("innerComments", child, parent);
}
function _inheritComments(key, child, parent) {
if (child && parent) {
child[key] = (0, _uniq2.default)([].concat(child[key], parent[key]).filter(Boolean));
}
}
function inherits(child, parent) {
if (!child || !parent) return child;
for (var _iterator5 = t.INHERIT_KEYS.optional, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : (0, _getIterator3.default)(_iterator5);;) {
var _ref5;
if (_isArray5) {
if (_i5 >= _iterator5.length) break;
_ref5 = _iterator5[_i5++];
} else {
_i5 = _iterator5.next();
if (_i5.done) break;
_ref5 = _i5.value;
}
var _key2 = _ref5;
if (child[_key2] == null) {
child[_key2] = parent[_key2];
}
}
for (var key in parent) {
if (key[0] === "_") child[key] = parent[key];
}
for (var _iterator6 = t.INHERIT_KEYS.force, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : (0, _getIterator3.default)(_iterator6);;) {
var _ref6;
if (_isArray6) {
if (_i6 >= _iterator6.length) break;
_ref6 = _iterator6[_i6++];
} else {
_i6 = _iterator6.next();
if (_i6.done) break;
_ref6 = _i6.value;
}
var _key3 = _ref6;
child[_key3] = parent[_key3];
}
t.inheritsComments(child, parent);
return child;
}
function assertNode(node) {
if (!isNode(node)) {
throw new TypeError("Not a valid node " + (node && node.type));
}
}
function isNode(node) {
return !!(node && _definitions.VISITOR_KEYS[node.type]);
}
(0, _toFastProperties2.default)(t);
(0, _toFastProperties2.default)(t.VISITOR_KEYS);
function traverseFast(node, enter, opts) {
if (!node) return;
var keys = t.VISITOR_KEYS[node.type];
if (!keys) return;
opts = opts || {};
enter(node, opts);
for (var _iterator7 = keys, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : (0, _getIterator3.default)(_iterator7);;) {
var _ref7;
if (_isArray7) {
if (_i7 >= _iterator7.length) break;
_ref7 = _iterator7[_i7++];
} else {
_i7 = _iterator7.next();
if (_i7.done) break;
_ref7 = _i7.value;
}
var key = _ref7;
var subNode = node[key];
if (Array.isArray(subNode)) {
for (var _iterator8 = subNode, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : (0, _getIterator3.default)(_iterator8);;) {
var _ref8;
if (_isArray8) {
if (_i8 >= _iterator8.length) break;
_ref8 = _iterator8[_i8++];
} else {
_i8 = _iterator8.next();
if (_i8.done) break;
_ref8 = _i8.value;
}
var _node = _ref8;
traverseFast(_node, enter, opts);
}
} else {
traverseFast(subNode, enter, opts);
}
}
}
var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
var CLEAR_KEYS_PLUS_COMMENTS = t.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
function removeProperties(node, opts) {
opts = opts || {};
var map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
for (var _iterator9 = map, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : (0, _getIterator3.default)(_iterator9);;) {
var _ref9;
if (_isArray9) {
if (_i9 >= _iterator9.length) break;
_ref9 = _iterator9[_i9++];
} else {
_i9 = _iterator9.next();
if (_i9.done) break;
_ref9 = _i9.value;
}
var _key4 = _ref9;
if (node[_key4] != null) node[_key4] = undefined;
}
for (var key in node) {
if (key[0] === "_" && node[key] != null) node[key] = undefined;
}
var syms = (0, _getOwnPropertySymbols2.default)(node);
for (var _iterator10 = syms, _isArray10 = Array.isArray(_iterator10), _i10 = 0, _iterator10 = _isArray10 ? _iterator10 : (0, _getIterator3.default)(_iterator10);;) {
var _ref10;
if (_isArray10) {
if (_i10 >= _iterator10.length) break;
_ref10 = _iterator10[_i10++];
} else {
_i10 = _iterator10.next();
if (_i10.done) break;
_ref10 = _i10.value;
}
var sym = _ref10;
node[sym] = null;
}
}
function removePropertiesDeep(tree, opts) {
traverseFast(tree, removeProperties, opts);
return tree;
}
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = { "default": __webpack_require__(400), __esModule: true };
/***/ }),
/* 3 */
/***/ (function(module, exports) {
"use strict";
exports.__esModule = true;
exports.default = function (instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
};
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
var _symbol = __webpack_require__(10);
var _symbol2 = _interopRequireDefault(_symbol);
exports.default = function (code, opts) {
var stack = void 0;
try {
throw new Error();
} catch (error) {
if (error.stack) {
stack = error.stack.split("\n").slice(1).join("\n");
}
}
opts = (0, _assign2.default)({
allowReturnOutsideFunction: true,
allowSuperOutsideMethod: true,
preserveComments: false
}, opts);
var _getAst = function getAst() {
var ast = void 0;
try {
ast = babylon.parse(code, opts);
ast = _babelTraverse2.default.removeProperties(ast, { preserveComments: opts.preserveComments });
_babelTraverse2.default.cheap(ast, function (node) {
node[FROM_TEMPLATE] = true;
});
} catch (err) {
err.stack = err.stack + "from\n" + stack;
throw err;
}
_getAst = function getAst() {
return ast;
};
return ast;
};
return function () {
for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return useTemplate(_getAst(), args);
};
};
var _cloneDeep = __webpack_require__(565);
var _cloneDeep2 = _interopRequireDefault(_cloneDeep);
var _assign = __webpack_require__(170);
var _assign2 = _interopRequireDefault(_assign);
var _has = __webpack_require__(269);
var _has2 = _interopRequireDefault(_has);
var _babelTraverse = __webpack_require__(7);
var _babelTraverse2 = _interopRequireDefault(_babelTraverse);
var _babylon = __webpack_require__(134);
var babylon = _interopRequireWildcard(_babylon);
var _babelTypes = __webpack_require__(1);
var t = _interopRequireWildcard(_babelTypes);
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj;
} else {
var newObj = {};if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
}
}newObj.default = obj;return newObj;
}
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
var FROM_TEMPLATE = "_fromTemplate";
var TEMPLATE_SKIP = (0, _symbol2.default)();
function useTemplate(ast, nodes) {
ast = (0, _cloneDeep2.default)(ast);
var _ast = ast,
program = _ast.program;
if (nodes.length) {
(0, _babelTraverse2.default)(ast, templateVisitor, null, nodes);
}
if (program.body.length > 1) {
return program.body;
} else {
return program.body[0];
}
}
var templateVisitor = {
noScope: true,
enter: function enter(path, args) {
var node = path.node;
if (node[TEMPLATE_SKIP]) return path.skip();
if (t.isExpressionStatement(node)) {
node = node.expression;
}
var replacement = void 0;
if (t.isIdentifier(node) && node[FROM_TEMPLATE]) {
if ((0, _has2.default)(args[0], node.name)) {
replacement = args[0][node.name];
} else if (node.name[0] === "$") {
var i = +node.name.slice(1);
if (args[i]) replacement = args[i];
}
}
if (replacement === null) {
path.remove();
}
if (replacement) {
replacement[TEMPLATE_SKIP] = true;
path.replaceInline(replacement);
}
},
exit: function exit(_ref) {
var node = _ref.node;
if (!node.loc) _babelTraverse2.default.clearNode(node);
}
};
module.exports = exports["default"];
/***/ }),
/* 5 */
/***/ (function(module, exports) {
'use strict';
var core = module.exports = { version: '2.4.0' };
if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
/***/ }),
/* 6 */
/***/ (function(module, exports) {
"use strict";
/**
* Checks if `value` is classified as an `Array` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array, else `false`.
* @example
*
* _.isArray([1, 2, 3]);
* // => true
*
* _.isArray(document.body.children);
* // => false
*
* _.isArray('abc');
* // => false
*
* _.isArray(_.noop);
* // => false
*/
var isArray = Array.isArray;
module.exports = isArray;
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
exports.visitors = exports.Hub = exports.Scope = exports.NodePath = undefined;
var _getIterator2 = __webpack_require__(2);
var _getIterator3 = _interopRequireDefault(_getIterator2);
var _path = __webpack_require__(35);
Object.defineProperty(exports, "NodePath", {
enumerable: true,
get: function get() {
return _interopRequireDefault(_path).default;
}
});
var _scope = __webpack_require__(132);
Object.defineProperty(exports, "Scope", {
enumerable: true,
get: function get() {
return _interopRequireDefault(_scope).default;
}
});
var _hub = __webpack_require__(219);
Object.defineProperty(exports, "Hub", {
enumerable: true,
get: function get() {
return _interopRequireDefault(_hub).default;
}
});
exports.default = traverse;
var _context = __webpack_require__(363);
var _context2 = _interopRequireDefault(_context);
var _visitors = __webpack_require__(380);
var visitors = _interopRequireWildcard(_visitors);
var _babelMessages = __webpack_require__(18);
var messages = _interopRequireWildcard(_babelMessages);
var _includes = __webpack_require__(110);
var _includes2 = _interopRequireDefault(_includes);
var _babelTypes = __webpack_require__(1);
var t = _interopRequireWildcard(_babelTypes);
var _cache = __webpack_require__(86);
var cache = _interopRequireWildcard(_cache);
function _interopRequireWildcard(obj) {
if (obj && obj.__esModule) {
return obj;
} else {
var newObj = {};if (obj != null) {
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
}
}newObj.default = obj;return newObj;
}
}
function _interopRequireDefault(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
exports.visitors = visitors;
function traverse(parent, opts, scope, state, parentPath) {
if (!parent) return;
if (!opts) opts = {};
if (!opts.noScope && !scope) {
if (parent.type !== "Program" && parent.type !== "File") {
throw new Error(messages.get("traverseNeedsParent", parent.type));
}
}
visitors.explode(opts);
traverse.node(parent, opts, scope, state, parentPath);
}
traverse.visitors = visitors;
traverse.verify = visitors.verify;
traverse.explode = visitors.explode;
traverse.NodePath = __webpack_require__(35);
traverse.Scope = __webpack_require__(132);
traverse.Hub = __webpack_require__(219);
traverse.cheap = function (node, enter) {
return t.traverseFast(node, enter);
};
traverse.node = function (node, opts, scope, state, parentPath, skipKeys) {
var keys = t.VISITOR_KEYS[node.type];
if (!keys) return;
var context = new _context2.default(scope, opts, state, parentPath);
for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var key = _ref;
if (skipKeys && skipKeys[key]) continue;
if (context.visit(node, key)) return;
}
};
traverse.clearNode = function (node, opts) {
t.removeProperties(node, opts);
cache.path.delete(node);
};
traverse.removeProperties = function (tree, opts) {
t.traverseFast(tree, traverse.clearNode, opts);
return tree;
};
function hasBlacklistedType(path, state) {
if (path.node.type === state.type) {
state.has = true;
path.stop();
}
}
traverse.hasType = function (tree, scope, type, blacklistTypes) {
if ((0, _includes2.default)(blacklistTypes, tree.type)) return false;
if (tree.type === type) return true;
var state = {
has: false,
type: type
};
traverse(tree, {
blacklist: blacklistTypes,
enter: hasBlacklistedType
}, scope, state);
return state.has;
};
traverse.clearCache = function () {
cache.clear();
};
traverse.clearCache.clearPath = cache.clearPath;
traverse.clearCache.clearScope = cache.clearScope;
traverse.copyCache = function (source, destination) {
if (cache.path.has(source)) {
cache.path.set(destination, cache.path.get(source));
}
};
/***/ }),
/* 8 */
/***/ (function(module, exports) {
'use strict';
// shim for using process in browser
var process = module.exports = {};
// cached from whatever global is present so that test runners that stub it
// don't break things. But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals. It's inside a
// function because try/catches deoptimize in certain engines.
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout() {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
} else {
cachedSetTimeout = defaultSetTimout;
}
} catch (e) {
cachedSetTimeout = defaultSetTimout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
} else {
cachedClearTimeout = defaultClearTimeout;
}
} catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
})();
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch (e) {
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch (e) {
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e) {
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global ob