https://ucgclass.com/player/plyr/babel.js?ver=20211125

1(function webpackUniversalModuleDefinition(root, factory) {
2	if(typeof exports === 'object' && typeof module === 'object')
3		module.exports = factory();
4	else if(typeof define === 'function' && define.amd)
5		define([], factory);
6	else if(typeof exports === 'object')
7		exports["Babel"] = factory();
8	else
9		root["Babel"] = factory();
10})(this, function() {
11return /******/ (function(modules) { // webpackBootstrap
12/******/ 	// The module cache
13/******/ 	var installedModules = {};
14
15/******/ 	// The require function
16/******/ 	function __webpack_require__(moduleId) {
17
18/******/ 		// Check if module is in cache
19/******/ 		if(installedModules[moduleId])
20/******/ 			return installedModules[moduleId].exports;
21
22/******/ 		// Create a new module (and put it into the cache)
23/******/ 		var module = installedModules[moduleId] = {
24/******/ 			exports: {},
25/******/ 			id: moduleId,
26/******/ 			loaded: false
27/******/ 		};
28
29/******/ 		// Execute the module function
30/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
31
32/******/ 		// Flag the module as loaded
33/******/ 		module.loaded = true;
34
35/******/ 		// Return the exports of the module
36/******/ 		return module.exports;
37/******/ 	}
38
39
40/******/ 	// expose the modules object (__webpack_modules__)
41/******/ 	__webpack_require__.m = modules;
42
43/******/ 	// expose the module cache
44/******/ 	__webpack_require__.c = installedModules;
45
46/******/ 	// __webpack_public_path__
47/******/ 	__webpack_require__.p = "";
48
49/******/ 	// Load entry module and return exports
50/******/ 	return __webpack_require__(0);
51/******/ })
52/************************************************************************/
53/******/ ((function(modules) {
54	// Check all modules for deduplicated modules
55	for(var i in modules) {
56		if(Object.prototype.hasOwnProperty.call(modules, i)) {
57			switch(typeof modules[i]) {
58			case "function": break;
59			case "object":
60				// Module can be created from a template
61				modules[i] = (function(_m) {
62					var args = _m.slice(1), fn = modules[_m[0]];
63					return function (a,b,c) {
64						fn.apply(this, [a,b,c].concat(args));
65					};
66				}(modules[i]));
67				break;
68			default:
69				// Module is a copy of another module
70				modules[i] = modules[modules[i]];
71				break;
72			}
73		}
74	}
75	return modules;
76}([
77/* 0 */
78/***/ function(module, exports, __webpack_require__) {
79
80	'use strict';
81
82	Object.defineProperty(exports, "__esModule", {
83	  value: true
84	});
85	exports.version = exports.availablePresets = exports.availablePlugins = undefined;
86
87	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; };
88
89	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; };
90
91	exports.transform = transform;
92	exports.transformFromAst = transformFromAst;
93	exports.registerPlugin = registerPlugin;
94	exports.registerPlugins = registerPlugins;
95	exports.registerPreset = registerPreset;
96	exports.registerPresets = registerPresets;
97	exports.disableScriptTags = disableScriptTags;
98
99	var _babelCore = __webpack_require__(287);
100
101	var Babel = _interopRequireWildcard(_babelCore);
102
103	var _transformScriptTags = __webpack_require__(617);
104
105	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; } }
106
107	var isArray = Array.isArray || function (arg) {
108	  return Object.prototype.toString.call(arg) === '[object Array]';
109	};
110
111	/**
112	 * Loads the given name (or [name, options] pair) from the given table object
113	 * holding the available presets or plugins.
114	 *
115	 * Returns undefined if the preset or plugin is not available; passes through
116	 * name unmodified if it (or the first element of the pair) is not a string.
117	 */
118	function loadBuiltin(builtinTable, name) {
119	  if (isArray(name) && typeof name[0] === 'string') {
120	    if (builtinTable.hasOwnProperty(name[0])) {
121	      return [builtinTable[name[0]]].concat(name.slice(1));
122	    }
123	    return;
124	  } else if (typeof name === 'string') {
125	    return builtinTable[name];
126	  }
127	  // Could be an actual preset/plugin module
128	  return name;
129	}
130
131	/**
132	 * Parses plugin names and presets from the specified options.
133	 */
134	function processOptions(options) {
135	  // Parse preset names
136	  var presets = (options.presets || []).map(function (presetName) {
137	    var preset = loadBuiltin(availablePresets, presetName);
138
139	    if (preset) {
140	      // workaround for babel issue
141	      // at some point, babel copies the preset, losing the non-enumerable
142	      // buildPreset key; convert it into an enumerable key.
143	      if (isArray(preset) && _typeof(preset[0]) === 'object' && preset[0].hasOwnProperty('buildPreset')) {
144	        preset[0] = _extends({}, preset[0], { buildPreset: preset[0].buildPreset });
145	      }
146	    } else {
147	      throw new Error('Invalid preset specified in Babel options: "' + presetName + '"');
148	    }
149	    return preset;
150	  });
151
152	  // Parse plugin names
153	  var plugins = (options.plugins || []).map(function (pluginName) {
154	    var plugin = loadBuiltin(availablePlugins, pluginName);
155
156	    if (!plugin) {
157	      throw new Error('Invalid plugin specified in Babel options: "' + pluginName + '"');
158	    }
159	    return plugin;
160	  });
161
162	  return _extends({
163	    babelrc: false
164	  }, options, {
165	    presets: presets,
166	    plugins: plugins
167	  });
168	}
169
170	function transform(code, options) {
171	  return Babel.transform(code, processOptions(options));
172	}
173
174	function transformFromAst(ast, code, options) {
175	  return Babel.transformFromAst(ast, code, processOptions(options));
176	}
177	var availablePlugins = exports.availablePlugins = {};
178	var availablePresets = exports.availablePresets = {};
179
180	/**
181	 * Registers a named plugin for use with Babel.
182	 */
183	function registerPlugin(name, plugin) {

184	  if (availablePlugins.hasOwnProperty(name)) {
185	    console.warn('A plugin named "' + name + '" is already registered, it will be overridden');
186	  }
187	  availablePlugins[name] = plugin;
188	}
189	/**
190	 * Registers multiple plugins for use with Babel. `newPlugins` should be an object where the key
191	 * is the name of the plugin, and the value is the plugin itself.
192	 */
193	function registerPlugins(newPlugins) {
194	  Object.keys(newPlugins).forEach(function (name) {
195	    return registerPlugin(name, newPlugins[name]);
196	  });
197	}
198
199	/**
200	 * Registers a named preset for use with Babel.
201	 */
202	function registerPreset(name, preset) {
203	  if (availablePresets.hasOwnProperty(name)) {
204	    console.warn('A preset named "' + name + '" is already registered, it will be overridden');
205	  }
206	  availablePresets[name] = preset;
207	}
208	/**
209	 * Registers multiple presets for use with Babel. `newPresets` should be an object where the key
210	 * is the name of the preset, and the value is the preset itself.
211	 */
212	function registerPresets(newPresets) {
213	  Object.keys(newPresets).forEach(function (name) {
214	    return registerPreset(name, newPresets[name]);
215	  });
216	}
217
218	// All the plugins we should bundle
219	registerPlugins({
220	  'check-es2015-constants': __webpack_require__(64),
221	  'external-helpers': __webpack_require__(319),
222	  'syntax-async-functions': __webpack_require__(65),
223	  'syntax-async-generators': __webpack_require__(192),
224	  'syntax-class-constructor-call': __webpack_require__(193),
225	  'syntax-class-properties': __webpack_require__(194),
226	  'syntax-decorators': __webpack_require__(122),
227	  'syntax-do-expressions': __webpack_require__(195),
228	  'syntax-exponentiation-operator': __webpack_require__(196),
229	  'syntax-export-extensions': __webpack_require__(197),
230	  'syntax-flow': __webpack_require__(123),
231	  'syntax-function-bind': __webpack_require__(198),
232	  'syntax-function-sent': __webpack_require__(321),
233	  'syntax-jsx': __webpack_require__(124),
234	  'syntax-object-rest-spread': __webpack_require__(199),
235	  'syntax-trailing-function-commas': __webpack_require__(125),
236	  'transform-async-functions': __webpack_require__(322),
237	  'transform-async-to-generator': __webpack_require__(126),
238	  'transform-async-to-module-method': __webpack_require__(324),
239	  'transform-class-constructor-call': __webpack_require__(200),
240	  'transform-class-properties': __webpack_require__(201),
241	  'transform-decorators': __webpack_require__(202),
242	  'transform-decorators-legacy': __webpack_require__(325).default, // <- No clue. Nope.
243	  'transform-do-expressions': __webpack_require__(203),
244	  'transform-es2015-arrow-functions': __webpack_require__(66),
245	  'transform-es2015-block-scoped-functions': __webpack_require__(67),
246	  'transform-es2015-block-scoping': __webpack_require__(68),
247	  'transform-es2015-classes': __webpack_require__(69),
248	  'transform-es2015-computed-properties': __webpack_require__(70),
249	  'transform-es2015-destructuring': __webpack_require__(71),
250	  'transform-es2015-duplicate-keys': __webpack_require__(127),
251	  'transform-es2015-for-of': __webpack_require__(72),
252	  'transform-es2015-function-name': __webpack_require__(73),
253	  'transform-es2015-instanceof': __webpack_require__(328),
254	  'transform-es2015-literals': __webpack_require__(74),
255	  'transform-es2015-modules-amd': __webpack_require__(128),
256	  'transform-es2015-modules-commonjs': __webpack_require__(75),
257	  'transform-es2015-modules-systemjs': __webpack_require__(205),
258	  'transform-es2015-modules-umd': __webpack_require__(206),
259	  'transform-es2015-object-super': __webpack_require__(76),
260	  'transform-es2015-parameters': __webpack_require__(77),
261	  'transform-es2015-shorthand-properties': __webpack_require__(78),
262	  'transform-es2015-spread': __webpack_require__(79),
263	  'transform-es2015-sticky-regex': __webpack_require__(80),
264	  'transform-es2015-template-literals': __webpack_require__(81),
265	  'transform-es2015-typeof-symbol': __webpack_require__(82),
266	  'transform-es2015-unicode-regex': __webpack_require__(83),
267	  'transform-es3-member-expression-literals': __webpack_require__(332),
268	  'transform-es3-property-literals': __webpack_require__(333),

269	  'transform-es5-property-mutators': __webpack_require__(334),
270	  'transform-eval': __webpack_require__(335),
271	  'transform-exponentiation-operator': __webpack_require__(129),
272	  'transform-export-extensions': __webpack_require__(207),
273	  'transform-flow-comments': __webpack_require__(336),
274	  'transform-flow-strip-types': __webpack_require__(208),
275	  'transform-function-bind': __webpack_require__(209),
276	  'transform-jscript': __webpack_require__(337),
277	  'transform-object-assign': __webpack_require__(338),
278	  'transform-object-rest-spread': __webpack_require__(210),
279	  'transform-object-set-prototype-of-to-assign': __webpack_require__(339),
280	  'transform-proto-to-assign': __webpack_require__(340),
281	  'transform-react-constant-elements': __webpack_require__(341),
282	  'transform-react-display-name': __webpack_require__(211),
283	  'transform-react-inline-elements': __webpack_require__(342),
284	  'transform-react-jsx': __webpack_require__(212),
285	  'transform-react-jsx-compat': __webpack_require__(343),
286	  'transform-react-jsx-self': __webpack_require__(344),
287	  'transform-react-jsx-source': __webpack_require__(345),
288	  'transform-regenerator': __webpack_require__(84),
289	  'transform-runtime': __webpack_require__(347),
290	  'transform-strict-mode': __webpack_require__(213),
291	  'undeclared-variables-check': __webpack_require__(348)
292	});
293
294	// All the presets we should bundle
295	registerPresets({
296	  es2015: __webpack_require__(214),
297	  es2016: __webpack_require__(215),
298	  es2017: __webpack_require__(216),
299	  latest: __webpack_require__(350),
300	  react: __webpack_require__(351),
301	  'stage-0': __webpack_require__(352),
302	  'stage-1': __webpack_require__(217),
303	  'stage-2': __webpack_require__(218),
304	  'stage-3': __webpack_require__(219),
305
306	  // ES2015 preset with es2015-modules-commonjs removed
307	  // Plugin list copied from babel-preset-es2015/index.js
308	  'es2015-no-commonjs': {
309	    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 }]]
310	  },
311
312	  // ES2015 preset with plugins set to loose mode.
313	  // Based off https://github.com/bkonkle/babel-preset-es2015-loose/blob/master/index.js
314	  'es2015-loose': {
315	    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__(127), [__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 }]]
316	  }
317	});
318
319	var version = exports.version = ("6.24.0");
320
321	// Listen for load event if we're in a browser and then kick off finding and
322	// running of scripts with "text/babel" type.
323	var transformScriptTags = function transformScriptTags() {
324	  return (0, _transformScriptTags.runScripts)(transform);
325	};
326	if (typeof window !== 'undefined' && window && window.addEventListener) {
327	  window.addEventListener('DOMContentLoaded', transformScriptTags, false);
328	}
329
330	/**
331	 * Disables automatic transformation of <script> tags with "text/babel" type.
332	 */
333	function disableScriptTags() {
334	  window.removeEventListener('DOMContentLoaded', transformScriptTags);
335	}
336
337/***/ },
338/* 1 */
339/***/ function(module, exports, __webpack_require__) {
340
341	"use strict";
342
343	exports.__esModule = true;
344	exports.createTypeAnnotationBasedOnTypeof = exports.removeTypeDuplicates = exp

344orts.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;
345
346	var _getOwnPropertySymbols = __webpack_require__(354);
347
348	var _getOwnPropertySymbols2 = _interopRequireDefault(_getOwnPropertySymbols);
349
350	var _getIterator2 = __webpack_require__(2);
351
352	var _getIterator3 = _interopRequireDefault(_getIterator2);
353
354	var _keys = __webpack_require__(13);
355
356	var _keys2 = _interopRequireDefault(_keys);
357
358	var _stringify = __webpack_require__(34);
359
360	var _stringify2 = _interopRequireDefault(_stringify);
361
362	var _constants = __webpack_require__(132);
363
364	Object.defineProperty(exports, "STATEMENT_OR_BLOCK_KEYS", {
365	  enumerable: true,
366	  get: function get() {
367	    return _constants.STATEMENT_OR_BLOCK_KEYS;
368	  }
369	});
370	Object.defineProperty(exports, "FLATTENABLE_KEYS", {
371	  enumerable: true,
372	  get: function get() {
373	    return _constants.FLATTENABLE_KEYS;
374	  }
375	});
376	Object.defineProperty(exports, "FOR_INIT_KEYS", {
377	  enumerable: true,
378	  get: function get() {
379	    return _constants.FOR_INIT_KEYS;
380	  }
381	});
382	Object.defineProperty(exports, "COMMENT_KEYS", {
383	  enumerable: true,
384	  get: function get() {
385	    return _constants.COMMENT_KEYS;
386	  }
387	});
388	Object.defineProperty(exports, "LOGICAL_OPERATORS", {
389	  enumerable: true,
390	  get: function get() {
391	    return _constants.LOGICAL_OPERATORS;
392	  }
393	});
394	Object.defineProperty(exports, "UPDATE_OPERATORS", {
395	  enumerable: true,
396	  get: function get() {
397	    return _constants.UPDATE_OPERATORS;
398	  }
399	});
400	Object.defineProperty(exports, "BOOLEAN_NUMBER_BINARY_OPERATORS", {
401	  enumerable: true,
402	  get: function get() {
403	    return _constants.BOOLEAN_NUMBER_BINARY_OPERATORS;
404	  }
405	});
406	Object.defineProperty(exports, "EQUALITY_BINARY_OPERATORS", {
407	  enumerable: true,
408	  get: function get() {
409	    return _constants.EQUALITY_BINARY_OPERATORS;
410	  }
411	});
412	Object.defineProperty(exports, "COMPARISON_BINARY_OPERATORS", {
413	  enumerable: true,
414	  get: function get() {
415	    return _constants.COMPARISON_BINARY_OPERATORS;
416	  }
417	});
418	Object.defineProperty(exports, "BOOLEAN_BINARY_OPERATORS", {
419	  enumerable: true,
420	  get: function get() {
421	    return _constants.BOOLEAN_BINARY_OPERATORS;
422	  }
423	});
424	Object.defineProperty(exports, "NUMBER_BINARY_OPERATORS", {
425	  enumerable: true,
426	  get: function get() {
427	    return _constants.NUMBER_BINARY_OPERATORS;
428	  }
429	});
430	Object.defineProperty(exports, "BINARY_OPERATORS", {
431	  enumerable: true,
432	  get: function get() {
433	    return _constants.BINARY_OPERATORS;
434	  }
435	});
436	Object.defineProperty(exports, "BOOLEAN_UNARY_OPERATORS", {
437	  enumerable: true,
438	  get: function get() {
439	    return _constants.BOOLEAN_UNARY_OPERATORS;
440	  }
441	});
442	Object.defineProperty(exports, "NUMBER_UNARY_OPERATORS", {
443	  enumerable: true,
444	  get: function get() {
445	    return _constants.NUMBER_UNARY_OPERATORS;
446	  }
447	});
448	Object.defineProperty(exports, "STRING_UNARY_OPERATORS", {
449	  enumerable: true,
450	  get: function get() {
451	    return _constants.STRING_UNARY_OPERATORS;
452	  }
453	});
454	Object.defineProperty(exports, "UNARY_OPERATORS", {
455	  enumerable: true,
456	  get: function get() {
457	    return _constants.UNARY_OPERATORS;
458	  }
459	});
460	Object.defineProperty(exports, "INHERIT_KEYS", {
461	  enumerable: true,
462	  get: function get() {
463	    return _constants.INHERIT_KEYS;
464	  }
465	});
466	Object.defineProperty(exports, "BLOCK_SCOPED_SYMBOL", {
467	  enumerable: true,
468	  get: function get() {
469	    return _constants.BLOCK_SCOPED_SYMBOL;
470	  }
471	});
472	Object.defineProperty(exports, "NOT_LOCAL_BINDING", {
473	  enumerable: true,
474	  get: function get() {
475	    return _constants.NOT_LOCAL_BINDING;
476	  }
477	});
478	exports.is = is;
479	exports.isType = isType;

480	exports.validate = validate;
481	exports.shallowEqual = shallowEqual;
482	exports.appendToMemberExpression = appendToMemberExpression;
483	exports.prependToMemberExpression = prependToMemberExpression;
484	exports.ensureBlock = ensureBlock;
485	exports.clone = clone;
486	exports.cloneWithoutLoc = cloneWithoutLoc;
487	exports.cloneDeep = cloneDeep;
488	exports.buildMatchMemberExpression = buildMatchMemberExpression;
489	exports.removeComments = removeComments;
490	exports.inheritsComments = inheritsComments;
491	exports.inheritTrailingComments = inheritTrailingComments;
492	exports.inheritLeadingComments = inheritLeadingComments;
493	exports.inheritInnerComments = inheritInnerComments;
494	exports.inherits = inherits;
495	exports.assertNode = assertNode;
496	exports.isNode = isNode;
497	exports.traverseFast = traverseFast;
498	exports.removeProperties = removeProperties;
499	exports.removePropertiesDeep = removePropertiesDeep;
500
501	var _retrievers = __webpack_require__(223);
502
503	Object.defineProperty(exports, "getBindingIdentifiers", {
504	  enumerable: true,
505	  get: function get() {
506	    return _retrievers.getBindingIdentifiers;
507	  }
508	});
509	Object.defineProperty(exports, "getOuterBindingIdentifiers", {
510	  enumerable: true,
511	  get: function get() {
512	    return _retrievers.getOuterBindingIdentifiers;
513	  }
514	});
515
516	var _validators = __webpack_require__(389);
517
518	Object.defineProperty(exports, "isBinding", {
519	  enumerable: true,
520	  get: function get() {
521	    return _validators.isBinding;
522	  }
523	});
524	Object.defineProperty(exports, "isReferenced", {
525	  enumerable: true,
526	  get: function get() {
527	    return _validators.isReferenced;
528	  }
529	});
530	Object.defineProperty(exports, "isValidIdentifier", {
531	  enumerable: true,
532	  get: function get() {
533	    return _validators.isValidIdentifier;
534	  }
535	});
536	Object.defineProperty(exports, "isLet", {
537	  enumerable: true,
538	  get: function get() {
539	    return _validators.isLet;
540	  }
541	});
542	Object.defineProperty(exports, "isBlockScoped", {
543	  enumerable: true,
544	  get: function get() {
545	    return _validators.isBlockScoped;
546	  }
547	});
548	Object.defineProperty(exports, "isVar", {
549	  enumerable: true,
550	  get: function get() {
551	    return _validators.isVar;
552	  }
553	});
554	Object.defineProperty(exports, "isSpecifierDefault", {
555	  enumerable: true,
556	  get: function get() {
557	    return _validators.isSpecifierDefault;
558	  }
559	});
560	Object.defineProperty(exports, "isScope", {
561	  enumerable: true,
562	  get: function get() {
563	    return _validators.isScope;
564	  }
565	});
566	Object.defineProperty(exports, "isImmutable", {
567	  enumerable: true,
568	  get: function get() {
569	    return _validators.isImmutable;
570	  }
571	});
572	Object.defineProperty(exports, "isNodesEquivalent", {
573	  enumerable: true,
574	  get: function get() {
575	    return _validators.isNodesEquivalent;
576	  }
577	});
578
579	var _converters = __webpack_require__(379);
580
581	Object.defineProperty(exports, "toComputedKey", {
582	  enumerable: true,
583	  get: function get() {
584	    return _converters.toComputedKey;
585	  }
586	});
587	Object.defineProperty(exports, "toSequenceExpression", {
588	  enumerable: true,
589	  get: function get() {
590	    return _converters.toSequenceExpression;
591	  }
592	});
593	Object.defineProperty(exports, "toKeyAlias", {
594	  enumerable: true,
595	  get: function get() {
596	    return _converters.toKeyAlias;
597	  }
598	});
599	Object.defineProperty(exports, "toIdentifier", {
600	  enumerable: true,
601	  get: function get() {
602	    return _converters.toIdentifier;
603	  }
604	});
605	Object.defineProperty(exports, "toBindingIdentifierName", {
606	  enumerable: true,
607	  get: function get() {
608	    return _converters.toBindingIdentifierName;
609	  }
610	});
611	Object.defineProperty(exports, "toStatement", {
612	  enumerable: true,
613	  get: function get() {
614	    return _converters.toStatement;
615	  }
616	});
617	Object.defineProperty(exports, "toExpression", {
618	  enumerable: true,
619	  get: function get() {
620	    return _converters.toExpression;
621	  }
622	});
623	Object.defineProperty(exports, "toBlock", {
624	  enumerable: true,
625	  get: function get() {
626	    return _converters.toBlock;
627	  }
628	});
629	Object.defineProperty(exports, "valueToNode", {
630	  enumerable: true,
631	  get: function get() {
632	    return _converters.valueToNode;
633	  }
634	});
635
636	var _flow = __webpack_require__(387);
637
638	Object.defineProperty(exports, "createUnionTypeAnnotation", {
639	  enumerable: true,
640	  get: function get() {
641	    return _flow.createUnionTypeAnnotation;
642	  }
643	});
644	Object.defineProperty(exports, "removeTypeDuplicates", {
645	  enumerable: true,
646	  get: function get() {
647	    return _flow.removeTypeDuplicates;
648	  }
649	});
650	Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
651	  enumerable: true,
652	  get: function get() {
653	    return _flow.createTypeAnnotationBasedOnTypeof;
654	  }
655	});
656
657	var _toFastProperties = __webpack_require__(612);
658
659	var _toFastProperties2 = _interopRequireDefault(_toFastProperties);
660
661	var _clone = __webpack_require__(107);
662
663	var _clone2 = _interopRequireDefault(_clone);
664
665	var _uniq = __webpack_require__(589);
666
667	var _uniq2 = _interopRequireDefault(_uniq);
668
669	__webpack_require__(384);
670
671	var _definitions = __webpack_require__(26);
672
673	var _react2 = __webpack_require__(388);
674
675	var _react = _interopRequireWildcard(_react2);
676
677	function _interopRequireWildcard(obj) {
678	  if (obj && obj.__esModule) {
679	    return obj;
680	  } else {
681	    var newObj = {};if (obj != null) {
682	      for (var key in obj) {
683	        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
684	      }
685	    }newObj.default = obj;return newObj;
686	  }
687	}
688
689	function _interopRequireDefault(obj) {
690	  return obj && obj.__esModule ? obj : { default: obj };
691	}
692
693	var t = exports;
694
695	function registerType(type) {
696	  var is = t["is" + type];
697	  if (!is) {
698	    is = t["is" + type] = function (node, opts) {
699	      return t.is(type, node, opts);
700	    };
701	  }
702
703	  t["assert" + type] = function (node, opts) {
704	    opts = opts || {};
705	    if (!is(node, opts)) {
706	      throw new Error("Expected type " + (0, _stringify2.default)(type) + " with option " + (0, _stringify2.default)(opts));
707	    }
708	  };
709	}
710
711	exports.VISITOR_KEYS = _definitions.VISITOR_KEYS;
712	exports.ALIAS_KEYS = _definitions.ALIAS_KEYS;
713	exports.NODE_FIELDS = _definitions.NODE_FIELDS;
714	exports.BUILDER_KEYS = _definitions.BUILDER_KEYS;
715	exports.DEPRECATED_KEYS = _definitions.DEPRECATED_KEYS;
716	exports.react = _react;
717
718	for (var type in t.VISITOR_KEYS) {
719	  registerType(type);
720	}
721
722	t.FLIPPED_ALIAS_KEYS = {};
723

724	(0, _keys2.default)(t.ALIAS_KEYS).forEach(function (type) {
725	  t.ALIAS_KEYS[type].forEach(function (alias) {
726	    var types = t.FLIPPED_ALIAS_KEYS[alias] = t.FLIPPED_ALIAS_KEYS[alias] || [];
727	    types.push(type);
728	  });
729	});
730
731	(0, _keys2.default)(t.FLIPPED_ALIAS_KEYS).forEach(function (type) {
732	  t[type.toUpperCase() + "_TYPES"] = t.FLIPPED_ALIAS_KEYS[type];
733	  registerType(type);
734	});
735
736	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));
737
738	function is(type, node, opts) {
739	  if (!node) return false;
740
741	  var matches = isType(node.type, type);
742	  if (!matches) return false;
743
744	  if (typeof opts === "undefined") {
745	    return true;
746	  } else {
747	    return t.shallowEqual(node, opts);
748	  }
749	}
750
751	function isType(nodeType, targetType) {
752	  if (nodeType === targetType) return true;
753
754	  if (t.ALIAS_KEYS[targetType]) return false;
755
756	  var aliases = t.FLIPPED_ALIAS_KEYS[targetType];
757	  if (aliases) {
758	    if (aliases[0] === nodeType) return true;
759
760	    for (var _iterator = aliases, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
761	      var _ref;
762
763	      if (_isArray) {
764	        if (_i >= _iterator.length) break;
765	        _ref = _iterator[_i++];
766	      } else {
767	        _i = _iterator.next();
768	        if (_i.done) break;
769	        _ref = _i.value;
770	      }
771
772	      var alias = _ref;
773
774	      if (nodeType === alias) return true;
775	    }
776	  }
777
778	  return false;
779	}
780
781	(0, _keys2.default)(t.BUILDER_KEYS).forEach(function (type) {
782	  var keys = t.BUILDER_KEYS[type];
783
784	  function builder() {
785	    if (arguments.length > keys.length) {
786	      throw new Error("t." + type + ": Too many arguments passed. Received " + arguments.length + " but can receive " + ("no more than " + keys.length));
787	    }
788
789	    var node = {};
790	    node.type = type;
791
792	    var i = 0;
793
794	    for (var _iterator2 = keys, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
795	      var _ref2;
796
797	      if (_isArray2) {
798	        if (_i2 >= _iterator2.length) break;
799	        _ref2 = _iterator2[_i2++];
800	      } else {
801	        _i2 = _iterator2.next();
802	        if (_i2.done) break;
803	        _ref2 = _i2.value;
804	      }
805
806	      var _key = _ref2;
807
808	      var field = t.NODE_FIELDS[type][_key];
809
810	      var arg = arguments[i++];
811	      if (arg === undefined) arg = (0, _clone2.default)(field.default);
812
813	      node[_key] = arg;
814	    }
815
816	    for (var key in node) {
817	      validate(node, key, node[key]);
818	    }
819
820	    return node;
821	  }
822
823	  t[type] = builder;
824	  t[type[0].toLowerCase() + type.slice(1)] = builder;
825	});
826
827	var _loop = function _loop(_type) {
828	  var newType = t.DEPRECATED_KEYS[_type];
829
830	  function proxy(fn) {
831	    return function () {
832	      console.trace("The node type " + _type + " has been renamed to " + newType);
833	      return fn.apply(this, arguments);
834	    };
835	  }
836
837	  t[_type] = t[_type[0].toLowerCase() + _type.slice(1)] = proxy(t[newType]);
838	  t["is" + _type] = proxy(t["is" + newType]);
839	  t["assert" + _type] = proxy(t["assert" + newType]);
840	};
841
842	for (var _type in t.DEPRECATED_KEYS) {
843	  _loop(_type);
844	}
845
846	function validate(node, key, val) {
847	  if (!node) return;
848
849	  var fields = t.NODE_FIELDS[node.type];
850	  if (!fields) return;
851
852	  var field = fields[key];
853	  if (!field || !field.validate) return;
854	  if (field.optional && val == null) return;
855
856	  field.validate(node, key, val);
857	}
858
859	function shallowEqual(actual, expected) {
860	  var keys = (0, _keys2.default)(expected);
861
862	  for (var _iterator3 = keys, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
863	    var _ref3;
864
865	    if (_isArray3) {
866	      if (_i3 >= _iterator3.length) break;
867	      _ref3 = _iterator3[_i3++];
868	    } else {
869	      _i3 = _iterator3.next();
870	      if (_i3.done) break;
871	      _ref3 = _i3.value;
872	    }
873
874	    var key = _ref3;
875
876	    if (actual[key] !== expected[key]) {
877	      return false;

878	    }
879	  }
880
881	  return true;
882	}
883
884	function appendToMemberExpression(member, append, computed) {
885	  member.object = t.memberExpression(member.object, member.property, member.computed);
886	  member.property = append;
887	  member.computed = !!computed;
888	  return member;
889	}
890
891	function prependToMemberExpression(member, prepend) {
892	  member.object = t.memberExpression(prepend, member.object);
893	  return member;
894	}
895
896	function ensureBlock(node) {
897	  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "body";
898
899	  return node[key] = t.toBlock(node[key], node);
900	}
901
902	function clone(node) {
903	  if (!node) return node;
904	  var newNode = {};
905	  for (var key in node) {
906	    if (key[0] === "_") continue;
907	    newNode[key] = node[key];
908	  }
909	  return newNode;
910	}
911
912	function cloneWithoutLoc(node) {
913	  var newNode = clone(node);
914	  delete newNode.loc;
915	  return newNode;
916	}
917
918	function cloneDeep(node) {
919	  if (!node) return node;
920	  var newNode = {};
921
922	  for (var key in node) {
923	    if (key[0] === "_") continue;
924
925	    var val = node[key];
926
927	    if (val) {
928	      if (val.type) {
929	        val = t.cloneDeep(val);
930	      } else if (Array.isArray(val)) {
931	        val = val.map(t.cloneDeep);
932	      }
933	    }
934
935	    newNode[key] = val;
936	  }
937
938	  return newNode;
939	}
940
941	function buildMatchMemberExpression(match, allowPartial) {
942	  var parts = match.split(".");
943
944	  return function (member) {
945	    if (!t.isMemberExpression(member)) return false;
946
947	    var search = [member];
948	    var i = 0;
949
950	    while (search.length) {
951	      var node = search.shift();
952
953	      if (allowPartial && i === parts.length) {
954	        return true;
955	      }
956
957	      if (t.isIdentifier(node)) {
958	        if (parts[i] !== node.name) return false;
959	      } else if (t.isStringLiteral(node)) {
960	        if (parts[i] !== node.value) return false;
961	      } else if (t.isMemberExpression(node)) {
962	        if (node.computed && !t.isStringLiteral(node.property)) {
963	          return false;
964	        } else {
965	          search.push(node.object);
966	          search.push(node.property);
967	          continue;
968	        }
969	      } else {
970	        return false;
971	      }
972
973	      if (++i > parts.length) {
974	        return false;
975	      }
976	    }
977
978	    return true;
979	  };
980	}
981
982	function removeComments(node) {
983	  for (var _iterator4 = t.COMMENT_KEYS, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) {
984	    var _ref4;
985
986	    if (_isArray4) {
987	      if (_i4 >= _iterator4.length) break;
988	      _ref4 = _iterator4[_i4++];
989	    } else {
990	      _i4 = _iterator4.next();
991	      if (_i4.done) break;
992	      _ref4 = _i4.value;
993	    }
994
995	    var key = _ref4;
996
997	    delete node[key];
998	  }
999	  return node;
1000	}
1001
1002	function inheritsComments(child, parent) {
1003	  inheritTrailingComments(child, parent);
1004	  inheritLeadingComments(child, parent);
1005	  inheritInnerComments(child, parent);
1006	  return child;
1007	}
1008
1009	function inheritTrailingComments(child, parent) {
1010	  _inheritComments("trailingComments", child, parent);
1011	}
1012
1013	function inheritLeadingComments(child, parent) {
1014	  _inheritComments("leadingComments", child, parent);
1015	}
1016
1017	function inheritInnerComments(child, parent) {
1018	  _inheritComments("innerComments", child, parent);
1019	}
1020
1021	function _inheritComments(key, child, parent) {
1022	  if (child && parent) {
1023	    child[key] = (0, _uniq2.default)([].concat(child[key], parent[key]).filter(Boolean));
1024	  }
1025	}
1026
1027	function inherits(child, parent) {
1028	  if (!child || !parent) return child;
1029
1030	  for (var _iterator5 = t.INHERIT_KEYS.optional, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : (0, _getIterator3.default)(_iterator5);;) {
1031	    var _ref5;
1032
1033	    if (_isArray5) {
1034	      if (_i5 >= _iterator5.length) break;
1035	      _ref5 = _iterator5[_i5++];
1036	    } else {
1037	      _i5 = _iterator5.next();
1038	      if (_i5.done) break;
1039	      _ref5 = _i5.value;
1040	    }
1041
1042	    var _key2 = _ref5;
1043
1044	    if (child[_key2] == null) {
1045	      child[_key2] = parent[_key2];
1046	    }
1047	  }
1048
1049	  for (var key in parent) {
1050	    if (key[0] === "_") child[key] = parent[key];
1051	  }
1052
1053	  for (var _iterator6 = t.INHERIT_KEYS.force, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : (0, _getIterator3.default)(_iterator6);;) {
1054	    var _ref6;
1055
1056	    if (_isArray6) {
1057	      if (_i6 >= _iterator6.length) break;
1058	      _ref6 = _iterator6[_i6++];
1059	    } else {
1060	      _i6 = _iterator6.next();
1061	      if (_i6.done) break;
1062	      _ref6 = _i6.value;
1063	    }
1064
1065	    var _key3 = _ref6;
1066
1067	    child[_key3] = parent[_key3];
1068	  }
1069
1070	  t.inheritsComments(child, parent);
1071
1072	  return child;
1073	}
1074
1075	function assertNode(node) {
1076	  if (!isNode(node)) {
1077	    throw new TypeError("Not a valid node " + (node && node.type));
1078	  }
1079	}
1080
1081	function isNode(node) {
1082	  return !!(node && _definitions.VISITOR_KEYS[node.type]);
1083	}
1084
1085	(0, _toFastProperties2.default)(t);
1086	(0, _toFastProperties2.default)(t.VISITOR_KEYS);
1087
1088	function traverseFast(node, enter, opts) {
1089	  if (!node) return;
1090
1091	  var keys = t.VISITOR_KEYS[node.type];
1092	  if (!keys) return;
1093
1094	  opts = opts || {};
1095	  enter(node, opts);
1096
1097	  for (var _iterator7 = keys, _isArray7 = Array.isArray(_iterator7), _i7 = 0, _iterator7 = _isArray7 ? _iterator7 : (0, _getIterator3.default)(_iterator7);;) {
1098	    var _ref7;
1099
1100	    if (_isArray7) {
1101	      if (_i7 >= _iterator7.length) break;
1102	      _ref7 = _iterator7[_i7++];
1103	    } else {
1104	      _i7 = _iterator7.next();
1105	      if (_i7.done) break;
1106	      _ref7 = _i7.value;
1107	    }
1108
1109	    var key = _ref7;
1110
1111	    var subNode = node[key];
1112
1113	    if (Array.isArray(subNode)) {
1114	      for (var _iterator8 = subNode, _isArray8 = Array.isArray(_iterator8), _i8 = 0, _iterator8 = _isArray8 ? _iterator8 : (0, _getIterator3.default)(_iterator8);;) {
1115	        var _ref8;
1116
1117	        if (_isArray8) {
1118	          if (_i8 >= _iterator8.length) break;
1119	          _ref8 = _iterator8[_i8++];
1120	        } else {
1121	          _i8 = _iterator8.next();
1122	          if (_i8.done) break;
1123	          _ref8 = _i8.value;
1124	        }
1125
1126	        var _node = _ref8;
1127
1128	        traverseFast(_node, enter, opts);
1129	      }
1130	    } else {
1131	      traverseFast(subNode, enter, opts);
1132	    }
1133	  }
1134	}
1135
1136	var CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
1137
1138	var CLEAR_KEYS_PLUS_COMMENTS = t.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
1139
1140	function removeProperties(node, opts) {
1141	  opts = opts || {};
1142	  var map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
1143	  for (var _iterator9 = map, _isArray9 = Array.isArray(_iterator9), _i9 = 0, _iterator9 = _isArray9 ? _iterator9 : (0, _getIterator3.default)(_iterator9);;) {
1144	    var _ref9;
1145
1146	    if (_isArray9) {
1147	      if (_i9 >= _iterator9.length) break;
1148	      _ref9 = _iterator9[_i9++];
1149	    } else {
1150	      _i9 = _iterator9.next();
1151	      if (_i9.done) break;
1152	      _ref9 = _i9.value;
1153	    }
1154
1155	    var _key4 = _ref9;
1156
1157	    if (node[_key4] != null) node[_key4] = undefined;
1158	  }
1159
1160	  for (var key in node) {
1161	    if (key[0] === "_" && node[key] != null) node[key] = undefined;
1162	  }
1163
1164	  var syms = (0, _getOwnPropertySymbols2.default)(node);
1165	  for (var _iterator10 = syms, _isArray10 = Array.isArray(_iterator10), _i10 = 0, _iterator10 = _isArray10 ? _iterator10 

1165: (0, _getIterator3.default)(_iterator10);;) {
1166	    var _ref10;
1167
1168	    if (_isArray10) {
1169	      if (_i10 >= _iterator10.length) break;
1170	      _ref10 = _iterator10[_i10++];
1171	    } else {
1172	      _i10 = _iterator10.next();
1173	      if (_i10.done) break;
1174	      _ref10 = _i10.value;
1175	    }
1176
1177	    var sym = _ref10;
1178
1179	    node[sym] = null;
1180	  }
1181	}
1182
1183	function removePropertiesDeep(tree, opts) {
1184	  traverseFast(tree, removeProperties, opts);
1185	  return tree;
1186	}
1187
1188/***/ },
1189/* 2 */
1190/***/ function(module, exports, __webpack_require__) {
1191
1192	"use strict";
1193
1194	module.exports = { "default": __webpack_require__(398), __esModule: true };
1195
1196/***/ },
1197/* 3 */
1198/***/ function(module, exports) {
1199
1200	"use strict";
1201
1202	exports.__esModule = true;
1203
1204	exports.default = function (instance, Constructor) {
1205	  if (!(instance instanceof Constructor)) {
1206	    throw new TypeError("Cannot call a class as a function");
1207	  }
1208	};
1209
1210/***/ },
1211/* 4 */
1212/***/ function(module, exports, __webpack_require__) {
1213
1214	"use strict";
1215
1216	exports.__esModule = true;
1217
1218	var _symbol = __webpack_require__(11);
1219
1220	var _symbol2 = _interopRequireDefault(_symbol);
1221
1222	exports.default = function (code, opts) {
1223	  var stack = void 0;
1224	  try {
1225	    throw new Error();
1226	  } catch (error) {
1227	    if (error.stack) {
1228	      stack = error.stack.split("\n").slice(1).join("\n");
1229	    }
1230	  }
1231
1232	  opts = (0, _assign2.default)({
1233	    allowReturnOutsideFunction: true,
1234	    allowSuperOutsideMethod: true,
1235	    preserveComments: false
1236	  }, opts);
1237
1238	  var _getAst = function getAst() {
1239	    var ast = void 0;
1240
1241	    try {
1242	      ast = babylon.parse(code, opts);
1243
1244	      ast = _babelTraverse2.default.removeProperties(ast, { preserveComments: opts.preserveComments });
1245
1246	      _babelTraverse2.default.cheap(ast, function (node) {
1247	        node[FROM_TEMPLATE] = true;
1248	      });
1249	    } catch (err) {
1250	      err.stack = err.stack + "from\n" + stack;
1251	      throw err;
1252	    }
1253
1254	    _getAst = function getAst() {
1255	      return ast;
1256	    };
1257
1258	    return ast;
1259	  };
1260
1261	  return function () {
1262	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
1263	      args[_key] = arguments[_key];
1264	    }
1265
1266	    return useTemplate(_getAst(), args);
1267	  };
1268	};
1269
1270	var _cloneDeep = __webpack_require__(563);
1271
1272	var _cloneDeep2 = _interopRequireDefault(_cloneDeep);
1273
1274	var _assign = __webpack_require__(170);
1275
1276	var _assign2 = _interopRequireDefault(_assign);
1277
1278	var _has = __webpack_require__(270);
1279
1280	var _has2 = _interopRequireDefault(_has);
1281
1282	var _babelTraverse = __webpack_require__(8);
1283
1284	var _babelTraverse2 = _interopRequireDefault(_babelTraverse);
1285
1286	var _babylon = __webpack_require__(133);
1287
1288	var babylon = _interopRequireWildcard(_babylon);
1289
1290	var _babelTypes = __webpack_require__(1);
1291
1292	var t = _interopRequireWildcard(_babelTypes);
1293
1294	function _interopRequireWildcard(obj) {
1295	  if (obj && obj.__esModule) {
1296	    return obj;
1297	  } else {
1298	    var newObj = {};if (obj != null) {
1299	      for (var key in obj) {
1300	        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
1301	      }
1302	    }newObj.default = obj;return newObj;
1303	  }
1304	}
1305
1306	function _interopRequireDefault(obj) {
1307	  return obj && obj.__esModule ? obj : { default: obj };
1308	}
1309
1310	var FROM_TEMPLATE = "_fromTemplate";
1311	var TEMPLATE_SKIP = (0, _symbol2.default)();
1312
1313	function useTemplate(ast, nodes) {
1314	  ast = (0, _cloneDeep2.default)(ast);
1315	  var _ast = ast,
1316	      program = _ast.program;
1317
1318	  if (nodes.length) {
1319	    (0, _babelTraverse2.default)(ast, templateVisitor, null, nodes);
1320	  }
1321
1322	  if (program.body.length > 1) {
1323	    return program.body;
1324	  } else {
1325	    return program.body[0];
1326	  }
1327	}
1328
1329	var templateVisitor = {
1330	  noScope: true,
1331
1332	  enter: function enter(path, args) {
1333	    var node = path.node;
1334
1335	    if (node[TEMPLATE_SKIP]) return path.skip();
1336
1337	    if (t.isExpressionStatement(node)) {
1338	      node = node.expression;
1339	    }
1340
1341	    var replacement = void 0;
1342
1343	    if (t.isIdentifier(node) && node[FROM_TEMPLATE]) {
1344	      if ((0, _has2.default)(args[0], node.name)) {
1345	        replacement = args[0][node.name];
1346	      } else if (node.name[0] === "$") {
1347	        var i = +node.name.slice(1);
1348	        if (args[i]) replacement = args[i];
1349	      }
1350	    }
1351
1352	    if (replacement === null) {
1353	      path.remove();
1354	    }
1355
1356	    if (replacement) {
1357	      replacement[TEMPLATE_SKIP] = true;
1358	      path.replaceInline(replacement);
1359	    }
1360	  },
1361	  exit: function exit(_ref) {
1362	    var node = _ref.node;
1363
1364	    if (!node.loc) _babelTraverse2.default.clearNode(node);
1365	  }
1366	};
1367	module.exports = exports["default"];
1368
1369/***/ },
1370/* 5 */

1371/***/ function(module, exports) {
1372
1373	'use strict';
1374
1375	var core = module.exports = { version: '2.4.0' };
1376	if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
1377
1378/***/ },
1379/* 6 */
1380/***/ function(module, exports, __webpack_require__) {
1381
1382	"use strict";
1383
1384	var _typeof2 = 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; };
1385
1386	exports.__esModule = true;
1387
1388	var _iterator = __webpack_require__(357);
1389
1390	var _iterator2 = _interopRequireDefault(_iterator);
1391
1392	var _symbol = __webpack_require__(11);
1393
1394	var _symbol2 = _interopRequireDefault(_symbol);
1395
1396	var _typeof = typeof _symbol2.default === "function" && _typeof2(_iterator2.default) === "symbol" ? function (obj) {
1397	  return typeof obj === "undefined" ? "undefined" : _typeof2(obj);
1398	} : function (obj) {
1399	  return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof2(obj);
1400	};
1401
1402	function _interopRequireDefault(obj) {
1403	  return obj && obj.__esModule ? obj : { default: obj };
1404	}
1405
1406	exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function (obj) {
1407	  return typeof obj === "undefined" ? "undefined" : _typeof(obj);
1408	} : function (obj) {
1409	  return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
1410	};
1411
1412/***/ },
1413/* 7 */
1414/***/ function(module, exports) {
1415
1416	"use strict";
1417
1418	/**
1419	 * Checks if `value` is classified as an `Array` object.
1420	 *
1421	 * @static
1422	 * @memberOf _
1423	 * @since 0.1.0
1424	 * @category Lang
1425	 * @param {*} value The value to check.
1426	 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
1427	 * @example
1428	 *
1429	 * _.isArray([1, 2, 3]);
1430	 * // => true
1431	 *
1432	 * _.isArray(document.body.children);
1433	 * // => false
1434	 *
1435	 * _.isArray('abc');
1436	 * // => false
1437	 *
1438	 * _.isArray(_.noop);
1439	 * // => false
1440	 */
1441	var isArray = Array.isArray;
1442
1443	module.exports = isArray;
1444
1445/***/ },
1446/* 8 */
1447/***/ function(module, exports, __webpack_require__) {
1448
1449	"use strict";
1450
1451	exports.__esModule = true;
1452	exports.visitors = exports.Hub = exports.Scope = exports.NodePath = undefined;
1453
1454	var _getIterator2 = __webpack_require__(2);
1455
1456	var _getIterator3 = _interopRequireDefault(_getIterator2);
1457
1458	var _path = __webpack_require__(35);
1459
1460	Object.defineProperty(exports, "NodePath", {
1461	  enumerable: true,
1462	  get: function get() {
1463	    return _interopRequireDefault(_path).default;
1464	  }
1465	});
1466
1467	var _scope = __webpack_require__(131);
1468
1469	Object.defineProperty(exports, "Scope", {
1470	  enumerable: true,
1471	  get: function get() {
1472	    return _interopRequireDefault(_scope).default;
1473	  }
1474	});
1475
1476	var _hub = __webpack_require__(220);
1477
1478	Object.defineProperty(exports, "Hub", {
1479	  enumerable: true,
1480	  get: function get() {
1481	    return _interopRequireDefault(_hub).default;
1482	  }
1483	});
1484	exports.default = traverse;
1485
1486	var _context = __webpack_require__(361);
1487
1488	var _context2 = _interopRequireDefault(_context);
1489
1490	var _visitors = __webpack_require__(378);
1491
1492	var visitors = _interopRequireWildcard(_visitors);
1493
1494	var _babelMessages = __webpack_require__(18);
1495
1496	var messages = _interopRequireWildcard(_babelMessages);
1497
1498	var _includes = __webpack_require__(109);
1499
1500	var _includes2 = _interopRequireDefault(_includes);
1501
1502	var _babelTypes = __webpack_require__(1);
1503
1504	var t = _interopRequireWildcard(_babelTypes);
1505
1506	var _cache = __webpack_require__(86);
1507
1508	var cache = _interopRequireWildcard(_cache);
1509
1510	function _interopRequireWildcard(obj) {
1511	  if (obj && obj.__esModule) {
1512	    return obj;
1513	  } else {
1514	    var newObj = {};if (obj != null) {
1515	      for (var key in obj) {
1516	        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
1517	      }
1518	    }newObj.default = obj;return newObj;
1519	  }
1520	}
1521
1522	function _interopRequireDefault(obj) {
1523	  return obj && obj.__esModule ? obj : { default: obj };
1524	}
1525
1526	exports.visitors = visitors;
1527	function traverse(parent, opts, scope, state, parentPath) {
1528	  if (!parent) return;
1529	  if (!opts) opts = {};
1530
1531	  if (!opts.noScope && !scope) {
1532	    if (parent.type !== "Program" && parent.type !== "File") {
1533	      throw new Error(messages.get("traverseNeedsParent", parent.type));
1534	    }
1535	  }
1536
1537	  visitors.explode(opts);
1538
1539	  traverse.node(parent, opts, scope, state, parentPath);
1540	}
1541
1542	traverse.visitors = visitors;
1543	traverse.verify = visitors.verify;
1544	traverse.explode = visitors.explode;
1545

1546	traverse.NodePath = __webpack_require__(35);
1547	traverse.Scope = __webpack_require__(131);
1548	traverse.Hub = __webpack_require__(220);
1549
1550	traverse.cheap = function (node, enter) {
1551	  return t.traverseFast(node, enter);
1552	};
1553
1554	traverse.node = function (node, opts, scope, state, parentPath, skipKeys) {
1555	  var keys = t.VISITOR_KEYS[node.type];
1556	  if (!keys) return;
1557
1558	  var context = new _context2.default(scope, opts, state, parentPath);
1559	  for (var _iterator = keys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
1560	    var _ref;
1561
1562	    if (_isArray) {
1563	      if (_i >= _iterator.length) break;
1564	      _ref = _iterator[_i++];
1565	    } else {
1566	      _i = _iterator.next();
1567	      if (_i.done) break;
1568	      _ref = _i.value;
1569	    }
1570
1571	    var key = _ref;
1572
1573	    if (skipKeys && skipKeys[key]) continue;
1574	    if (context.visit(node, key)) return;
1575	  }
1576	};
1577
1578	traverse.clearNode = function (node, opts) {
1579	  t.removeProperties(node, opts);
1580
1581	  cache.path.delete(node);
1582	};
1583
1584	traverse.removeProperties = function (tree, opts) {
1585	  t.traverseFast(tree, traverse.clearNode, opts);
1586	  return tree;
1587	};
1588
1589	function hasBlacklistedType(path, state) {
1590	  if (path.node.type === state.type) {
1591	    state.has = true;
1592	    path.stop();
1593	  }
1594	}
1595

1596	traverse.hasType = function (tree, scope, type, blacklistTypes) {
1597	  if ((0, _includes2.default)(blacklistTypes, tree.type)) return false;
1598
1599	  if (tree.type === type) return true;
1600
1601	  var state = {
1602	    has: false,
1603	    type: type
1604	  };
1605
1606	  traverse(tree, {
1607	    blacklist: blacklistTypes,
1608	    enter: hasBlacklistedType
1609	  }, scope, state);
1610
1611	  return state.has;
1612	};
1613
1614	traverse.clearCache = function () {
1615	  cache.clear();
1616	};
1617
1618	traverse.clearCache.clearPath = cache.clearPath;
1619	traverse.clearCache.clearScope = cache.clearScope;
1620
1621	traverse.copyCache = function (source, destination) {
1622	  if (cache.path.has(source)) {
1623	    cache.path.set(destination, cache.path.get(source));
1624	  }
1625	};
1626
1627/***/ },
1628/* 9 */
1629/***/ function(module, exports) {
1630
1631	'use strict';
1632
1633	// shim for using process in browser
1634	var process = module.exports = {};
1635
1636	// cached from whatever global is present so that test runners that stub it
1637	// don't break things.  But we need to wrap it in a try catch in case it is
1638	// wrapped in strict mode code which doesn't define any globals.  It's inside a
1639	// function because try/catches deoptimize in certain engines.
1640
1641	var cachedSetTimeout;
1642	var cachedClearTimeout;
1643
1644	function defaultSetTimout() {
1645	    throw new Error('setTimeout has not been defined');
1646	}
1647	function defaultClearTimeout() {
1648	    throw new Error('clearTimeout has not been defined');
1649	}
1650	(function () {
1651	    try {
1652	        if (typeof setTimeout === 'function') {
1653	            cachedSetTimeout = setTimeout;
1654	        } else {
1655	            cachedSetTimeout = defaultSetTimout;
1656	        }
1657	    } catch (e) {
1658	        cachedSetTimeout = defaultSetTimout;
1659	    }
1660	    try {
1661	        if (typeof clearTimeout === 'function') {
1662	            cachedClearTimeout = clearTimeout;
1663	        } else {
1664	            cachedClearTimeout = defaultClearTimeout;
1665	        }
1666	    } catch (e) {
1667	        cachedClearTimeout = defaultClearTimeout;
1668	    }
1669	})();
1670	function runTimeout(fun) {
1671	    if (cachedSetTimeout === setTimeout) {
1672	        //normal enviroments in sane situations
1673	        return setTimeout(fun, 0);
1674	    }
1675	    // if setTimeout wasn't available but was latter defined
1676	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
1677	        cachedSetTimeout = setTimeout;
1678	        return setTimeout(fun, 0);
1679	    }
1680	    try {
1681	        // when when somebody has screwed with setTimeout but no I.E. maddness
1682	        return cachedSetTimeout(fun, 0);
1683	    } catch (e) {
1684	        try {
1685	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
1686	            return cachedSetTimeout.call(null, fun, 0);
1687	        } catch (e) {
1688	            // 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
1689	            return cachedSetTimeout.call(this, fun, 0);
1690	        }
1691	    }
1692	}
1693	function runClearTimeout(marker) {
1694	    if (cachedClearTimeout === clearTimeout) {
1695	        //normal enviroments in sane situations
1696	        return clearTimeout(marker);
1697	    }
1698	    // if clearTimeout wasn't available but was latter defined
1699	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
1700	        cachedClearTimeout = clearTimeout;
1701	        return clearTimeout(marker);
1702	    }
1703	    try {
1704	        // when when somebody has screwed with setTimeout but no I.E. maddness
1705	        return cachedClearTimeout(marker);
1706	    } catch (e) {
1707	        try {
1708	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
1709	            return cachedClearTimeout.call(null, marker);
1710	        } catch (e) {
1711	            // 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.
1712	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
1713	            return cachedClearTimeout.call(this, marker);
1714	        }
1715	    }
1716	}
1717	var queue = [];
1718	var draining = false;

1719	var currentQueue;
1720	var queueIndex = -1;
1721
1722	function cleanUpNextTick() {
1723	    if (!draining || !currentQueue) {
1724	        return;
1725	    }
1726	    draining = false;
1727	    if (currentQueue.length) {
1728	        queue = currentQueue.concat(queue);
1729	    } else {
1730	        queueIndex = -1;
1731	    }
1732	    if (queue.length) {
1733	        drainQueue();
1734	    }
1735	}
1736
1737	function drainQueue() {
1738	    if (draining) {
1739	        return;
1740	    }
1741	    var timeout = runTimeout(cleanUpNextTick);
1742	    draining = true;
1743
1744	    var len = queue.length;
1745	    while (len) {
1746	        currentQueue = queue;
1747	        queue = [];
1748	        while (++queueIndex < len) {
1749	            if (currentQueue) {
1750	                currentQueue[queueIndex].run();
1751	            }
1752	        }
1753	        queueIndex = -1;
1754	        len = queue.length;
1755	    }
1756	    currentQueue = null;
1757	    draining = false;
1758	    runClearTimeout(timeout);
1759	}
1760
1761	process.nextTick = function (fun) {
1762	    var args = new Array(arguments.length - 1);
1763	    if (arguments.length > 1) {
1764	        for (var i = 1; i < arguments.length; i++) {
1765	            args[i - 1] = arguments[i];
1766	        }
1767	    }
1768	    queue.push(new Item(fun, args));
1769	    if (queue.length === 1 && !draining) {
1770	        runTimeout(drainQueue);
1771	    }
1772	};
1773
1774	// v8 likes predictible objects
1775	function Item(fun, array) {
1776	    this.fun = fun;
1777	    this.array = array;
1778	}
1779	Item.prototype.run = function () {
1780	    this.fun.apply(null, this.array);
1781	};
1782	process.title = 'browser';
1783	process.browser = true;
1784	process.env = {};
1785	process.argv = [];
1786	process.version = ''; // empty string to avoid regexp issues
1787	process.versions = {};
1788
1789	function noop() {}
1790
1791	process.on = noop;
1792	process.addListener = noop;
1793	process.once = noop;
1794	process.off = noop;
1795	process.removeListener = noop;
1796	process.removeAllListeners = noop;
1797	process.emit = noop;
1798
1799	process.binding = function (name) {
1800	    throw new Error('process.binding is not supported');
1801	};
1802
1803	process.cwd = function () {
1804	    return '/';
1805	};
1806	process.chdir = function (dir) {
1807	    throw new Error('process.chdir is not supported');
1808	};
1809	process.umask = function () {
1810	    return 0;
1811	};
1812
1813/***/ },
1814/* 10 */
1815/***/ function(module, exports, __webpack_require__) {
1816
1817	"use strict";
1818
1819	module.exports = { "default": __webpack_require__(403), __esModule: true };
1820
1821/***/ },
1822/* 11 */
1823/***/ function(module, exports, __webpack_require__) {
1824
1825	"use strict";
1826
1827	module.exports = { "default": __webpack_require__(408), __esModule: true };
1828
1829/***/ },
1830/* 12 */
1831/***/ function(module, exports, __webpack_require__) {
1832
1833	'use strict';
1834
1835	var store = __webpack_require__(146)('wks'),
1836	    uid = __webpack_require__(94),
1837	    _Symbol = __webpack_require__(14).Symbol,
1838	    USE_SYMBOL = typeof _Symbol == 'function';
1839
1840	var $exports = module.exports = function (name) {
1841	  return store[name] || (store[name] = USE_SYMBOL && _Symbol[name] || (USE_SYMBOL ? _Symbol : uid)('Symbol.' + name));
1842	};
1843
1844	$exports.store = store;
1845
1846/***/ },
1847/* 13 */
1848/***/ function(module, exports, __webpack_require__) {
1849
1850	"use strict";
1851
1852	module.exports = { "default": __webpack_require__(405), __esModule: true };
1853
1854/***/ },
1855/* 14 */
1856/***/ function(module, exports) {
1857
1858	'use strict';
1859
1860	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
1861	var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
1862	if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
1863
1864/***/ },
1865/* 15 */
1866/***/ function(module, exports, __webpack_require__) {
1867
1868	'use strict';
1869
1870	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; };
1871
1872	var freeGlobal = __webpack_require__(257);
1873
1874	/** Detect free variable `self`. */
1875	var freeSelf = (typeof self === 'undefined' ? 'undefined' : _typeof(self)) == 'object' && self && self.Object === Object && self;
1876
1877	/** Used as a reference to the global object. */
1878	var root = freeGlobal || freeSelf || Function('return this')();
1879
1880	module.exports = root;
1881
1882/***/ },
1883/* 16 */

1884/***/ function(module, exports) {
1885
1886	'use strict';
1887
1888	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; };
1889
1890	/**
1891	 * Checks if `value` is the
1892	 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
1893	 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
1894	 *
1895	 * @static
1896	 * @memberOf _
1897	 * @since 0.1.0
1898	 * @category Lang
1899	 * @param {*} value The value to check.
1900	 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
1901	 * @example
1902	 *
1903	 * _.isObject({});
1904	 * // => true
1905	 *
1906	 * _.isObject([1, 2, 3]);
1907	 * // => true
1908	 *
1909	 * _.isObject(_.noop);
1910	 * // => true
1911	 *
1912	 * _.isObject(null);
1913	 * // => false
1914	 */
1915	function isObject(value) {
1916	  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);
1917	  return value != null && (type == 'object' || type == 'function');
1918	}
1919
1920	module.exports = isObject;
1921
1922/***/ },
1923/* 17 */
1924/***/ function(module, exports, __webpack_require__) {
1925
1926	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
1927
1928	// Copyright Joyent, Inc. and other Node contributors.
1929	//
1930	// Permission is hereby granted, free of charge, to any person obtaining a
1931	// copy of this software and associated documentation files (the
1932	// "Software"), to deal in the Software without restriction, including
1933	// without limitation the rights to use, copy, modify, merge, publish,
1934	// distribute, sublicense, and/or sell copies of the Software, and to permit
1935	// persons to whom the Software is furnished to do so, subject to the
1936	// following conditions:
1937	//
1938	// The above copyright notice and this permission notice shall be included
1939	// in all copies or substantial portions of the Software.
1940	//
1941	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
1942	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
1943	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
1944	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
1945	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
1946	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
1947	// USE OR OTHER DEALINGS IN THE SOFTWARE.
1948
1949	// resolves . and .. elements in a path array with directory names there
1950	// must be no slashes, empty elements, or device names (c:\) in the array
1951	// (so also no leading and trailing slashes - it does not distinguish
1952	// relative and absolute paths)
1953	function normalizeArray(parts, allowAboveRoot) {
1954	  // if the path tries to go above the root, `up` ends up > 0
1955	  var up = 0;
1956	  for (var i = parts.length - 1; i >= 0; i--) {
1957	    var last = parts[i];
1958	    if (last === '.') {
1959	      parts.splice(i, 1);
1960	    } else if (last === '..') {
1961	      parts.splice(i, 1);
1962	      up++;
1963	    } else if (up) {
1964	      parts.splice(i, 1);
1965	      up--;
1966	    }
1967	  }
1968
1969	  // if the path is allowed to go above the root, restore leading ..s
1970	  if (allowAboveRoot) {
1971	    for (; up--; up) {
1972	      parts.unshift('..');
1973	    }
1974	  }
1975
1976	  return parts;
1977	}
1978
1979	// Split a filename into [root, dir, basename, ext], unix version
1980	// 'root' is just a slash, or nothing.
1981	var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
1982	var splitPath = function splitPath(filename) {
1983	  return splitPathRe.exec(filename).slice(1);
1984	};
1985
1986	// path.resolve([from ...], to)
1987	// posix version
1988	exports.resolve = function () {
1989	  var resolvedPath = '',
1990	      resolvedAbsolute = false;
1991
1992	  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
1993	    var path = i >= 0 ? arguments[i] : process.cwd();
1994
1995	    // Skip empty and invalid entries
1996	    if (typeof path !== 'string') {
1997	      throw new TypeError('Arguments to path.resolve must be strings');
1998	    } else if (!path) {
1999	      continue;
2000	    }
2001
2002	    resolvedPath = path + '/' + resolvedPath;
2003	    resolvedAbsolute = path.charAt(0) === '/';
2004	  }
2005
2006	  // At this point the path should be resolved to a full absolute path, but
2007	  // handle relative paths to be safe (might happen when process.cwd() fails)
2008
2009	  // Normalize the path
2010	  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function (p) {
2011	    return !!p;
2012	  }), !resolvedAbsolute).join('/');
2013
2014	  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
2015	};
2016
2017	// path.normalize(path)
2018	// posix version
2019	exports.normalize = function (path) {
2020	  var isAbsolute = exports.isAbsolute(path),
2021	      trailingSlash = substr(path, -1) === '/';
2022
2023	  // Normalize the path
2024	  path = normalizeArray(filter(path.split('/'), function (p) {
2025	    return !!p;
2026	  }), !isAbsolute).join('/');
2027
2028	  if (!path && !isAbsolute) {
2029	    path = '.';
2030	  }
2031	  if (path && trailingSlash) {
2032	    path += '/';
2033	  }
2034
2035	  return (isAbsolute ? '/' : '') + path;
2036	};
2037
2038	// posix version
2039	exports.isAbsolute = function (path) {
2040	  return path.charAt(0) === '/';
2041	};
2042
2043	// posix version
2044	exports.join = function () {
2045	  var paths = Array.prototype.slice.call(arguments, 0);
2046	  return exports.normalize(filter(paths, function (p, index) {
2047	    if (typeof p !== 'string') {
2048	      throw new TypeError('Arguments to path.join must be strings');
2049	    }
2050	    return p;
2051	  }).join('/'));
2052	};
2053
2054	// path.relative(from, to)
2055	// posix version
2056	exports.relative = function (from, to) {
2057	  from = exports.resolve(from).substr(1);
2058	  to = exports.resolve(to).substr(1);
2059
2060	  function trim(arr) {
2061	    var start = 0;
2062	    for (; start < arr.length; start++) {
2063	      if (arr[start] !== '') break;
2064	    }
2065
2066	    var end = arr.length - 1;
2067	    for (; end >= 0; end--) {
2068	      if (arr[end] !== '') break;
2069	    }
2070
2071	    if (start > end) return [];

2072	    return arr.slice(start, end - start + 1);
2073	  }
2074
2075	  var fromParts = trim(from.split('/'));
2076	  var toParts = trim(to.split('/'));
2077
2078	  var length = Math.min(fromParts.length, toParts.length);
2079	  var samePartsLength = length;
2080	  for (var i = 0; i < length; i++) {
2081	    if (fromParts[i] !== toParts[i]) {
2082	      samePartsLength = i;
2083	      break;
2084	    }
2085	  }
2086
2087	  var outputParts = [];
2088	  for (var i = samePartsLength; i < fromParts.length; i++) {
2089	    outputParts.push('..');
2090	  }
2091
2092	  outputParts = outputParts.concat(toParts.slice(samePartsLength));
2093
2094	  return outputParts.join('/');
2095	};
2096
2097	exports.sep = '/';
2098	exports.delimiter = ':';
2099
2100	exports.dirname = function (path) {
2101	  var result = splitPath(path),
2102	      root = result[0],
2103	      dir = result[1];
2104
2105	  if (!root && !dir) {
2106	    // No dirname whatsoever
2107	    return '.';
2108	  }
2109
2110	  if (dir) {
2111	    // It has a dirname, strip trailing slash
2112	    dir = dir.substr(0, dir.length - 1);
2113	  }
2114
2115	  return root + dir;
2116	};
2117
2118	exports.basename = function (path, ext) {
2119	  var f = splitPath(path)[2];
2120	  // TODO: make this comparison case-insensitive on windows?
2121	  if (ext && f.substr(-1 * ext.length) === ext) {
2122	    f = f.substr(0, f.length - ext.length);
2123	  }
2124	  return f;
2125	};
2126
2127	exports.extname = function (path) {
2128	  return splitPath(path)[3];
2129	};
2130
2131	function filter(xs, f) {
2132	  if (xs.filter) return xs.filter(f);
2133	  var res = [];
2134	  for (var i = 0; i < xs.length; i++) {
2135	    if (f(xs[i], i, xs)) res.push(xs[i]);
2136	  }
2137	  return res;
2138	}
2139
2140	// String.prototype.substr - negative index don't work in IE8
2141	var substr = 'ab'.substr(-1) === 'b' ? function (str, start, len) {
2142	  return str.substr(start, len);
2143	} : function (str, start, len) {
2144	  if (start < 0) start = str.length + start;
2145	  return str.substr(start, len);
2146	};
2147	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)))
2148
2149/***/ },
2150/* 18 */
2151/***/ function(module, exports, __webpack_require__) {
2152
2153	"use strict";
2154
2155	exports.__esModule = true;
2156	exports.MESSAGES = undefined;
2157
2158	var _stringify = __webpack_require__(34);
2159
2160	var _stringify2 = _interopRequireDefault(_stringify);
2161
2162	exports.get = get;
2163	exports.parseArgs = parseArgs;
2164
2165	var _util = __webpack_require__(114);
2166
2167	var util = _interopRequireWildcard(_util);
2168
2169	function _interopRequireWildcard(obj) {
2170	  if (obj && obj.__esModule) {
2171	    return obj;
2172	  } else {
2173	    var newObj = {};if (obj != null) {
2174	      for (var key in obj) {
2175	        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
2176	      }
2177	    }newObj.default = obj;return newObj;
2178	  }
2179	}
2180
2181	function _interopRequireDefault(obj) {
2182	  return obj && obj.__esModule ? obj : { default: obj };
2183	}
2184
2185	var MESSAGES = exports.MESSAGES = {
2186	  tailCallReassignmentDeopt: "Function reference has been reassigned, so it will probably be dereferenced, therefore we can't optimise this with confidence",
2187	  classesIllegalBareSuper: "Illegal use of bare super",
2188	  classesIllegalSuperCall: "Direct super call is illegal in non-constructor, use super.$1() instead",
2189	  scopeDuplicateDeclaration: "Duplicate declaration $1",
2190	  settersNoRest: "Setters aren't allowed to have a rest",
2191	  noAssignmentsInForHead: "No assignments allowed in for-in/of head",
2192	  expectedMemberExpressionOrIdentifier: "Expected type MemberExpression or Identifier",
2193	  invalidParentForThisNode: "We don't know how to handle this node within the current parent - please open an issue",
2194	  readOnly: "$1 is read-only",
2195	  unknownForHead: "Unknown node type $1 in ForStatement",
2196	  didYouMean: "Did you mean $1?",
2197	  codeGeneratorDeopt: "Note: The code generator has deoptimised the styling of $1 as it exceeds the max of $2.",
2198	  missingTemplatesDirectory: "no templates directory - this is most likely the result of a broken `npm publish`. Please report to https://github.com/babel/babel/issues",
2199	  unsupportedOutputType: "Unsupported output type $1",
2200	  illegalMethodName: "Illegal method name $1",
2201	  lostTrackNodePath: "We lost track of this node's position, likely because the AST was directly manipulated",
2202
2203	  modulesIllegalExportName: "Illegal export $1",
2204	  modulesDuplicateDeclarations: "Duplicate module declarations with the same source but in different scopes",
2205
2206	  undeclaredVariable: "Reference to undeclared variable $1",
2207	  undeclaredVariableType: "Referencing a type alias outside of a type annotation",
2208	  undeclaredVariableSuggestion: "Reference to undeclared variable $1 - did you mean $2?",
2209
2210	  traverseNeedsParent: "You must pass a scope and parentPath unless traversing a Program/File. Instead of that you tried to traverse a $1 node without passing scope and parentPath.",
2211	  traverseVerifyRootFunction: "You passed `traverse()` a function when it expected a visitor object, are you sure you didn't mean `{ enter: Function }`?",
2212	  traverseVerifyVisitorProperty: "You passed `traverse()` a visitor object with the property $1 that has the invalid property $2",
2213	  traverseVerifyNodeType: "You gave us a visitor for the node type $1 but it's not a valid type",
2214
2215	  pluginNotObject: "Plugin $2 specified in $1 was expected to return an object when invoked but returned $3",
2216	  pluginNotFunction: "Plugin $2 specified in $1 was expected to return a function but returned $3",
2217	  pluginUnknown: "Unknown plugin $1 specified in $2 at $3, attempted to resolve relative to $4",
2218	  pluginInvalidProperty: "Plugin $2 specified in $1 provided an invali

2218d property of $3"
2219	};
2220
2221	function get(key) {
2222	  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
2223	    args[_key - 1] = arguments[_key];
2224	  }
2225
2226	  var msg = MESSAGES[key];
2227	  if (!msg) throw new ReferenceError("Unknown message " + (0, _stringify2.default)(key));
2228
2229	  args = parseArgs(args);
2230
2231	  return msg.replace(/\$(\d+)/g, function (str, i) {
2232	    return args[i - 1];
2233	  });
2234	}
2235
2236	function parseArgs(args) {
2237	  return args.map(function (val) {
2238	    if (val != null && val.inspect) {
2239	      return val.inspect();
2240	    } else {
2241	      try {
2242	        return (0, _stringify2.default)(val) || val + "";
2243	      } catch (e) {
2244	        return util.inspect(val);
2245	      }
2246	    }
2247	  });
2248	}
2249
2250/***/ },
2251/* 19 */
2252/***/ function(module, exports, __webpack_require__) {
2253
2254	'use strict';
2255
2256	var isObject = __webpack_require__(22);
2257	module.exports = function (it) {
2258	  if (!isObject(it)) throw TypeError(it + ' is not an object!');
2259	  return it;
2260	};
2261
2262/***/ },
2263/* 20 */
2264/***/ function(module, exports, __webpack_require__) {
2265
2266	'use strict';
2267
2268	// Thank's IE8 for his funny defineProperty
2269	module.exports = !__webpack_require__(36)(function () {
2270	  return Object.defineProperty({}, 'a', { get: function get() {
2271	      return 7;
2272	    } }).a != 7;
2273	});
2274
2275/***/ },
2276/* 21 */
2277/***/ function(module, exports, __webpack_require__) {
2278
2279	'use strict';
2280
2281	var global = __webpack_require__(14),
2282	    core = __webpack_require__(5),
2283	    ctx = __webpack_require__(54),
2284	    hide = __webpack_require__(28),
2285	    PROTOTYPE = 'prototype';
2286
2287	var $export = function $export(type, name, source) {
2288	  var IS_FORCED = type & $export.F,
2289	      IS_GLOBAL = type & $export.G,
2290	      IS_STATIC = type & $export.S,
2291	      IS_PROTO = type & $export.P,
2292	      IS_BIND = type & $export.B,
2293	      IS_WRAP = type & $export.W,
2294	      exports = IS_GLOBAL ? core : core[name] || (core[name] = {}),
2295	      expProto = exports[PROTOTYPE],
2296	      target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE],
2297	      key,
2298	      own,
2299	      out;
2300	  if (IS_GLOBAL) source = name;
2301	  for (key in source) {
2302	    // contains in native
2303	    own = !IS_FORCED && target && target[key] !== undefined;
2304	    if (own && key in exports) continue;
2305	    // export native or passed
2306	    out = own ? target[key] : source[key];
2307	    // prevent global pollution for namespaces
2308	    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
2309	    // bind timers to global for call from export context
2310	    : IS_BIND && own ? ctx(out, global)
2311	    // wrap global constructors for prevent change them in library
2312	    : IS_WRAP && target[key] == out ? function (C) {
2313	      var F = function F(a, b, c) {
2314	        if (this instanceof C) {
2315	          switch (arguments.length) {
2316	            case 0:
2317	              return new C();
2318	            case 1:
2319	              return new C(a);
2320	            case 2:
2321	              return new C(a, b);
2322	          }return new C(a, b, c);
2323	        }return C.apply(this, arguments);
2324	      };
2325	      F[PROTOTYPE] = C[PROTOTYPE];
2326	      return F;
2327	      // make static versions for prototype methods
2328	    }(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
2329	    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
2330	    if (IS_PROTO) {
2331	      (exports.virtual || (exports.virtual = {}))[key] = out;
2332	      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
2333	      if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);
2334	    }
2335	  }
2336	};
2337	// type bitmap
2338	$export.F = 1; // forced
2339	$export.G = 2; // global
2340	$export.S = 4; // static
2341	$export.P = 8; // proto
2342	$export.B = 16; // bind
2343	$export.W = 32; // wrap
2344	$export.U = 64; // safe
2345	$export.R = 128; // real proto method for `library` 
2346	module.exports = $export;
2347
2348/***/ },
2349/* 22 */
2350/***/ function(module, exports) {
2351
2352	'use strict';
2353
2354	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; };
2355
2356	module.exports = function (it) {
2357	  return (typeof it === 'undefined' ? 'undefined' : _typeof(it)) === 'object' ? it !== null : typeof it === 'function';
2358	};
2359
2360/***/ },
2361/* 23 */
2362/***/ function(module, exports, __webpack_require__) {
2363
2364	'use strict';
2365
2366	var anObject = __webpack_require__(19),
2367	    IE8_DOM_DEFINE = __webpack_require__(227),
2368	    toPrimitive = __webpack_require__(149),
2369	    dP = Object.defineProperty;
2370
2371	exports.f = __webpack_require__(20) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
2372	  anObject(O);
2373	  P = toPrimitive(P, true);
2374	  anObject(Attributes);
2375	  if (IE8_DOM_DEFINE) try {
2376	    return dP(O, P, Attributes);
2377	  } catch (e) {/* empty */}
2378	  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
2379	  if ('value' in Attributes) O[P] = Attributes.value;
2380	  return O;
2381	};
2382
2383/***/ },
2384/* 24 */
2385/***/ function(module, exports, __webpack_require__) {
2386
2387	'use strict';
2388
2389	var isFunction = __webpack_require__(171),
2390	    isLength = __webpack_require__(172);
2391
2392	/**
2393	 * Checks if `value` is array-like. A value is considered array-like if it's
2394	 * not a function and has a `value.length` that's an integer greater than or
2395	 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
2396	 *
2397	 * @static
2398	 * @memberOf _
2399	 * @since 4.0.0
2400	 * @category Lang
2401	 * @param {*} value The value to check.
2402	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
2403	 * @example
2404	 *
2405	 * _.isArrayLike([1, 2, 3]);
2406	 * // => true
2407	 *
2408	 * _.isArrayLike(document.body.children);
2409	 * // => true
2410	 *
2411	 * _.isArrayLike('abc');
2412	 * // => true
2413	 *
2414	 * _.isArrayLike(_.noop);
2415	 * // => false
2416	 */
2417	function isArrayLike(value) {
2418	  return value != null && isLength(value.length) && !isFunction(value);
2419	}
2420
2421	module.exports = isArrayLike;
2422
2423/***/ },
2424/* 25 */

2425/***/ function(module, exports) {
2426
2427	'use strict';
2428
2429	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; };
2430
2431	/**
2432	 * Checks if `value` is object-like. A value is object-like if it's not `null`
2433	 * and has a `typeof` result of "object".
2434	 *
2435	 * @static
2436	 * @memberOf _
2437	 * @since 4.0.0
2438	 * @category Lang
2439	 * @param {*} value The value to check.
2440	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
2441	 * @example
2442	 *
2443	 * _.isObjectLike({});
2444	 * // => true
2445	 *
2446	 * _.isObjectLike([1, 2, 3]);
2447	 * // => true
2448	 *
2449	 * _.isObjectLike(_.noop);
2450	 * // => false
2451	 *
2452	 * _.isObjectLike(null);
2453	 * // => false
2454	 */
2455	function isObjectLike(value) {
2456	  return value != null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) == 'object';
2457	}
2458
2459	module.exports = isObjectLike;
2460
2461/***/ },
2462/* 26 */
2463/***/ function(module, exports, __webpack_require__) {
2464
2465	"use strict";
2466
2467	exports.__esModule = true;
2468	exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = undefined;
2469
2470	var _getIterator2 = __webpack_require__(2);
2471
2472	var _getIterator3 = _interopRequireDefault(_getIterator2);
2473
2474	var _stringify = __webpack_require__(34);
2475
2476	var _stringify2 = _interopRequireDefault(_stringify);
2477
2478	var _typeof2 = __webpack_require__(6);
2479
2480	var _typeof3 = _interopRequireDefault(_typeof2);
2481
2482	exports.assertEach = assertEach;
2483	exports.assertOneOf = assertOneOf;
2484	exports.assertNodeType = assertNodeType;
2485	exports.assertNodeOrValueType = assertNodeOrValueType;
2486	exports.assertValueType = assertValueType;
2487	exports.chain = chain;
2488	exports.default = defineType;
2489
2490	var _index = __webpack_require__(1);
2491
2492	var t = _interopRequireWildcard(_index);
2493
2494	function _interopRequireWildcard(obj) {
2495	  if (obj && obj.__esModule) {
2496	    return obj;
2497	  } else {
2498	    var newObj = {};if (obj != null) {
2499	      for (var key in obj) {
2500	        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
2501	      }
2502	    }newObj.default = obj;return newObj;
2503	  }
2504	}
2505
2506	function _interopRequireDefault(obj) {
2507	  return obj && obj.__esModule ? obj : { default: obj };
2508	}
2509
2510	var VISITOR_KEYS = exports.VISITOR_KEYS = {};
2511	var ALIAS_KEYS = exports.ALIAS_KEYS = {};
2512	var NODE_FIELDS = exports.NODE_FIELDS = {};
2513	var BUILDER_KEYS = exports.BUILDER_KEYS = {};
2514	var DEPRECATED_KEYS = exports.DEPRECATED_KEYS = {};
2515
2516	function getType(val) {
2517	  if (Array.isArray(val)) {
2518	    return "array";
2519	  } else if (val === null) {
2520	    return "null";
2521	  } else if (val === undefined) {
2522	    return "undefined";
2523	  } else {
2524	    return typeof val === "undefined" ? "undefined" : (0, _typeof3.default)(val);
2525	  }
2526	}
2527
2528	function assertEach(callback) {
2529	  function validator(node, key, val) {
2530	    if (!Array.isArray(val)) return;
2531
2532	    for (var i = 0; i < val.length; i++) {
2533	      callback(node, key + "[" + i + "]", val[i]);
2534	    }
2535	  }
2536	  validator.each = callback;
2537	  return validator;
2538	}
2539
2540	function assertOneOf() {
2541	  for (var _len = arguments.length, vals = Array(_len), _key = 0; _key < _len; _key++) {
2542	    vals[_key] = arguments[_key];
2543	  }
2544
2545	  function validate(node, key, val) {
2546	    if (vals.indexOf(val) < 0) {
2547	      throw new TypeError("Property " + key + " expected value to be one of " + (0, _stringify2.default)(vals) + " but got " + (0, _stringify2.default)(val));
2548	    }
2549	  }
2550
2551	  validate.oneOf = vals;
2552
2553	  return validate;
2554	}
2555
2556	function assertNodeType() {
2557	  for (var _len2 = arguments.length, types = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
2558	    types[_key2] = arguments[_key2];
2559	  }
2560
2561	  function validate(node, key, val) {
2562	    var valid = false;
2563
2564	    for (var _iterator = types, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
2565	      var _ref;
2566
2567	      if (_isArray) {
2568	        if (_i >= _iterator.length) break;
2569	        _ref = _iterator[_i++];
2570	      } else {
2571	        _i = _iterator.next();
2572	        if (_i.done) break;
2573	        _ref = _i.value;
2574	      }
2575
2576	      var type = _ref;

2577
2578	      if (t.is(type, val)) {
2579	        valid = true;
2580	        break;
2581	      }
2582	    }
2583
2584	    if (!valid) {
2585	      throw new TypeError("Property " + key + " of " + node.type + " expected node to be of a type " + (0, _stringify2.default)(types) + " " + ("but instead got " + (0, _stringify2.default)(val && val.type)));
2586	    }
2587	  }
2588
2589	  validate.oneOfNodeTypes = types;
2590
2591	  return validate;
2592	}
2593
2594	function assertNodeOrValueType() {
2595	  for (var _len3 = arguments.length, types = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
2596	    types[_key3] = arguments[_key3];
2597	  }
2598
2599	  function validate(node, key, val) {
2600	    var valid = false;
2601
2602	    for (var _iterator2 = types, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
2603	      var _ref2;
2604
2605	      if (_isArray2) {
2606	        if (_i2 >= _iterator2.length) break;
2607	        _ref2 = _iterator2[_i2++];
2608	      } else {
2609	        _i2 = _iterator2.next();
2610	        if (_i2.done) break;
2611	        _ref2 = _i2.value;
2612	      }
2613
2614	      var type = _ref2;
2615
2616	      if (getType(val) === type || t.is(type, val)) {
2617	        valid = true;
2618	        break;
2619	      }
2620	    }
2621
2622	    if (!valid) {
2623	      throw new TypeError("Property " + key + " of " + node.type + " expected node to be of a type " + (0, _stringify2.default)(types) + " " + ("but instead got " + (0, _stringify2.default)(val && val.type)));
2624	    }
2625	  }
2626
2627	  validate.oneOfNodeOrValueTypes = types;
2628
2629	  return validate;
2630	}
2631
2632	function assertValueType(type) {
2633	  function validate(node, key, val) {
2634	    var valid = getType(val) === type;
2635
2636	    if (!valid) {
2637	      throw new TypeError("Property " + key + " expected type of " + type + " but got " + getType(val));
2638	    }
2639	  }
2640
2641	  validate.type = type;
2642
2643	  return validate;
2644	}
2645
2646	function chain() {
2647	  for (var _len4 = arguments.length, fns = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
2648	    fns[_key4] = arguments[_key4];
2649	  }
2650
2651	  function validate() {
2652	    for (var _iterator3 = fns, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
2653	      var _ref3;
2654
2655	      if (_isArray3) {
2656	        if (_i3 >= _iterator3.length) break;
2657	        _ref3 = _iterator3[_i3++];
2658	      } else {
2659	        _i3 = _iterator3.next();
2660	        if (_i3.done) break;
2661	        _ref3 = _i3.value;
2662	      }
2663
2664	      var fn = _ref3;
2665
2666	      fn.apply(undefined, arguments);
2667	    }
2668	  }
2669	  validate.chainOf = fns;
2670	  return validate;
2671	}
2672
2673	function defineType(type) {
2674	  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2675
2676	  var inherits = opts.inherits && store[opts.inherits] || {};
2677
2678	  opts.fields = opts.fields || inherits.fields || {};
2679	  opts.visitor = opts.visitor || inherits.visitor || [];
2680	  opts.aliases = opts.aliases || inherits.aliases || [];
2681	  opts.builder = opts.builder || inherits.builder || opts.visitor || [];
2682
2683	  if (opts.deprecatedAlias) {
2684	    DEPRECATED_KEYS[opts.deprecatedAlias] = type;
2685	  }
2686
2687	  for (var _iterator4 = opts.visitor.concat(opts.builder), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : (0, _getIterator3.default)(_iterator4);;) {
2688	    var _ref4;
2689
2690	    if (_isArray4) {
2691	      if (_i4 >= _iterator4.length) break;
2692	      _ref4 = _iterator4[_i4++];
2693	    } else {
2694	      _i4 = _iterator4.next();
2695	      if (_i4.done) break;
2696	      _ref4 = _i4.value;
2697	    }
2698
2699	    var _key5 = _ref4;
2700
2701	    opts.fields[_key5] = opts.fields[_key5] || {};
2702	  }
2703
2704	  for (var key in opts.fields) {
2705	    var field = opts.fields[key];
2706
2707	    if (opts.builder.indexOf(key) === -1) {
2708	      field.optional = true;
2709	    }
2710	    if (field.default === undefined) {
2711	      field.default = null;
2712	    } else if (!field.validate) {
2713	      field.validate = assertValueType(getType(field.default));
2714	    }
2715	  }
2716
2717	  VISITOR_KEYS[type] = opts.visitor;
2718	  BUILDER_KEYS[type] = opts.builder;
2719	  NODE_FIELDS[type] = opts.fields;
2720	  ALIAS_KEYS[type] = opts.aliases;
2721
2722	  store[type] = opts;
2723	}
2724
2725	var store = {};
2726
2727/***/ },
2728/* 27 */
2729/***/ function(module, exports) {
2730
2731	"use strict";
2732
2733	var hasOwnProperty = {}.hasOwnProperty;
2734	module.exports = function (it, key) {
2735	  return hasOwnProperty.call(it, key);
2736	};
2737
2738/***/ },
2739/* 28 */
2740/***/ function(module, exports, __webpack_require__) {
2741
2742	'use strict';
2743
2744	var dP = __webpack_require__(23),
2745	    createDesc = __webpack_require__(91);
2746	module.exports = __webpack_require__(20) ? function (object, key, value) {
2747	  return dP.f(object, key, createDesc(1, value));
2748	} : function (object, key, value) {
2749	  object[key] = value;
2750	  return object;
2751	};
2752
2753/***/ },
2754/* 29 */
2755/***/ function(module, exports, __webpack_require__) {
2756
2757	'use strict';
2758
2759	var _Symbol = __webpack_require__(44),
2760	    getRawTag = __webpack_require__(523),
2761	    objectToString = __webpack_require__(548);
2762
2763	/** `Object#toString` result references. */
2764	var nullTag = '[object Null]',