Showing preview only (1,036K chars total). Download the full file or copy to clipboard to get everything.
Repository: react-map/react-magic
Branch: master
Commit: 97213deff90a
Files: 165
Total size: 983.0 KB
Directory structure:
gitextract_x65iedph/
├── .babelrc
├── .gitignore
├── .npmignore
├── LICENSE
├── README.md
├── dev/
│ ├── App.js
│ ├── index.html
│ ├── index.js
│ ├── server.js
│ └── webpack-dev-server.config.js
├── examples/
│ ├── App.js
│ ├── dist/
│ │ ├── app.js
│ │ └── index.html
│ ├── index.html
│ ├── index.js
│ ├── server.js
│ └── webpack-examples-server.config.js
├── lib/
│ ├── bling/
│ │ ├── puffIn.js
│ │ ├── puffOut.js
│ │ ├── vanishIn.js
│ │ └── vanishOut.js
│ ├── boing/
│ │ ├── boingInUp.js
│ │ └── boingOutDown.js
│ ├── bomb/
│ │ ├── bombLeftOut.js
│ │ └── bombRightOut.js
│ ├── index.js
│ ├── magic/
│ │ ├── magic.js
│ │ ├── swap.js
│ │ ├── twisterInDown.js
│ │ └── twisterInUp.js
│ ├── math/
│ │ ├── foolishIn.js
│ │ ├── foolishOut.js
│ │ ├── holeIn.js
│ │ ├── holeOut.js
│ │ ├── swashIn.js
│ │ └── swashOut.js
│ ├── perspective/
│ │ ├── perspectiveDown.js
│ │ ├── perspectiveDownReturn.js
│ │ ├── perspectiveLeft.js
│ │ ├── perspectiveLeftReturn.js
│ │ ├── perspectiveRight.js
│ │ ├── perspectiveRightReturn.js
│ │ ├── perspectiveUp.js
│ │ └── perspectiveUpReturn.js
│ ├── rotate/
│ │ ├── rotateDownIn.js
│ │ ├── rotateDownOut.js
│ │ ├── rotateLeftIn.js
│ │ ├── rotateLeftOut.js
│ │ ├── rotateRightIn.js
│ │ ├── rotateRightOut.js
│ │ ├── rotateUpIn.js
│ │ └── rotateUpOut.js
│ ├── slide/
│ │ ├── slideDown.js
│ │ ├── slideDownReturn.js
│ │ ├── slideLeft.js
│ │ ├── slideLeftReturn.js
│ │ ├── slideRight.js
│ │ ├── slideRightReturn.js
│ │ ├── slideUp.js
│ │ └── slideUpReturn.js
│ ├── space/
│ │ ├── spaceInDown.js
│ │ ├── spaceInLeft.js
│ │ ├── spaceInRight.js
│ │ ├── spaceInUp.js
│ │ ├── spaceOutDown.js
│ │ ├── spaceOutLeft.js
│ │ ├── spaceOutRight.js
│ │ └── spaceOutUp.js
│ ├── staticEffects/
│ │ ├── openDownLeft.js
│ │ ├── openDownLeftReturn.js
│ │ ├── openDownRight.js
│ │ ├── openDownRightReturn.js
│ │ ├── openUpLeft.js
│ │ ├── openUpLeftReturn.js
│ │ ├── openUpRight.js
│ │ └── openUpRightReturn.js
│ ├── staticEffectsOut/
│ │ ├── openDownLeftOut.js
│ │ ├── openDownRightOut.js
│ │ ├── openUpLeftOut.js
│ │ └── openUpRightOut.js
│ ├── tin/
│ │ ├── tinDownIn.js
│ │ ├── tinDownOut.js
│ │ ├── tinLeftIn.js
│ │ ├── tinLeftOut.js
│ │ ├── tinRightIn.js
│ │ ├── tinRightOut.js
│ │ ├── tinUpIn.js
│ │ └── tinUpOut.js
│ └── utils/
│ ├── types.js
│ └── utils.js
├── package.json
├── src/
│ ├── bling/
│ │ ├── puffIn.js
│ │ ├── puffOut.js
│ │ ├── vanishIn.js
│ │ └── vanishOut.js
│ ├── boing/
│ │ ├── boingInUp.js
│ │ └── boingOutDown.js
│ ├── bomb/
│ │ ├── bombLeftOut.js
│ │ └── bombRightOut.js
│ ├── index.js
│ ├── magic/
│ │ ├── magic.js
│ │ ├── swap.js
│ │ ├── twisterInDown.js
│ │ └── twisterInUp.js
│ ├── math/
│ │ ├── foolishIn.js
│ │ ├── foolishOut.js
│ │ ├── holeIn.js
│ │ ├── holeOut.js
│ │ ├── swashIn.js
│ │ └── swashOut.js
│ ├── perspective/
│ │ ├── perspectiveDown.js
│ │ ├── perspectiveDownReturn.js
│ │ ├── perspectiveLeft.js
│ │ ├── perspectiveLeftReturn.js
│ │ ├── perspectiveRight.js
│ │ ├── perspectiveRightReturn.js
│ │ ├── perspectiveUp.js
│ │ └── perspectiveUpReturn.js
│ ├── rotate/
│ │ ├── rotateDownIn.js
│ │ ├── rotateDownOut.js
│ │ ├── rotateLeftIn.js
│ │ ├── rotateLeftOut.js
│ │ ├── rotateRightIn.js
│ │ ├── rotateRightOut.js
│ │ ├── rotateUpIn.js
│ │ └── rotateUpOut.js
│ ├── slide/
│ │ ├── slideDown.js
│ │ ├── slideDownReturn.js
│ │ ├── slideLeft.js
│ │ ├── slideLeftReturn.js
│ │ ├── slideRight.js
│ │ ├── slideRightReturn.js
│ │ ├── slideUp.js
│ │ └── slideUpReturn.js
│ ├── space/
│ │ ├── spaceInDown.js
│ │ ├── spaceInLeft.js
│ │ ├── spaceInRight.js
│ │ ├── spaceInUp.js
│ │ ├── spaceOutDown.js
│ │ ├── spaceOutLeft.js
│ │ ├── spaceOutRight.js
│ │ └── spaceOutUp.js
│ ├── staticEffects/
│ │ ├── openDownLeft.js
│ │ ├── openDownLeftReturn.js
│ │ ├── openDownRight.js
│ │ ├── openDownRightReturn.js
│ │ ├── openUpLeft.js
│ │ ├── openUpLeftReturn.js
│ │ ├── openUpRight.js
│ │ └── openUpRightReturn.js
│ ├── staticEffectsOut/
│ │ ├── openDownLeftOut.js
│ │ ├── openDownRightOut.js
│ │ ├── openUpLeftOut.js
│ │ └── openUpRightOut.js
│ ├── tin/
│ │ ├── tinDownIn.js
│ │ ├── tinDownOut.js
│ │ ├── tinLeftIn.js
│ │ ├── tinLeftOut.js
│ │ ├── tinRightIn.js
│ │ ├── tinRightOut.js
│ │ ├── tinUpIn.js
│ │ └── tinUpOut.js
│ └── utils/
│ ├── types.js
│ └── utils.js
└── webpack-production.config.js
================================================
FILE CONTENTS
================================================
================================================
FILE: .babelrc
================================================
{
"presets": ["es2015", "react"],
"plugins": [
"transform-object-rest-spread",
"transform-export-extensions"
]
}
================================================
FILE: .gitignore
================================================
# Logs
logs
*.log
npm-debug.log*
# Runtime data
pids
*.pid
*.seed
# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov
# Coverage directory used by tools like istanbul
coverage
# nyc test coverage
.nyc_output
# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
.grunt
# node-waf configuration
.lock-wscript
# Compiled binary addons (http://nodejs.org/api/addons.html)
build/Release
# Dependency directories
node_modules
jspm_packages
# Optional npm cache directory
.npm
# Optional REPL history
.node_repl_history
================================================
FILE: .npmignore
================================================
src
__test__
examples
node_modules
dev
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2017 react-map
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# react-magic
[](https://www.npmjs.com/package/react-magic)
<a href="https://github.com/facebook/react"><img src="https://img.shields.io/badge/react-v15.4.2-blue.svg" alt="react"></a>
<a href="https://github.com/miniMAC/magic"><img src="https://img.shields.io/badge/magic-v1.2.0-blue.svg" alt="react"></a>
<a href="https://github.com/Khan/aphrodite"><img src="https://img.shields.io/badge/aphrodite-v1.1.0-blue.svg" alt="react"></a>
A collection of magic animations for react components. Although React provides a way to implement arbitrary animations,
it is not an easy task to do it, even for simple animations. That's where react-magic package comes in. It supports inline styles work with [aphrodite](https://github.com/Khan/aphrodite).
Most animations was implemented base on [magic](https://github.com/miniMAC/magic).
> How to work with [tailwindcss](https://tailwindcss.com/)? Try [tailwindcss-magic](https://github.com/Sylvenas/tailwindcss-magic).
<div style="text-align:center" align="center">
<img src="https://p1.music.126.net/T4JA1NmZlSTZZZK4EgBncA==/109951164699178486.gif" />
</div>
## Demo online
A demo is available on the Github Pages webpage for react-magic [Check out demo](https://lit-forest.github.io/react-magic/react-magic.html)!
## Installation
React-magic is distributed via [npm](https://www.npmjs.com/package/react-magic):
```
npm install --save react-magic
```
## Usage
You can import each animation directly from the main package
```js
import { swap } from "react-magic";
```
or you can import a specific animation directly
```js
import swap from "react-magic/lib/magic/swap";
```
usage with [Aphrodite](https://github.com/Khan/aphrodite)
```js
import React, { Component, PropTypes } from "react";
import { StyleSheet, css } from "aphrodite";
import { swap } from "react-magic";
const styles = StyleSheet.create({
magic: {
animationName: swap,
animationDuration: "1s",
},
});
class App extends Component {
render() {
return (
<div>
<div className={css(styles.magic)}>
<h2>react-magic</h2>
</div>
</div>
);
}
}
export default App;
```
## Animations
```
.
├── magic
│ |── magic
│ |── twisterInDown
│ |── twisterInUp
│ └── swap
├── bling
│ |── puffIn
│ |── puffOut
│ |── vanishIn
│ └── vanishOut
├── staticEffects
│ |── openDownLeft
│ |── openDownLeftReturn
│ |── openDownRight
│ |── openDownRightReturn
│ |── openUpLeft
│ |── openUpLeftReturn
│ |── openUpRight
│ └── openUpRightReturn
├── staticEffectsOut
│ |── openDownLeftOut
│ |── openDownRightOut
│ |── openUpLeftOut
│ └── openUpRightOut
├── perspective
│ |── perspectiveDown
│ |── perspectiveDownReturn
│ |── perspectiveLeft
│ |── perspectiveLeftReturn
│ |── perspectiveRight
│ |── perspectiveRightReturn
│ |── perspectiveUp
│ └── perspectiveUpReturn
├── rotate
│ |── rotateDownIn
│ |── rotateDownOut
│ |── rotateLeftIn
│ |── rotateLeftOut
│ |── rotateRightIn
│ |── rotateRightOut
│ |── rotateUpIn
│ └── rotateUpOut
├── slide
│ |── slideDown
│ |── slideDownReturn
│ |── slideLeft
│ |── slideLeftReturn
│ |── slideRight
│ |── slideRightReturn
│ |── slideUp
│ └── slideUpReturn
├── math
│ |── foolishIn
│ |── foolishOut
│ |── holeIn
│ |── holeOut
│ |── swashIn
│ └── swashOut
├── tin
│ |── tinDownIn
│ |── tinDownOut
│ |── tinLeftIn
│ |── tinLeftOut
│ |── tinRightIn
│ |── tinRightOut
│ |── tinUpIn
│ └── tinUpOut
├── bomb
│ |── bombLeftOut
│ └── bombRightOut
├── boing
│ |── boingInUp
│ └── boingOutDown
├── space
│ |── spaceInDown
│ |── spaceInLeft
│ |── spaceInRight
│ |── spaceInUp
│ |── spaceOutDown
│ |── spaceOutLeft
│ |── spaceOutRight
│ └── spaceOutUp
```
## License
MIT
================================================
FILE: dev/App.js
================================================
import React, { Component, PropTypes } from 'react';
import { StyleSheet, css } from 'aphrodite';
import spaceOutUp from '../src/space/spaceOutUp';
const root = {
placeholder: {
backgroundColor: '#f9f9f9',
width: '100px',
height: '100px',
left: '30%',
top: '30%',
position: 'absolute',
borderRadius: '3px',
},
div: {
backgroundColor: '#FF7374',
width: '100%',
height: '100%',
position: 'absolute',
borderRadius: '3px',
textAlign: 'center',
color:'#fff'
}
}
const styles = StyleSheet.create({
magic: {
animationName: spaceOutUp,
animationDuration: '1s'
}
});
class App extends Component {
constructor(props, context) {
super(props, context);
this.state = {
class: null
}
}
render() {
return (
<div style={root.placeholder}>
<div style={root.div} className={css(styles.magic)}>
<h2>React<br />Magic</h2>
</div>
</div>
);
}
}
App.propTypes = {
};
export default App;
================================================
FILE: dev/index.html
================================================
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>App</title>
</head>
<body>
<div id='root'></div>
<script src="./app.js"></script>
</body>
</html>
================================================
FILE: dev/index.js
================================================
import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
ReactDOM.render(<App />,document.getElementById('root'));
================================================
FILE: dev/server.js
================================================
const WebpackDevServer = require('webpack-dev-server');
const webpack = require('webpack');
const config = require('./webpack-dev-server.config');
const port = process.env.PORT || 3000;
var server = new WebpackDevServer(webpack(config), {
contentBase: 'dev',
stats: {
colors: true,
},
});
server.listen(port, function() {});
================================================
FILE: dev/webpack-dev-server.config.js
================================================
const webpack = require('webpack');
const path = require('path');
const buildPath = path.resolve(__dirname, 'dist');
const nodeModulesPath = path.resolve(__dirname, 'node_modules');
const config = {
entry: path.join(__dirname, '/index.js'),
output: {
path: buildPath,
filename: 'app.js',
},
devServer: {
inline: true,
port: 8080,
host:'0.0.0.0'
},
module: {
rules: [
{
test: /\.js$/,
exclude: /node_modules/,
loader: 'babel-loader'
},
{
test: /\.(png|jpg|svg)$/,
loader: 'url-loader?limit=8192&name=images/[name].[ext]'
}
]
},
}
module.exports = config;
================================================
FILE: examples/App.js
================================================
import React, { Component, PropTypes } from 'react';
import { StyleSheet, css } from 'aphrodite/no-important';
import * as animations from '../lib';
const root = {
placeholder: {
backgroundColor: '#eee',
width: '100px',
height: '100px',
left: '12%',
top: '200px',
position: 'fixed',
borderRadius: '3px',
fontFamily: '"SF Pro SC","HanHei SC","SF Pro Text","Myriad Set Pro","SF Pro Icons","PingFang SC","Helvetica Neue","Helvetica","Arial",sans-serif',
},
magicAni: {
backgroundColor: '#FF7374',
width: '100%',
height: '100%',
position: 'absolute',
borderRadius: '3px',
textAlign: 'center',
color: '#fff'
},
cssOptions: {
width: '50%',
left: '35%',
position: 'absolute',
fontFamily: '"SF Pro SC","HanHei SC","SF Pro Text","Myriad Set Pro","SF Pro Icons","PingFang SC","Helvetica Neue","Helvetica","Arial",sans-serif',
color: '#52616A',
// userSelect: 'none'
},
title: {
position: 'relative',
left: '10%'
},
chunk: {
padding: '1em 0 0 0',
left: '10%',
clear: 'both'
},
h2: {
// marginTop: '110px',
marginBottom: '5px',
fontWeight: 400
}
}
const styles = StyleSheet.create({
btnDefault: {
fontSize: 16,
display: 'block',
float: 'left',
margin: '10px 10px 10px 0',
padding: '12px 18px',
background: '#fff',
border: '2px solid #C9D6DE',
color: '#52616A',
borderRadius: '4px',
cursor: 'pointer'
},
btnHover: {
':hover': {
background: '#52616A',
color: '#fff',
}
}
});
const PVaule = [
[
'magic', 'twisterInDown', 'twisterInUp', 'swap'
], [
'puffIn', 'puffOut', 'vanishIn', 'vanishOut'
], [
'openDownLeft', 'openDownLeftReturn', 'openDownRight', 'openDownRightReturn', 'openUpLeft', 'openUpLeftReturn', 'openUpRight', 'openUpRightReturn'
], [
'openDownLeftOut', 'openDownRightOut', 'openUpLeftOut', 'openUpRightOut'
], [
'perspectiveDown', 'perspectiveDownReturn', 'perspectiveLeft', 'perspectiveLeftReturn', 'perspectiveRight', 'perspectiveRightReturn', 'perspectiveUp', 'perspectiveUpReturn'
],[
'rotateDownIn','rotateDownOut','rotateLeftIn','rotateLeftOut','rotateRightIn','rotateRightOut','rotateUpIn','rotateUpOut'
],[
'slideDown','slideDownReturn','slideLeft','slideLeftReturn','slideRight','slideRightReturn','slideUp','slideUpReturn'
],[
'foolishIn','foolishOut','holeIn','holeOut','swashIn','swashOut'
],[
'tinDownIn','tinDownOut','tinLeftIn','tinLeftOut','tinRightIn','tinRightOut','tinUpIn','tinUpOut'
],[
'bombLeftOut','bombRightOut'
],[
'boingInUp','boingOutDown'
],[
'spaceInDown','spaceInLeft','spaceInRight','spaceInUp','spaceOutDown','spaceOutLeft','spaceOutRight','spaceOutUp'
]
]
class App extends Component {
constructor(props, context) {
super(props, context);
this.state = {
isPlaying: false,
magicClass: null
}
this.handleBtnClick = this.handleBtnClick.bind(this);
}
handleBtnClick(e) {
if (this.state.isPlaying) {
return;
}
var cssName = e.target.innerText;
var ani = StyleSheet.create({
magic: {
animationName: animations[cssName],
animationDuration: '1s'
}
});
this.setState({
isPlaying: true,
magicClass: ani.magic
})
setTimeout(() => {
this.setState({
isPlaying: false,
magicClass: null
})
}, 1000);
}
render() {
return (
<div>
<div style={root.placeholder}>
<div style={root.magicAni} className={css(this.state.magicClass)}>
<h2>React<br />Magic</h2>
</div>
</div>
<div style={root.cssOptions}>
<h1 style={root.title}>React-Magic</h1>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Effects</h2>
{PVaule[0].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Bling</h2>
{PVaule[1].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Static Effects</h2>
{PVaule[2].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Static Effects Out</h2>
{PVaule[3].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Perspective</h2>
{PVaule[4].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Rotate</h2>
{PVaule[5].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Slide</h2>
{PVaule[6].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Math</h2>
{PVaule[7].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Tin</h2>
{PVaule[8].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Bomb</h2>
{PVaule[9].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Boing</h2>
{PVaule[10].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
<div style={root.chunk}>
<h2 style={root.h2}>React-Magic Space</h2>
{PVaule[11].map((name) => {
return <p key={name} className={css(styles.btnDefault, styles.btnHover)} onClick={this.handleBtnClick}>{name}</p>
})}
</div>
</div>
</div>
);
}
}
export default App;
================================================
FILE: examples/dist/app.js
================================================
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // identity function for calling harmony imports with the correct context
/******/ __webpack_require__.i = function(value) { return value; };
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 97);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {
// shim for using process in browser
var process = module.exports = {};
// cached from whatever global is present so that test runners that stub it
// don't break things. But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals. It's inside a
// function because try/catches deoptimize in certain engines.
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
} else {
cachedSetTimeout = defaultSetTimout;
}
} catch (e) {
cachedSetTimeout = defaultSetTimout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
} else {
cachedClearTimeout = defaultClearTimeout;
}
} catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
} ())
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch(e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout.call(null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) { return [] }
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _toConsumableArray(arr) {
if (Array.isArray(arr)) {
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
arr2[i] = arr[i];
}return arr2;
} else {
return Array.from(arr);
}
}
/**
* Composes a variable number of CSS helper functions.
* Returns a function that accepts all the original arguments
* of the functions it composed. If the original function
* accepted multiple arguments, they must be passed as
* an array.
* @example
* const translateXandRotateY = compose(translateX, rotateY);
* const cssValue = translateXandRotateY('-5px', '30deg');
*/
var compose = exports.compose = function compose() {
for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
funcs[_key] = arguments[_key];
}
return function () {
for (var _len2 = arguments.length, styleArgs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
styleArgs[_key2] = arguments[_key2];
}
var result = funcs.reduce(function (acc, func, i) {
var arg = styleArgs[i];
return acc + ' ' + (Array.isArray(arg) ? func.apply(undefined, _toConsumableArray(arg)) : func(arg));
}, '');
return result.trim();
};
};
var cubicBezier = exports.cubicBezier = function cubicBezier(a, b, c, d) {
return 'cubic-bezier(' + a + ', ' + b + ', ' + c + ', ' + d + ')';
};
var translate3d = exports.translate3d = function translate3d(a, b, c) {
return 'translate3d(' + a + ', ' + b + ', ' + c + ')';
};
var translateX = exports.translateX = function translateX(a) {
return 'translateX(' + a + ')';
};
var scale3d = exports.scale3d = function scale3d(a, b, c) {
return 'scale3d(' + a + ', ' + b + ', ' + c + ')';
};
var scale = exports.scale = function scale(a) {
return 'scale(' + a + ')';
};
var skewX = exports.skewX = function skewX(deg) {
return 'skewX(' + deg + 'deg)';
};
var skewY = exports.skewY = function skewY(deg) {
return 'skewY(' + deg + 'deg)';
};
var skewXY = exports.skewXY = function skewXY(x, y) {
return skewX(x) + ' ' + skewY(y);
};
var rotateY = exports.rotateY = function rotateY(a) {
return 'rotateY(' + a + 'deg)';
};
var rotate3d = exports.rotate3d = function rotate3d(a, b, c, d) {
return 'rotate3d(' + a + ', ' + b + ', ' + c + ', ' + d + 'deg)';
};
var perspective = exports.perspective = function perspective(a) {
return 'perspective(' + a + ')';
};
var translateY = exports.translateY = function translateY(a) {
return 'translateY(' + a + ')';
};
var translateZ = exports.translateZ = function translateZ(a) {
return 'translateZ(' + a + ')';
};
var translateXY = exports.translateXY = function translateXY(a, b) {
return 'translate(' + a + ',' + b + ')';
};
var rotate = exports.rotate = function rotate(a) {
return 'rotate(' + a + 'deg)';
};
var rotateX = exports.rotateX = function rotateX(a) {
return 'rotateX(' + a + 'deg)';
};
var blur = exports.blur = function blur(a) {
return 'blur(' + a + ')';
};
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
/**
* Use invariant() to assert state which your program assumes to be true.
*
* Provide sprintf-style format (only %s is supported) and arguments
* to provide information about what broke and what you were
* expecting.
*
* The invariant message will be stripped in production, but the invariant
* will remain to ensure logic does not differ in production.
*/
var validateFormat = function validateFormat(format) {};
if (process.env.NODE_ENV !== 'production') {
validateFormat = function validateFormat(format) {
if (format === undefined) {
throw new Error('invariant requires an error message argument');
}
};
}
function invariant(condition, format, a, b, c, d, e, f) {
validateFormat(format);
if (!condition) {
var error;
if (format === undefined) {
error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
} else {
var args = [a, b, c, d, e, f];
var argIndex = 0;
error = new Error(format.replace(/%s/g, function () {
return args[argIndex++];
}));
error.name = 'Invariant Violation';
}
error.framesToPop = 1; // we don't care about invariant's own frame
throw error;
}
}
module.exports = invariant;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var emptyFunction = __webpack_require__(10);
/**
* Similar to invariant but only logs a warning if the condition is not met.
* This can be used to log issues in development environments in critical
* paths. Removing the logging code for production environments will keep the
* same logic and follow the same code paths.
*/
var warning = emptyFunction;
if (process.env.NODE_ENV !== 'production') {
var printWarning = function printWarning(format) {
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
var argIndex = 0;
var message = 'Warning: ' + format.replace(/%s/g, function () {
return args[argIndex++];
});
if (typeof console !== 'undefined') {
console.error(message);
}
try {
// --- Welcome to debugging React ---
// This error was thrown as a convenience so that you can use this stack
// to find the callsite that caused this warning to fire.
throw new Error(message);
} catch (x) {}
};
warning = function warning(condition, format) {
if (format === undefined) {
throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
}
if (format.indexOf('Failed Composite propType: ') === 0) {
return; // Ignore CompositeComponent proptype check.
}
if (!condition) {
for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
args[_key2 - 2] = arguments[_key2];
}
printWarning.apply(undefined, [format].concat(args));
}
};
}
module.exports = warning;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
/**
* WARNING: DO NOT manually require this module.
* This is a replacement for `invariant(...)` used by the error code system
* and will _only_ be required by the corresponding babel pass.
* It always throws.
*/
function reactProdInvariant(code) {
var argCount = arguments.length - 1;
var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
for (var argIdx = 0; argIdx < argCount; argIdx++) {
message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
}
message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
var error = new Error(message);
error.name = 'Invariant Violation';
error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
throw error;
}
module.exports = reactProdInvariant;
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === undefined) {
throw new TypeError('Object.assign cannot be called with null or undefined');
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
// Detect buggy property enumeration order in older V8 versions.
// https://bugs.chromium.org/p/v8/issues/detail?id=4118
var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
test1[5] = 'de';
if (Object.getOwnPropertyNames(test1)[0] === '5') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test2 = {};
for (var i = 0; i < 10; i++) {
test2['_' + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
return test2[n];
});
if (order2.join('') !== '0123456789') {
return false;
}
// https://bugs.chromium.org/p/v8/issues/detail?id=3056
var test3 = {};
'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join('') !==
'abcdefghijklmnopqrst') {
return false;
}
return true;
} catch (err) {
// We don't expect any of the above to throw, but better to be safe.
return false;
}
}
module.exports = shouldUseNative() ? Object.assign : function (target, source) {
var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s]);
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _prodInvariant = __webpack_require__(4);
var DOMProperty = __webpack_require__(14);
var ReactDOMComponentFlags = __webpack_require__(64);
var invariant = __webpack_require__(2);
var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
var Flags = ReactDOMComponentFlags;
var internalInstanceKey = '__reactInternalInstance$' + Math.random().toString(36).slice(2);
/**
* Check if a given node should be cached.
*/
function shouldPrecacheNode(node, nodeID) {
return node.nodeType === 1 && node.getAttribute(ATTR_NAME) === String(nodeID) || node.nodeType === 8 && node.nodeValue === ' react-text: ' + nodeID + ' ' || node.nodeType === 8 && node.nodeValue === ' react-empty: ' + nodeID + ' ';
}
/**
* Drill down (through composites and empty components) until we get a host or
* host text component.
*
* This is pretty polymorphic but unavoidable with the current structure we have
* for `_renderedChildren`.
*/
function getRenderedHostOrTextFromComponent(component) {
var rendered;
while (rendered = component._renderedComponent) {
component = rendered;
}
return component;
}
/**
* Populate `_hostNode` on the rendered host/text component with the given
* DOM node. The passed `inst` can be a composite.
*/
function precacheNode(inst, node) {
var hostInst = getRenderedHostOrTextFromComponent(inst);
hostInst._hostNode = node;
node[internalInstanceKey] = hostInst;
}
function uncacheNode(inst) {
var node = inst._hostNode;
if (node) {
delete node[internalInstanceKey];
inst._hostNode = null;
}
}
/**
* Populate `_hostNode` on each child of `inst`, assuming that the children
* match up with the DOM (element) children of `node`.
*
* We cache entire levels at once to avoid an n^2 problem where we access the
* children of a node sequentially and have to walk from the start to our target
* node every time.
*
* Since we update `_renderedChildren` and the actual DOM at (slightly)
* different times, we could race here and see a newer `_renderedChildren` than
* the DOM nodes we see. To avoid this, ReactMultiChild calls
* `prepareToManageChildren` before we change `_renderedChildren`, at which
* time the container's child nodes are always cached (until it unmounts).
*/
function precacheChildNodes(inst, node) {
if (inst._flags & Flags.hasCachedChildNodes) {
return;
}
var children = inst._renderedChildren;
var childNode = node.firstChild;
outer: for (var name in children) {
if (!children.hasOwnProperty(name)) {
continue;
}
var childInst = children[name];
var childID = getRenderedHostOrTextFromComponent(childInst)._domID;
if (childID === 0) {
// We're currently unmounting this child in ReactMultiChild; skip it.
continue;
}
// We assume the child nodes are in the same order as the child instances.
for (; childNode !== null; childNode = childNode.nextSibling) {
if (shouldPrecacheNode(childNode, childID)) {
precacheNode(childInst, childNode);
continue outer;
}
}
// We reached the end of the DOM children without finding an ID match.
true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unable to find element with ID %s.', childID) : _prodInvariant('32', childID) : void 0;
}
inst._flags |= Flags.hasCachedChildNodes;
}
/**
* Given a DOM node, return the closest ReactDOMComponent or
* ReactDOMTextComponent instance ancestor.
*/
function getClosestInstanceFromNode(node) {
if (node[internalInstanceKey]) {
return node[internalInstanceKey];
}
// Walk up the tree until we find an ancestor whose instance we have cached.
var parents = [];
while (!node[internalInstanceKey]) {
parents.push(node);
if (node.parentNode) {
node = node.parentNode;
} else {
// Top of the tree. This node must not be part of a React tree (or is
// unmounted, potentially).
return null;
}
}
var closest;
var inst;
for (; node && (inst = node[internalInstanceKey]); node = parents.pop()) {
closest = inst;
if (parents.length) {
precacheChildNodes(inst, node);
}
}
return closest;
}
/**
* Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
* instance, or null if the node was not rendered by this React.
*/
function getInstanceFromNode(node) {
var inst = getClosestInstanceFromNode(node);
if (inst != null && inst._hostNode === node) {
return inst;
} else {
return null;
}
}
/**
* Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
* DOM node.
*/
function getNodeFromInstance(inst) {
// Without this first invariant, passing a non-DOM-component triggers the next
// invariant for a missing parent, which is super confusing.
!(inst._hostNode !== undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
if (inst._hostNode) {
return inst._hostNode;
}
// Walk up the tree until we find an ancestor whose DOM node we have cached.
var parents = [];
while (!inst._hostNode) {
parents.push(inst);
!inst._hostParent ? process.env.NODE_ENV !== 'production' ? invariant(false, 'React DOM tree root should always have a node reference.') : _prodInvariant('34') : void 0;
inst = inst._hostParent;
}
// Now parents contains each ancestor that does *not* have a cached native
// node, and `inst` is the deepest ancestor that does.
for (; parents.length; inst = parents.pop()) {
precacheChildNodes(inst, inst._hostNode);
}
return inst._hostNode;
}
var ReactDOMComponentTree = {
getClosestInstanceFromNode: getClosestInstanceFromNode,
getInstanceFromNode: getInstanceFromNode,
getNodeFromInstance: getNodeFromInstance,
precacheChildNodes: precacheChildNodes,
precacheNode: precacheNode,
uncacheNode: uncacheNode
};
module.exports = ReactDOMComponentTree;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
/**
* Simple, lightweight module assisting with the detection and context of
* Worker. Helps avoid circular dependencies and allows code to reason about
* whether or not they are in a Worker, even if they never include the main
* `ReactWorker` dependency.
*/
var ExecutionEnvironment = {
canUseDOM: canUseDOM,
canUseWorkers: typeof Worker !== 'undefined',
canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
canUseViewport: canUseDOM && !!window.screen,
isInWorker: !canUseDOM // For now, this is true - might change in the future.
};
module.exports = ExecutionEnvironment;
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2016-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
var _prodInvariant = __webpack_require__(21);
var ReactCurrentOwner = __webpack_require__(12);
var invariant = __webpack_require__(2);
var warning = __webpack_require__(3);
function isNative(fn) {
// Based on isNative() from Lodash
var funcToString = Function.prototype.toString;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var reIsNative = RegExp('^' + funcToString
// Take an example native function source for comparison
.call(hasOwnProperty
// Strip regex characters so we can use it for regex
).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&'
// Remove hasOwnProperty from the template to make it generic
).replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
try {
var source = funcToString.call(fn);
return reIsNative.test(source);
} catch (err) {
return false;
}
}
var canUseCollections =
// Array.from
typeof Array.from === 'function' &&
// Map
typeof Map === 'function' && isNative(Map) &&
// Map.prototype.keys
Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&
// Set
typeof Set === 'function' && isNative(Set) &&
// Set.prototype.keys
Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);
var setItem;
var getItem;
var removeItem;
var getItemIDs;
var addRoot;
var removeRoot;
var getRootIDs;
if (canUseCollections) {
var itemMap = new Map();
var rootIDSet = new Set();
setItem = function (id, item) {
itemMap.set(id, item);
};
getItem = function (id) {
return itemMap.get(id);
};
removeItem = function (id) {
itemMap['delete'](id);
};
getItemIDs = function () {
return Array.from(itemMap.keys());
};
addRoot = function (id) {
rootIDSet.add(id);
};
removeRoot = function (id) {
rootIDSet['delete'](id);
};
getRootIDs = function () {
return Array.from(rootIDSet.keys());
};
} else {
var itemByKey = {};
var rootByKey = {};
// Use non-numeric keys to prevent V8 performance issues:
// https://github.com/facebook/react/pull/7232
var getKeyFromID = function (id) {
return '.' + id;
};
var getIDFromKey = function (key) {
return parseInt(key.substr(1), 10);
};
setItem = function (id, item) {
var key = getKeyFromID(id);
itemByKey[key] = item;
};
getItem = function (id) {
var key = getKeyFromID(id);
return itemByKey[key];
};
removeItem = function (id) {
var key = getKeyFromID(id);
delete itemByKey[key];
};
getItemIDs = function () {
return Object.keys(itemByKey).map(getIDFromKey);
};
addRoot = function (id) {
var key = getKeyFromID(id);
rootByKey[key] = true;
};
removeRoot = function (id) {
var key = getKeyFromID(id);
delete rootByKey[key];
};
getRootIDs = function () {
return Object.keys(rootByKey).map(getIDFromKey);
};
}
var unmountedIDs = [];
function purgeDeep(id) {
var item = getItem(id);
if (item) {
var childIDs = item.childIDs;
removeItem(id);
childIDs.forEach(purgeDeep);
}
}
function describeComponentFrame(name, source, ownerName) {
return '\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
}
function getDisplayName(element) {
if (element == null) {
return '#empty';
} else if (typeof element === 'string' || typeof element === 'number') {
return '#text';
} else if (typeof element.type === 'string') {
return element.type;
} else {
return element.type.displayName || element.type.name || 'Unknown';
}
}
function describeID(id) {
var name = ReactComponentTreeHook.getDisplayName(id);
var element = ReactComponentTreeHook.getElement(id);
var ownerID = ReactComponentTreeHook.getOwnerID(id);
var ownerName;
if (ownerID) {
ownerName = ReactComponentTreeHook.getDisplayName(ownerID);
}
process.env.NODE_ENV !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;
return describeComponentFrame(name, element && element._source, ownerName);
}
var ReactComponentTreeHook = {
onSetChildren: function (id, nextChildIDs) {
var item = getItem(id);
!item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
item.childIDs = nextChildIDs;
for (var i = 0; i < nextChildIDs.length; i++) {
var nextChildID = nextChildIDs[i];
var nextChild = getItem(nextChildID);
!nextChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;
!(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;
!nextChild.isMounted ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;
if (nextChild.parentID == null) {
nextChild.parentID = id;
// TODO: This shouldn't be necessary but mounting a new root during in
// componentWillMount currently causes not-yet-mounted components to
// be purged from our tree data so their parent id is missing.
}
!(nextChild.parentID === id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;
}
},
onBeforeMountComponent: function (id, element, parentID) {
var item = {
element: element,
parentID: parentID,
text: null,
childIDs: [],
isMounted: false,
updateCount: 0
};
setItem(id, item);
},
onBeforeUpdateComponent: function (id, element) {
var item = getItem(id);
if (!item || !item.isMounted) {
// We may end up here as a result of setState() in componentWillUnmount().
// In this case, ignore the element.
return;
}
item.element = element;
},
onMountComponent: function (id) {
var item = getItem(id);
!item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
item.isMounted = true;
var isRoot = item.parentID === 0;
if (isRoot) {
addRoot(id);
}
},
onUpdateComponent: function (id) {
var item = getItem(id);
if (!item || !item.isMounted) {
// We may end up here as a result of setState() in componentWillUnmount().
// In this case, ignore the element.
return;
}
item.updateCount++;
},
onUnmountComponent: function (id) {
var item = getItem(id);
if (item) {
// We need to check if it exists.
// `item` might not exist if it is inside an error boundary, and a sibling
// error boundary child threw while mounting. Then this instance never
// got a chance to mount, but it still gets an unmounting event during
// the error boundary cleanup.
item.isMounted = false;
var isRoot = item.parentID === 0;
if (isRoot) {
removeRoot(id);
}
}
unmountedIDs.push(id);
},
purgeUnmountedComponents: function () {
if (ReactComponentTreeHook._preventPurging) {
// Should only be used for testing.
return;
}
for (var i = 0; i < unmountedIDs.length; i++) {
var id = unmountedIDs[i];
purgeDeep(id);
}
unmountedIDs.length = 0;
},
isMounted: function (id) {
var item = getItem(id);
return item ? item.isMounted : false;
},
getCurrentStackAddendum: function (topElement) {
var info = '';
if (topElement) {
var name = getDisplayName(topElement);
var owner = topElement._owner;
info += describeComponentFrame(name, topElement._source, owner && owner.getName());
}
var currentOwner = ReactCurrentOwner.current;
var id = currentOwner && currentOwner._debugID;
info += ReactComponentTreeHook.getStackAddendumByID(id);
return info;
},
getStackAddendumByID: function (id) {
var info = '';
while (id) {
info += describeID(id);
id = ReactComponentTreeHook.getParentID(id);
}
return info;
},
getChildIDs: function (id) {
var item = getItem(id);
return item ? item.childIDs : [];
},
getDisplayName: function (id) {
var element = ReactComponentTreeHook.getElement(id);
if (!element) {
return null;
}
return getDisplayName(element);
},
getElement: function (id) {
var item = getItem(id);
return item ? item.element : null;
},
getOwnerID: function (id) {
var element = ReactComponentTreeHook.getElement(id);
if (!element || !element._owner) {
return null;
}
return element._owner._debugID;
},
getParentID: function (id) {
var item = getItem(id);
return item ? item.parentID : null;
},
getSource: function (id) {
var item = getItem(id);
var element = item ? item.element : null;
var source = element != null ? element._source : null;
return source;
},
getText: function (id) {
var element = ReactComponentTreeHook.getElement(id);
if (typeof element === 'string') {
return element;
} else if (typeof element === 'number') {
return '' + element;
} else {
return null;
}
},
getUpdateCount: function (id) {
var item = getItem(id);
return item ? item.updateCount : 0;
},
getRootIDs: getRootIDs,
getRegisteredIDs: getItemIDs,
pushNonStandardWarningStack: function (isCreatingElement, currentSource) {
if (typeof console.reactStack !== 'function') {
return;
}
var stack = [];
var currentOwner = ReactCurrentOwner.current;
var id = currentOwner && currentOwner._debugID;
try {
if (isCreatingElement) {
stack.push({
name: id ? ReactComponentTreeHook.getDisplayName(id) : null,
fileName: currentSource ? currentSource.fileName : null,
lineNumber: currentSource ? currentSource.lineNumber : null
});
}
while (id) {
var element = ReactComponentTreeHook.getElement(id);
var parentID = ReactComponentTreeHook.getParentID(id);
var ownerID = ReactComponentTreeHook.getOwnerID(id);
var ownerName = ownerID ? ReactComponentTreeHook.getDisplayName(ownerID) : null;
var source = element && element._source;
stack.push({
name: ownerName,
fileName: source ? source.fileName : null,
lineNumber: source ? source.lineNumber : null
});
id = parentID;
}
} catch (err) {
// Internal state is messed up.
// Stop building the stack (it's just a nice to have).
}
console.reactStack(stack);
},
popNonStandardWarningStack: function () {
if (typeof console.reactStackEnd !== 'function') {
return;
}
console.reactStackEnd();
}
};
module.exports = ReactComponentTreeHook;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2016-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
// Trust the developer to only use ReactInstrumentation with a __DEV__ check
var debugTool = null;
if (process.env.NODE_ENV !== 'production') {
var ReactDebugTool = __webpack_require__(233);
debugTool = ReactDebugTool;
}
module.exports = { debugTool: debugTool };
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
function makeEmptyFunction(arg) {
return function () {
return arg;
};
}
/**
* This function accepts and discards inputs; it has no side effects. This is
* primarily useful idiomatically for overridable function endpoints which
* always need to be callable, since JS lacks a null-call idiom ala Cocoa.
*/
var emptyFunction = function emptyFunction() {};
emptyFunction.thatReturns = makeEmptyFunction;
emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
emptyFunction.thatReturnsNull = makeEmptyFunction(null);
emptyFunction.thatReturnsThis = function () {
return this;
};
emptyFunction.thatReturnsArgument = function (arg) {
return arg;
};
module.exports = emptyFunction;
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _prodInvariant = __webpack_require__(4),
_assign = __webpack_require__(5);
var CallbackQueue = __webpack_require__(62);
var PooledClass = __webpack_require__(15);
var ReactFeatureFlags = __webpack_require__(67);
var ReactReconciler = __webpack_require__(19);
var Transaction = __webpack_require__(30);
var invariant = __webpack_require__(2);
var dirtyComponents = [];
var updateBatchNumber = 0;
var asapCallbackQueue = CallbackQueue.getPooled();
var asapEnqueued = false;
var batchingStrategy = null;
function ensureInjected() {
!(ReactUpdates.ReactReconcileTransaction && batchingStrategy) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must inject a reconcile transaction class and batching strategy') : _prodInvariant('123') : void 0;
}
var NESTED_UPDATES = {
initialize: function () {
this.dirtyComponentsLength = dirtyComponents.length;
},
close: function () {
if (this.dirtyComponentsLength !== dirtyComponents.length) {
// Additional updates were enqueued by componentDidUpdate handlers or
// similar; before our own UPDATE_QUEUEING wrapper closes, we want to run
// these new updates so that if A's componentDidUpdate calls setState on
// B, B will update before the callback A's updater provided when calling
// setState.
dirtyComponents.splice(0, this.dirtyComponentsLength);
flushBatchedUpdates();
} else {
dirtyComponents.length = 0;
}
}
};
var UPDATE_QUEUEING = {
initialize: function () {
this.callbackQueue.reset();
},
close: function () {
this.callbackQueue.notifyAll();
}
};
var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];
function ReactUpdatesFlushTransaction() {
this.reinitializeTransaction();
this.dirtyComponentsLength = null;
this.callbackQueue = CallbackQueue.getPooled();
this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(
/* useCreateElement */true);
}
_assign(ReactUpdatesFlushTransaction.prototype, Transaction, {
getTransactionWrappers: function () {
return TRANSACTION_WRAPPERS;
},
destructor: function () {
this.dirtyComponentsLength = null;
CallbackQueue.release(this.callbackQueue);
this.callbackQueue = null;
ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);
this.reconcileTransaction = null;
},
perform: function (method, scope, a) {
// Essentially calls `this.reconcileTransaction.perform(method, scope, a)`
// with this transaction's wrappers around it.
return Transaction.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
}
});
PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);
function batchedUpdates(callback, a, b, c, d, e) {
ensureInjected();
return batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
}
/**
* Array comparator for ReactComponents by mount ordering.
*
* @param {ReactComponent} c1 first component you're comparing
* @param {ReactComponent} c2 second component you're comparing
* @return {number} Return value usable by Array.prototype.sort().
*/
function mountOrderComparator(c1, c2) {
return c1._mountOrder - c2._mountOrder;
}
function runBatchedUpdates(transaction) {
var len = transaction.dirtyComponentsLength;
!(len === dirtyComponents.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected flush transaction\'s stored dirty-components length (%s) to match dirty-components array length (%s).', len, dirtyComponents.length) : _prodInvariant('124', len, dirtyComponents.length) : void 0;
// Since reconciling a component higher in the owner hierarchy usually (not
// always -- see shouldComponentUpdate()) will reconcile children, reconcile
// them before their children by sorting the array.
dirtyComponents.sort(mountOrderComparator);
// Any updates enqueued while reconciling must be performed after this entire
// batch. Otherwise, if dirtyComponents is [A, B] where A has children B and
// C, B could update twice in a single batch if C's render enqueues an update
// to B (since B would have already updated, we should skip it, and the only
// way we can know to do so is by checking the batch counter).
updateBatchNumber++;
for (var i = 0; i < len; i++) {
// If a component is unmounted before pending changes apply, it will still
// be here, but we assume that it has cleared its _pendingCallbacks and
// that performUpdateIfNecessary is a noop.
var component = dirtyComponents[i];
// If performUpdateIfNecessary happens to enqueue any new updates, we
// shouldn't execute the callbacks until the next render happens, so
// stash the callbacks first
var callbacks = component._pendingCallbacks;
component._pendingCallbacks = null;
var markerName;
if (ReactFeatureFlags.logTopLevelRenders) {
var namedComponent = component;
// Duck type TopLevelWrapper. This is probably always true.
if (component._currentElement.type.isReactTopLevelWrapper) {
namedComponent = component._renderedComponent;
}
markerName = 'React update: ' + namedComponent.getName();
console.time(markerName);
}
ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber);
if (markerName) {
console.timeEnd(markerName);
}
if (callbacks) {
for (var j = 0; j < callbacks.length; j++) {
transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance());
}
}
}
}
var flushBatchedUpdates = function () {
// ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents
// array and perform any updates enqueued by mount-ready handlers (i.e.,
// componentDidUpdate) but we need to check here too in order to catch
// updates enqueued by setState callbacks and asap calls.
while (dirtyComponents.length || asapEnqueued) {
if (dirtyComponents.length) {
var transaction = ReactUpdatesFlushTransaction.getPooled();
transaction.perform(runBatchedUpdates, null, transaction);
ReactUpdatesFlushTransaction.release(transaction);
}
if (asapEnqueued) {
asapEnqueued = false;
var queue = asapCallbackQueue;
asapCallbackQueue = CallbackQueue.getPooled();
queue.notifyAll();
CallbackQueue.release(queue);
}
}
};
/**
* Mark a component as needing a rerender, adding an optional callback to a
* list of functions which will be executed once the rerender occurs.
*/
function enqueueUpdate(component) {
ensureInjected();
// Various parts of our code (such as ReactCompositeComponent's
// _renderValidatedComponent) assume that calls to render aren't nested;
// verify that that's the case. (This is called by each top-level update
// function, like setState, forceUpdate, etc.; creation and
// destruction of top-level components is guarded in ReactMount.)
if (!batchingStrategy.isBatchingUpdates) {
batchingStrategy.batchedUpdates(enqueueUpdate, component);
return;
}
dirtyComponents.push(component);
if (component._updateBatchNumber == null) {
component._updateBatchNumber = updateBatchNumber + 1;
}
}
/**
* Enqueue a callback to be run at the end of the current batching cycle. Throws
* if no updates are currently being performed.
*/
function asap(callback, context) {
invariant(batchingStrategy.isBatchingUpdates, "ReactUpdates.asap: Can't enqueue an asap callback in a context where" + 'updates are not being batched.');
asapCallbackQueue.enqueue(callback, context);
asapEnqueued = true;
}
var ReactUpdatesInjection = {
injectReconcileTransaction: function (ReconcileTransaction) {
!ReconcileTransaction ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a reconcile transaction class') : _prodInvariant('126') : void 0;
ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
},
injectBatchingStrategy: function (_batchingStrategy) {
!_batchingStrategy ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batching strategy') : _prodInvariant('127') : void 0;
!(typeof _batchingStrategy.batchedUpdates === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batchedUpdates() function') : _prodInvariant('128') : void 0;
!(typeof _batchingStrategy.isBatchingUpdates === 'boolean') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : _prodInvariant('129') : void 0;
batchingStrategy = _batchingStrategy;
}
};
var ReactUpdates = {
/**
* React references `ReactReconcileTransaction` using this property in order
* to allow dependency injection.
*
* @internal
*/
ReactReconcileTransaction: null,
batchedUpdates: batchedUpdates,
enqueueUpdate: enqueueUpdate,
flushBatchedUpdates: flushBatchedUpdates,
injection: ReactUpdatesInjection,
asap: asap
};
module.exports = ReactUpdates;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
/**
* Keeps track of the current owner.
*
* The current owner is the component who should own any components that are
* currently being constructed.
*/
var ReactCurrentOwner = {
/**
* @internal
* @type {ReactComponent}
*/
current: null
};
module.exports = ReactCurrentOwner;
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _assign = __webpack_require__(5);
var PooledClass = __webpack_require__(15);
var emptyFunction = __webpack_require__(10);
var warning = __webpack_require__(3);
var didWarnForAddedNewProperty = false;
var isProxySupported = typeof Proxy === 'function';
var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances'];
/**
* @interface Event
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var EventInterface = {
type: null,
target: null,
// currentTarget is set when dispatching; no use in copying it here
currentTarget: emptyFunction.thatReturnsNull,
eventPhase: null,
bubbles: null,
cancelable: null,
timeStamp: function (event) {
return event.timeStamp || Date.now();
},
defaultPrevented: null,
isTrusted: null
};
/**
* Synthetic events are dispatched by event plugins, typically in response to a
* top-level event delegation handler.
*
* These systems should generally use pooling to reduce the frequency of garbage
* collection. The system should check `isPersistent` to determine whether the
* event should be released into the pool after being dispatched. Users that
* need a persisted event should invoke `persist`.
*
* Synthetic events (and subclasses) implement the DOM Level 3 Events API by
* normalizing browser quirks. Subclasses do not necessarily have to implement a
* DOM interface; custom application-specific events can also subclass this.
*
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {*} targetInst Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @param {DOMEventTarget} nativeEventTarget Target node.
*/
function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
if (process.env.NODE_ENV !== 'production') {
// these have a getter/setter for warnings
delete this.nativeEvent;
delete this.preventDefault;
delete this.stopPropagation;
}
this.dispatchConfig = dispatchConfig;
this._targetInst = targetInst;
this.nativeEvent = nativeEvent;
var Interface = this.constructor.Interface;
for (var propName in Interface) {
if (!Interface.hasOwnProperty(propName)) {
continue;
}
if (process.env.NODE_ENV !== 'production') {
delete this[propName]; // this has a getter/setter for warnings
}
var normalize = Interface[propName];
if (normalize) {
this[propName] = normalize(nativeEvent);
} else {
if (propName === 'target') {
this.target = nativeEventTarget;
} else {
this[propName] = nativeEvent[propName];
}
}
}
var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
if (defaultPrevented) {
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
} else {
this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
}
this.isPropagationStopped = emptyFunction.thatReturnsFalse;
return this;
}
_assign(SyntheticEvent.prototype, {
preventDefault: function () {
this.defaultPrevented = true;
var event = this.nativeEvent;
if (!event) {
return;
}
if (event.preventDefault) {
event.preventDefault();
// eslint-disable-next-line valid-typeof
} else if (typeof event.returnValue !== 'unknown') {
event.returnValue = false;
}
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
},
stopPropagation: function () {
var event = this.nativeEvent;
if (!event) {
return;
}
if (event.stopPropagation) {
event.stopPropagation();
// eslint-disable-next-line valid-typeof
} else if (typeof event.cancelBubble !== 'unknown') {
// The ChangeEventPlugin registers a "propertychange" event for
// IE. This event does not support bubbling or cancelling, and
// any references to cancelBubble throw "Member not found". A
// typeof check of "unknown" circumvents this issue (and is also
// IE specific).
event.cancelBubble = true;
}
this.isPropagationStopped = emptyFunction.thatReturnsTrue;
},
/**
* We release all dispatched `SyntheticEvent`s after each event loop, adding
* them back into the pool. This allows a way to hold onto a reference that
* won't be added back into the pool.
*/
persist: function () {
this.isPersistent = emptyFunction.thatReturnsTrue;
},
/**
* Checks if this event should be released back into the pool.
*
* @return {boolean} True if this should not be released, false otherwise.
*/
isPersistent: emptyFunction.thatReturnsFalse,
/**
* `PooledClass` looks for `destructor` on each instance it releases.
*/
destructor: function () {
var Interface = this.constructor.Interface;
for (var propName in Interface) {
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
} else {
this[propName] = null;
}
}
for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
this[shouldBeReleasedProperties[i]] = null;
}
if (process.env.NODE_ENV !== 'production') {
Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
}
}
});
SyntheticEvent.Interface = EventInterface;
/**
* Helper to reduce boilerplate when creating subclasses.
*
* @param {function} Class
* @param {?object} Interface
*/
SyntheticEvent.augmentClass = function (Class, Interface) {
var Super = this;
var E = function () {};
E.prototype = Super.prototype;
var prototype = new E();
_assign(prototype, Class.prototype);
Class.prototype = prototype;
Class.prototype.constructor = Class;
Class.Interface = _assign({}, Super.Interface, Interface);
Class.augmentClass = Super.augmentClass;
PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler);
};
/** Proxying after everything set on SyntheticEvent
* to resolve Proxy issue on some WebKit browsers
* in which some Event properties are set to undefined (GH#10010)
*/
if (process.env.NODE_ENV !== 'production') {
if (isProxySupported) {
/*eslint-disable no-func-assign */
SyntheticEvent = new Proxy(SyntheticEvent, {
construct: function (target, args) {
return this.apply(target, Object.create(target.prototype), args);
},
apply: function (constructor, that, args) {
return new Proxy(constructor.apply(that, args), {
set: function (target, prop, value) {
if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
process.env.NODE_ENV !== 'production' ? warning(didWarnForAddedNewProperty || target.isPersistent(), "This synthetic event is reused for performance reasons. If you're " + "seeing this, you're adding a new property in the synthetic event object. " + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.') : void 0;
didWarnForAddedNewProperty = true;
}
target[prop] = value;
return true;
}
});
}
});
/*eslint-enable no-func-assign */
}
}
PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler);
module.exports = SyntheticEvent;
/**
* Helper to nullify syntheticEvent instance properties when destructing
*
* @param {object} SyntheticEvent
* @param {String} propName
* @return {object} defineProperty object
*/
function getPooledWarningPropertyDefinition(propName, getVal) {
var isFunction = typeof getVal === 'function';
return {
configurable: true,
set: set,
get: get
};
function set(val) {
var action = isFunction ? 'setting the method' : 'setting the property';
warn(action, 'This is effectively a no-op');
return val;
}
function get() {
var action = isFunction ? 'accessing the method' : 'accessing the property';
var result = isFunction ? 'This is a no-op function' : 'This is set to null';
warn(action, result);
return getVal;
}
function warn(action, result) {
var warningCondition = false;
process.env.NODE_ENV !== 'production' ? warning(warningCondition, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result) : void 0;
}
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _prodInvariant = __webpack_require__(4);
var invariant = __webpack_require__(2);
function checkMask(value, bitmask) {
return (value & bitmask) === bitmask;
}
var DOMPropertyInjection = {
/**
* Mapping from normalized, camelcased property names to a configuration that
* specifies how the associated DOM property should be accessed or rendered.
*/
MUST_USE_PROPERTY: 0x1,
HAS_BOOLEAN_VALUE: 0x4,
HAS_NUMERIC_VALUE: 0x8,
HAS_POSITIVE_NUMERIC_VALUE: 0x10 | 0x8,
HAS_OVERLOADED_BOOLEAN_VALUE: 0x20,
/**
* Inject some specialized knowledge about the DOM. This takes a config object
* with the following properties:
*
* isCustomAttribute: function that given an attribute name will return true
* if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
* attributes where it's impossible to enumerate all of the possible
* attribute names,
*
* Properties: object mapping DOM property name to one of the
* DOMPropertyInjection constants or null. If your attribute isn't in here,
* it won't get written to the DOM.
*
* DOMAttributeNames: object mapping React attribute name to the DOM
* attribute name. Attribute names not specified use the **lowercase**
* normalized name.
*
* DOMAttributeNamespaces: object mapping React attribute name to the DOM
* attribute namespace URL. (Attribute names not specified use no namespace.)
*
* DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
* Property names not specified use the normalized name.
*
* DOMMutationMethods: Properties that require special mutation methods. If
* `value` is undefined, the mutation method should unset the property.
*
* @param {object} domPropertyConfig the config as described above.
*/
injectDOMPropertyConfig: function (domPropertyConfig) {
var Injection = DOMPropertyInjection;
var Properties = domPropertyConfig.Properties || {};
var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};
var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};
if (domPropertyConfig.isCustomAttribute) {
DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute);
}
for (var propName in Properties) {
!!DOMProperty.properties.hasOwnProperty(propName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'injectDOMPropertyConfig(...): You\'re trying to inject DOM property \'%s\' which has already been injected. You may be accidentally injecting the same DOM property config twice, or you may be injecting two configs that have conflicting property names.', propName) : _prodInvariant('48', propName) : void 0;
var lowerCased = propName.toLowerCase();
var propConfig = Properties[propName];
var propertyInfo = {
attributeName: lowerCased,
attributeNamespace: null,
propertyName: propName,
mutationMethod: null,
mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),
hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),
hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),
hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),
hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE)
};
!(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s', propName) : _prodInvariant('50', propName) : void 0;
if (process.env.NODE_ENV !== 'production') {
DOMProperty.getPossibleStandardName[lowerCased] = propName;
}
if (DOMAttributeNames.hasOwnProperty(propName)) {
var attributeName = DOMAttributeNames[propName];
propertyInfo.attributeName = attributeName;
if (process.env.NODE_ENV !== 'production') {
DOMProperty.getPossibleStandardName[attributeName] = propName;
}
}
if (DOMAttributeNamespaces.hasOwnProperty(propName)) {
propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];
}
if (DOMPropertyNames.hasOwnProperty(propName)) {
propertyInfo.propertyName = DOMPropertyNames[propName];
}
if (DOMMutationMethods.hasOwnProperty(propName)) {
propertyInfo.mutationMethod = DOMMutationMethods[propName];
}
DOMProperty.properties[propName] = propertyInfo;
}
}
};
/* eslint-disable max-len */
var ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
/* eslint-enable max-len */
/**
* DOMProperty exports lookup objects that can be used like functions:
*
* > DOMProperty.isValid['id']
* true
* > DOMProperty.isValid['foobar']
* undefined
*
* Although this may be confusing, it performs better in general.
*
* @see http://jsperf.com/key-exists
* @see http://jsperf.com/key-missing
*/
var DOMProperty = {
ID_ATTRIBUTE_NAME: 'data-reactid',
ROOT_ATTRIBUTE_NAME: 'data-reactroot',
ATTRIBUTE_NAME_START_CHAR: ATTRIBUTE_NAME_START_CHAR,
ATTRIBUTE_NAME_CHAR: ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040',
/**
* Map from property "standard name" to an object with info about how to set
* the property in the DOM. Each object contains:
*
* attributeName:
* Used when rendering markup or with `*Attribute()`.
* attributeNamespace
* propertyName:
* Used on DOM node instances. (This includes properties that mutate due to
* external factors.)
* mutationMethod:
* If non-null, used instead of the property or `setAttribute()` after
* initial render.
* mustUseProperty:
* Whether the property must be accessed and mutated as an object property.
* hasBooleanValue:
* Whether the property should be removed when set to a falsey value.
* hasNumericValue:
* Whether the property must be numeric or parse as a numeric and should be
* removed when set to a falsey value.
* hasPositiveNumericValue:
* Whether the property must be positive numeric or parse as a positive
* numeric and should be removed when set to a falsey value.
* hasOverloadedBooleanValue:
* Whether the property can be used as a flag as well as with a value.
* Removed when strictly equal to false; present without a value when
* strictly equal to true; present with a value otherwise.
*/
properties: {},
/**
* Mapping from lowercase property names to the properly cased version, used
* to warn in the case of missing properties. Available only in __DEV__.
*
* autofocus is predefined, because adding it to the property whitelist
* causes unintended side effects.
*
* @type {Object}
*/
getPossibleStandardName: process.env.NODE_ENV !== 'production' ? { autofocus: 'autoFocus' } : null,
/**
* All of the isCustomAttribute() functions that have been injected.
*/
_isCustomAttributeFunctions: [],
/**
* Checks whether a property name is a custom attribute.
* @method
*/
isCustomAttribute: function (attributeName) {
for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {
var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];
if (isCustomAttributeFn(attributeName)) {
return true;
}
}
return false;
},
injection: DOMPropertyInjection
};
module.exports = DOMProperty;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
var _prodInvariant = __webpack_require__(4);
var invariant = __webpack_require__(2);
/**
* Static poolers. Several custom versions for each potential number of
* arguments. A completely generic pooler is easy to implement, but would
* require accessing the `arguments` object. In each of these, `this` refers to
* the Class itself, not an instance. If any others are needed, simply add them
* here, or in their own files.
*/
var oneArgumentPooler = function (copyFieldsFrom) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, copyFieldsFrom);
return instance;
} else {
return new Klass(copyFieldsFrom);
}
};
var twoArgumentPooler = function (a1, a2) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2);
return instance;
} else {
return new Klass(a1, a2);
}
};
var threeArgumentPooler = function (a1, a2, a3) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2, a3);
return instance;
} else {
return new Klass(a1, a2, a3);
}
};
var fourArgumentPooler = function (a1, a2, a3, a4) {
var Klass = this;
if (Klass.instancePool.length) {
var instance = Klass.instancePool.pop();
Klass.call(instance, a1, a2, a3, a4);
return instance;
} else {
return new Klass(a1, a2, a3, a4);
}
};
var standardReleaser = function (instance) {
var Klass = this;
!(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
instance.destructor();
if (Klass.instancePool.length < Klass.poolSize) {
Klass.instancePool.push(instance);
}
};
var DEFAULT_POOL_SIZE = 10;
var DEFAULT_POOLER = oneArgumentPooler;
/**
* Augments `CopyConstructor` to be a poolable class, augmenting only the class
* itself (statically) not adding any prototypical fields. Any CopyConstructor
* you give this may have a `poolSize` property, and will look for a
* prototypical `destructor` on instances.
*
* @param {Function} CopyConstructor Constructor that can be used to reset.
* @param {Function} pooler Customizable pooler.
*/
var addPoolingTo = function (CopyConstructor, pooler) {
// Casting as any so that flow ignores the actual implementation and trusts
// it to match the type we declared
var NewKlass = CopyConstructor;
NewKlass.instancePool = [];
NewKlass.getPooled = pooler || DEFAULT_POOLER;
if (!NewKlass.poolSize) {
NewKlass.poolSize = DEFAULT_POOL_SIZE;
}
NewKlass.release = standardReleaser;
return NewKlass;
};
var PooledClass = {
addPoolingTo: addPoolingTo,
oneArgumentPooler: oneArgumentPooler,
twoArgumentPooler: twoArgumentPooler,
threeArgumentPooler: threeArgumentPooler,
fourArgumentPooler: fourArgumentPooler
};
module.exports = PooledClass;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _assign = __webpack_require__(5);
var ReactCurrentOwner = __webpack_require__(12);
var warning = __webpack_require__(3);
var canDefineProperty = __webpack_require__(33);
var hasOwnProperty = Object.prototype.hasOwnProperty;
var REACT_ELEMENT_TYPE = __webpack_require__(84);
var RESERVED_PROPS = {
key: true,
ref: true,
__self: true,
__source: true
};
var specialPropKeyWarningShown, specialPropRefWarningShown;
function hasValidRef(config) {
if (process.env.NODE_ENV !== 'production') {
if (hasOwnProperty.call(config, 'ref')) {
var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
if (getter && getter.isReactWarning) {
return false;
}
}
}
return config.ref !== undefined;
}
function hasValidKey(config) {
if (process.env.NODE_ENV !== 'production') {
if (hasOwnProperty.call(config, 'key')) {
var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
if (getter && getter.isReactWarning) {
return false;
}
}
}
return config.key !== undefined;
}
function defineKeyPropWarningGetter(props, displayName) {
var warnAboutAccessingKey = function () {
if (!specialPropKeyWarningShown) {
specialPropKeyWarningShown = true;
process.env.NODE_ENV !== 'production' ? warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
}
};
warnAboutAccessingKey.isReactWarning = true;
Object.defineProperty(props, 'key', {
get: warnAboutAccessingKey,
configurable: true
});
}
function defineRefPropWarningGetter(props, displayName) {
var warnAboutAccessingRef = function () {
if (!specialPropRefWarningShown) {
specialPropRefWarningShown = true;
process.env.NODE_ENV !== 'production' ? warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
}
};
warnAboutAccessingRef.isReactWarning = true;
Object.defineProperty(props, 'ref', {
get: warnAboutAccessingRef,
configurable: true
});
}
/**
* Factory method to create a new React element. This no longer adheres to
* the class pattern, so do not use new to call it. Also, no instanceof check
* will work. Instead test $$typeof field against Symbol.for('react.element') to check
* if something is a React Element.
*
* @param {*} type
* @param {*} key
* @param {string|object} ref
* @param {*} self A *temporary* helper to detect places where `this` is
* different from the `owner` when React.createElement is called, so that we
* can warn. We want to get rid of owner and replace string `ref`s with arrow
* functions, and as long as `this` and owner are the same, there will be no
* change in behavior.
* @param {*} source An annotation object (added by a transpiler or otherwise)
* indicating filename, line number, and/or other information.
* @param {*} owner
* @param {*} props
* @internal
*/
var ReactElement = function (type, key, ref, self, source, owner, props) {
var element = {
// This tag allow us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
type: type,
key: key,
ref: ref,
props: props,
// Record the component responsible for creating this element.
_owner: owner
};
if (process.env.NODE_ENV !== 'production') {
// The validation flag is currently mutative. We put it on
// an external backing store so that we can freeze the whole object.
// This can be replaced with a WeakMap once they are implemented in
// commonly used development environments.
element._store = {};
// To make comparing ReactElements easier for testing purposes, we make
// the validation flag non-enumerable (where possible, which should
// include every environment we run tests in), so the test framework
// ignores it.
if (canDefineProperty) {
Object.defineProperty(element._store, 'validated', {
configurable: false,
enumerable: false,
writable: true,
value: false
});
// self and source are DEV only properties.
Object.defineProperty(element, '_self', {
configurable: false,
enumerable: false,
writable: false,
value: self
});
// Two elements created in two different places should be considered
// equal for testing purposes and therefore we hide it from enumeration.
Object.defineProperty(element, '_source', {
configurable: false,
enumerable: false,
writable: false,
value: source
});
} else {
element._store.validated = false;
element._self = self;
element._source = source;
}
if (Object.freeze) {
Object.freeze(element.props);
Object.freeze(element);
}
}
return element;
};
/**
* Create and return a new ReactElement of the given type.
* See https://facebook.github.io/react/docs/top-level-api.html#react.createelement
*/
ReactElement.createElement = function (type, config, children) {
var propName;
// Reserved names are extracted
var props = {};
var key = null;
var ref = null;
var self = null;
var source = null;
if (config != null) {
if (hasValidRef(config)) {
ref = config.ref;
}
if (hasValidKey(config)) {
key = '' + config.key;
}
self = config.__self === undefined ? null : config.__self;
source = config.__source === undefined ? null : config.__source;
// Remaining properties are added to a new props object
for (propName in config) {
if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
props[propName] = config[propName];
}
}
}
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 2];
}
if (process.env.NODE_ENV !== 'production') {
if (Object.freeze) {
Object.freeze(childArray);
}
}
props.children = childArray;
}
// Resolve default props
if (type && type.defaultProps) {
var defaultProps = type.defaultProps;
for (propName in defaultProps) {
if (props[propName] === undefined) {
props[propName] = defaultProps[propName];
}
}
}
if (process.env.NODE_ENV !== 'production') {
if (key || ref) {
if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
if (key) {
defineKeyPropWarningGetter(props, displayName);
}
if (ref) {
defineRefPropWarningGetter(props, displayName);
}
}
}
}
return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
};
/**
* Return a function that produces ReactElements of a given type.
* See https://facebook.github.io/react/docs/top-level-api.html#react.createfactory
*/
ReactElement.createFactory = function (type) {
var factory = ReactElement.createElement.bind(null, type);
// Expose the type on the factory and the prototype so that it can be
// easily accessed on elements. E.g. `<Foo />.type === Foo`.
// This should not be named `constructor` since this may not be the function
// that created the element, and it may not even be a constructor.
// Legacy hook TODO: Warn if this is accessed
factory.type = type;
return factory;
};
ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
return newElement;
};
/**
* Clone and return a new ReactElement using element as the starting point.
* See https://facebook.github.io/react/docs/top-level-api.html#react.cloneelement
*/
ReactElement.cloneElement = function (element, config, children) {
var propName;
// Original props are copied
var props = _assign({}, element.props);
// Reserved names are extracted
var key = element.key;
var ref = element.ref;
// Self is preserved since the owner is preserved.
var self = element._self;
// Source is preserved since cloneElement is unlikely to be targeted by a
// transpiler, and the original source is probably a better indicator of the
// true owner.
var source = element._source;
// Owner will be preserved, unless ref is overridden
var owner = element._owner;
if (config != null) {
if (hasValidRef(config)) {
// Silently steal the ref from the parent.
ref = config.ref;
owner = ReactCurrentOwner.current;
}
if (hasValidKey(config)) {
key = '' + config.key;
}
// Remaining properties override existing props
var defaultProps;
if (element.type && element.type.defaultProps) {
defaultProps = element.type.defaultProps;
}
for (propName in config) {
if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
if (config[propName] === undefined && defaultProps !== undefined) {
// Resolve default props
props[propName] = defaultProps[propName];
} else {
props[propName] = config[propName];
}
}
}
}
// Children can be more than one argument, and those are transferred onto
// the newly allocated props object.
var childrenLength = arguments.length - 2;
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 2];
}
props.children = childArray;
}
return ReactElement(element.type, key, ref, self, source, owner, props);
};
/**
* Verifies the object is a ReactElement.
* See https://facebook.github.io/react/docs/top-level-api.html#react.isvalidelement
* @param {?object} object
* @return {boolean} True if `object` is a valid component.
* @final
*/
ReactElement.isValidElement = function (object) {
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
};
module.exports = ReactElement;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = isPrefixedValue;
var regex = /-webkit-|-moz-|-ms-/;
function isPrefixedValue(value) {
return typeof value === 'string' && regex.test(value);
}
module.exports = exports['default'];
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2015-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var DOMNamespaces = __webpack_require__(37);
var setInnerHTML = __webpack_require__(32);
var createMicrosoftUnsafeLocalFunction = __webpack_require__(44);
var setTextContent = __webpack_require__(81);
var ELEMENT_NODE_TYPE = 1;
var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
/**
* In IE (8-11) and Edge, appending nodes with no children is dramatically
* faster than appending a full subtree, so we essentially queue up the
* .appendChild calls here and apply them so each node is added to its parent
* before any children are added.
*
* In other browsers, doing so is slower or neutral compared to the other order
* (in Firefox, twice as slow) so we only do this inversion in IE.
*
* See https://github.com/spicyj/innerhtml-vs-createelement-vs-clonenode.
*/
var enableLazy = typeof document !== 'undefined' && typeof document.documentMode === 'number' || typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string' && /\bEdge\/\d/.test(navigator.userAgent);
function insertTreeChildren(tree) {
if (!enableLazy) {
return;
}
var node = tree.node;
var children = tree.children;
if (children.length) {
for (var i = 0; i < children.length; i++) {
insertTreeBefore(node, children[i], null);
}
} else if (tree.html != null) {
setInnerHTML(node, tree.html);
} else if (tree.text != null) {
setTextContent(node, tree.text);
}
}
var insertTreeBefore = createMicrosoftUnsafeLocalFunction(function (parentNode, tree, referenceNode) {
// DocumentFragments aren't actually part of the DOM after insertion so
// appending children won't update the DOM. We need to ensure the fragment
// is properly populated first, breaking out of our lazy approach for just
// this level. Also, some <object> plugins (like Flash Player) will read
// <param> nodes immediately upon insertion into the DOM, so <object>
// must also be populated prior to insertion into the DOM.
if (tree.node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE || tree.node.nodeType === ELEMENT_NODE_TYPE && tree.node.nodeName.toLowerCase() === 'object' && (tree.node.namespaceURI == null || tree.node.namespaceURI === DOMNamespaces.html)) {
insertTreeChildren(tree);
parentNode.insertBefore(tree.node, referenceNode);
} else {
parentNode.insertBefore(tree.node, referenceNode);
insertTreeChildren(tree);
}
});
function replaceChildWithTree(oldNode, newTree) {
oldNode.parentNode.replaceChild(newTree.node, oldNode);
insertTreeChildren(newTree);
}
function queueChild(parentTree, childTree) {
if (enableLazy) {
parentTree.children.push(childTree);
} else {
parentTree.node.appendChild(childTree.node);
}
}
function queueHTML(tree, html) {
if (enableLazy) {
tree.html = html;
} else {
setInnerHTML(tree.node, html);
}
}
function queueText(tree, text) {
if (enableLazy) {
tree.text = text;
} else {
setTextContent(tree.node, text);
}
}
function toString() {
return this.node.nodeName;
}
function DOMLazyTree(node) {
return {
node: node,
children: [],
html: null,
text: null,
toString: toString
};
}
DOMLazyTree.insertTreeBefore = insertTreeBefore;
DOMLazyTree.replaceChildWithTree = replaceChildWithTree;
DOMLazyTree.queueChild = queueChild;
DOMLazyTree.queueHTML = queueHTML;
DOMLazyTree.queueText = queueText;
module.exports = DOMLazyTree;
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var ReactRef = __webpack_require__(247);
var ReactInstrumentation = __webpack_require__(9);
var warning = __webpack_require__(3);
/**
* Helper to call ReactRef.attachRefs with this composite component, split out
* to avoid allocations in the transaction mount-ready queue.
*/
function attachRefs() {
ReactRef.attachRefs(this, this._currentElement);
}
var ReactReconciler = {
/**
* Initializes the component, renders markup, and registers event listeners.
*
* @param {ReactComponent} internalInstance
* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
* @param {?object} the containing host component instance
* @param {?object} info about the host container
* @return {?string} Rendered markup to be inserted into the DOM.
* @final
* @internal
*/
mountComponent: function (internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID) // 0 in production and for roots
{
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID);
}
}
var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID);
if (internalInstance._currentElement && internalInstance._currentElement.ref != null) {
transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
}
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID);
}
}
return markup;
},
/**
* Returns a value that can be passed to
* ReactComponentEnvironment.replaceNodeWithMarkup.
*/
getHostNode: function (internalInstance) {
return internalInstance.getHostNode();
},
/**
* Releases any resources allocated by `mountComponent`.
*
* @final
* @internal
*/
unmountComponent: function (internalInstance, safely) {
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID);
}
}
ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
internalInstance.unmountComponent(safely);
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID);
}
}
},
/**
* Update a component using a new element.
*
* @param {ReactComponent} internalInstance
* @param {ReactElement} nextElement
* @param {ReactReconcileTransaction} transaction
* @param {object} context
* @internal
*/
receiveComponent: function (internalInstance, nextElement, transaction, context) {
var prevElement = internalInstance._currentElement;
if (nextElement === prevElement && context === internalInstance._context) {
// Since elements are immutable after the owner is rendered,
// we can do a cheap identity compare here to determine if this is a
// superfluous reconcile. It's possible for state to be mutable but such
// change should trigger an update of the owner which would recreate
// the element. We explicitly check for the existence of an owner since
// it's possible for an element created outside a composite to be
// deeply mutated and reused.
// TODO: Bailing out early is just a perf optimization right?
// TODO: Removing the return statement should affect correctness?
return;
}
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement);
}
}
var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);
if (refsChanged) {
ReactRef.detachRefs(internalInstance, prevElement);
}
internalInstance.receiveComponent(nextElement, transaction, context);
if (refsChanged && internalInstance._currentElement && internalInstance._currentElement.ref != null) {
transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
}
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
}
}
},
/**
* Flush any dirty changes in a component.
*
* @param {ReactComponent} internalInstance
* @param {ReactReconcileTransaction} transaction
* @internal
*/
performUpdateIfNecessary: function (internalInstance, transaction, updateBatchNumber) {
if (internalInstance._updateBatchNumber !== updateBatchNumber) {
// The component's enqueued batch number should always be the current
// batch or the following one.
process.env.NODE_ENV !== 'production' ? warning(internalInstance._updateBatchNumber == null || internalInstance._updateBatchNumber === updateBatchNumber + 1, 'performUpdateIfNecessary: Unexpected batch number (current %s, ' + 'pending %s)', updateBatchNumber, internalInstance._updateBatchNumber) : void 0;
return;
}
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, internalInstance._currentElement);
}
}
internalInstance.performUpdateIfNecessary(transaction);
if (process.env.NODE_ENV !== 'production') {
if (internalInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
}
}
}
};
module.exports = ReactReconciler;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _assign = __webpack_require__(5);
var ReactBaseClasses = __webpack_require__(83);
var ReactChildren = __webpack_require__(280);
var ReactDOMFactories = __webpack_require__(281);
var ReactElement = __webpack_require__(16);
var ReactPropTypes = __webpack_require__(283);
var ReactVersion = __webpack_require__(285);
var createReactClass = __webpack_require__(287);
var onlyChild = __webpack_require__(289);
var createElement = ReactElement.createElement;
var createFactory = ReactElement.createFactory;
var cloneElement = ReactElement.cloneElement;
if (process.env.NODE_ENV !== 'production') {
var lowPriorityWarning = __webpack_require__(51);
var canDefineProperty = __webpack_require__(33);
var ReactElementValidator = __webpack_require__(85);
var didWarnPropTypesDeprecated = false;
createElement = ReactElementValidator.createElement;
createFactory = ReactElementValidator.createFactory;
cloneElement = ReactElementValidator.cloneElement;
}
var __spread = _assign;
var createMixin = function (mixin) {
return mixin;
};
if (process.env.NODE_ENV !== 'production') {
var warnedForSpread = false;
var warnedForCreateMixin = false;
__spread = function () {
lowPriorityWarning(warnedForSpread, 'React.__spread is deprecated and should not be used. Use ' + 'Object.assign directly or another helper function with similar ' + 'semantics. You may be seeing this warning due to your compiler. ' + 'See https://fb.me/react-spread-deprecation for more details.');
warnedForSpread = true;
return _assign.apply(null, arguments);
};
createMixin = function (mixin) {
lowPriorityWarning(warnedForCreateMixin, 'React.createMixin is deprecated and should not be used. ' + 'In React v16.0, it will be removed. ' + 'You can use this mixin directly instead. ' + 'See https://fb.me/createmixin-was-never-implemented for more info.');
warnedForCreateMixin = true;
return mixin;
};
}
var React = {
// Modern
Children: {
map: ReactChildren.map,
forEach: ReactChildren.forEach,
count: ReactChildren.count,
toArray: ReactChildren.toArray,
only: onlyChild
},
Component: ReactBaseClasses.Component,
PureComponent: ReactBaseClasses.PureComponent,
createElement: createElement,
cloneElement: cloneElement,
isValidElement: ReactElement.isValidElement,
// Classic
PropTypes: ReactPropTypes,
createClass: createReactClass,
createFactory: createFactory,
createMixin: createMixin,
// This looks DOM specific but these are actually isomorphic helpers
// since they are just generating DOM strings.
DOM: ReactDOMFactories,
version: ReactVersion,
// Deprecated hook for JSX spread, don't use this for anything.
__spread: __spread
};
if (process.env.NODE_ENV !== 'production') {
var warnedForCreateClass = false;
if (canDefineProperty) {
Object.defineProperty(React, 'PropTypes', {
get: function () {
lowPriorityWarning(didWarnPropTypesDeprecated, 'Accessing PropTypes via the main React package is deprecated,' + ' and will be removed in React v16.0.' + ' Use the latest available v15.* prop-types package from npm instead.' + ' For info on usage, compatibility, migration and more, see ' + 'https://fb.me/prop-types-docs');
didWarnPropTypesDeprecated = true;
return ReactPropTypes;
}
});
Object.defineProperty(React, 'createClass', {
get: function () {
lowPriorityWarning(warnedForCreateClass, 'Accessing createClass via the main React package is deprecated,' + ' and will be removed in React v16.0.' + " Use a plain JavaScript class instead. If you're not yet " + 'ready to migrate, create-react-class v15.* is available ' + 'on npm as a temporary, drop-in replacement. ' + 'For more info see https://fb.me/react-create-class');
warnedForCreateClass = true;
return createReactClass;
}
});
}
// React.DOM factories are deprecated. Wrap these methods so that
// invocations of the React.DOM namespace and alert users to switch
// to the `react-dom-factories` package.
React.DOM = {};
var warnedForFactories = false;
Object.keys(ReactDOMFactories).forEach(function (factory) {
React.DOM[factory] = function () {
if (!warnedForFactories) {
lowPriorityWarning(false, 'Accessing factories like React.DOM.%s has been deprecated ' + 'and will be removed in v16.0+. Use the ' + 'react-dom-factories package instead. ' + ' Version 1.0 provides a drop-in replacement.' + ' For more info, see https://fb.me/react-dom-factories', factory);
warnedForFactories = true;
}
return ReactDOMFactories[factory].apply(ReactDOMFactories, arguments);
};
});
}
module.exports = React;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
/**
* WARNING: DO NOT manually require this module.
* This is a replacement for `invariant(...)` used by the error code system
* and will _only_ be required by the corresponding babel pass.
* It always throws.
*/
function reactProdInvariant(code) {
var argCount = arguments.length - 1;
var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
for (var argIdx = 0; argIdx < argCount; argIdx++) {
message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
}
message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
var error = new Error(message);
error.name = 'Invariant Violation';
error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
throw error;
}
module.exports = reactProdInvariant;
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _prodInvariant = __webpack_require__(4);
var EventPluginRegistry = __webpack_require__(27);
var EventPluginUtils = __webpack_require__(38);
var ReactErrorUtils = __webpack_require__(42);
var accumulateInto = __webpack_require__(74);
var forEachAccumulated = __webpack_require__(75);
var invariant = __webpack_require__(2);
/**
* Internal store for event listeners
*/
var listenerBank = {};
/**
* Internal queue of events that have accumulated their dispatches and are
* waiting to have their dispatches executed.
*/
var eventQueue = null;
/**
* Dispatches an event and releases it back into the pool, unless persistent.
*
* @param {?object} event Synthetic event to be dispatched.
* @param {boolean} simulated If the event is simulated (changes exn behavior)
* @private
*/
var executeDispatchesAndRelease = function (event, simulated) {
if (event) {
EventPluginUtils.executeDispatchesInOrder(event, simulated);
if (!event.isPersistent()) {
event.constructor.release(event);
}
}
};
var executeDispatchesAndReleaseSimulated = function (e) {
return executeDispatchesAndRelease(e, true);
};
var executeDispatchesAndReleaseTopLevel = function (e) {
return executeDispatchesAndRelease(e, false);
};
var getDictionaryKey = function (inst) {
// Prevents V8 performance issue:
// https://github.com/facebook/react/pull/7232
return '.' + inst._rootNodeID;
};
function isInteractive(tag) {
return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
}
function shouldPreventMouseEvent(name, type, props) {
switch (name) {
case 'onClick':
case 'onClickCapture':
case 'onDoubleClick':
case 'onDoubleClickCapture':
case 'onMouseDown':
case 'onMouseDownCapture':
case 'onMouseMove':
case 'onMouseMoveCapture':
case 'onMouseUp':
case 'onMouseUpCapture':
return !!(props.disabled && isInteractive(type));
default:
return false;
}
}
/**
* This is a unified interface for event plugins to be installed and configured.
*
* Event plugins can implement the following properties:
*
* `extractEvents` {function(string, DOMEventTarget, string, object): *}
* Required. When a top-level event is fired, this method is expected to
* extract synthetic events that will in turn be queued and dispatched.
*
* `eventTypes` {object}
* Optional, plugins that fire events must publish a mapping of registration
* names that are used to register listeners. Values of this mapping must
* be objects that contain `registrationName` or `phasedRegistrationNames`.
*
* `executeDispatch` {function(object, function, string)}
* Optional, allows plugins to override how an event gets dispatched. By
* default, the listener is simply invoked.
*
* Each plugin that is injected into `EventsPluginHub` is immediately operable.
*
* @public
*/
var EventPluginHub = {
/**
* Methods for injecting dependencies.
*/
injection: {
/**
* @param {array} InjectedEventPluginOrder
* @public
*/
injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,
/**
* @param {object} injectedNamesToPlugins Map from names to plugin modules.
*/
injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName
},
/**
* Stores `listener` at `listenerBank[registrationName][key]`. Is idempotent.
*
* @param {object} inst The instance, which is the source of events.
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @param {function} listener The callback to store.
*/
putListener: function (inst, registrationName, listener) {
!(typeof listener === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected %s listener to be a function, instead got type %s', registrationName, typeof listener) : _prodInvariant('94', registrationName, typeof listener) : void 0;
var key = getDictionaryKey(inst);
var bankForRegistrationName = listenerBank[registrationName] || (listenerBank[registrationName] = {});
bankForRegistrationName[key] = listener;
var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
if (PluginModule && PluginModule.didPutListener) {
PluginModule.didPutListener(inst, registrationName, listener);
}
},
/**
* @param {object} inst The instance, which is the source of events.
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @return {?function} The stored callback.
*/
getListener: function (inst, registrationName) {
// TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
// live here; needs to be moved to a better place soon
var bankForRegistrationName = listenerBank[registrationName];
if (shouldPreventMouseEvent(registrationName, inst._currentElement.type, inst._currentElement.props)) {
return null;
}
var key = getDictionaryKey(inst);
return bankForRegistrationName && bankForRegistrationName[key];
},
/**
* Deletes a listener from the registration bank.
*
* @param {object} inst The instance, which is the source of events.
* @param {string} registrationName Name of listener (e.g. `onClick`).
*/
deleteListener: function (inst, registrationName) {
var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
if (PluginModule && PluginModule.willDeleteListener) {
PluginModule.willDeleteListener(inst, registrationName);
}
var bankForRegistrationName = listenerBank[registrationName];
// TODO: This should never be null -- when is it?
if (bankForRegistrationName) {
var key = getDictionaryKey(inst);
delete bankForRegistrationName[key];
}
},
/**
* Deletes all listeners for the DOM element with the supplied ID.
*
* @param {object} inst The instance, which is the source of events.
*/
deleteAllListeners: function (inst) {
var key = getDictionaryKey(inst);
for (var registrationName in listenerBank) {
if (!listenerBank.hasOwnProperty(registrationName)) {
continue;
}
if (!listenerBank[registrationName][key]) {
continue;
}
var PluginModule = EventPluginRegistry.registrationNameModules[registrationName];
if (PluginModule && PluginModule.willDeleteListener) {
PluginModule.willDeleteListener(inst, registrationName);
}
delete listenerBank[registrationName][key];
}
},
/**
* Allows registered plugins an opportunity to extract events from top-level
* native browser events.
*
* @return {*} An accumulation of synthetic events.
* @internal
*/
extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
var events;
var plugins = EventPluginRegistry.plugins;
for (var i = 0; i < plugins.length; i++) {
// Not every plugin in the ordering may be loaded at runtime.
var possiblePlugin = plugins[i];
if (possiblePlugin) {
var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
if (extractedEvents) {
events = accumulateInto(events, extractedEvents);
}
}
}
return events;
},
/**
* Enqueues a synthetic event that should be dispatched when
* `processEventQueue` is invoked.
*
* @param {*} events An accumulation of synthetic events.
* @internal
*/
enqueueEvents: function (events) {
if (events) {
eventQueue = accumulateInto(eventQueue, events);
}
},
/**
* Dispatches all synthetic events on the event queue.
*
* @internal
*/
processEventQueue: function (simulated) {
// Set `eventQueue` to null before processing it so that we can tell if more
// events get enqueued while processing.
var processingEventQueue = eventQueue;
eventQueue = null;
if (simulated) {
forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
} else {
forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
}
!!eventQueue ? process.env.NODE_ENV !== 'production' ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : _prodInvariant('95') : void 0;
// This would be a good time to rethrow if any of the event handlers threw.
ReactErrorUtils.rethrowCaughtError();
},
/**
* These are needed for tests only. Do not use!
*/
__purge: function () {
listenerBank = {};
},
__getListenerBank: function () {
return listenerBank;
}
};
module.exports = EventPluginHub;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var EventPluginHub = __webpack_require__(22);
var EventPluginUtils = __webpack_require__(38);
var accumulateInto = __webpack_require__(74);
var forEachAccumulated = __webpack_require__(75);
var warning = __webpack_require__(3);
var getListener = EventPluginHub.getListener;
/**
* Some event types have a notion of different registration names for different
* "phases" of propagation. This finds listeners by a given phase.
*/
function listenerAtPhase(inst, event, propagationPhase) {
var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
return getListener(inst, registrationName);
}
/**
* Tags a `SyntheticEvent` with dispatched listeners. Creating this function
* here, allows us to not have to bind or create functions for each event.
* Mutating the event's members allows us to not have to create a wrapping
* "dispatch" object that pairs the event with the listener.
*/
function accumulateDirectionalDispatches(inst, phase, event) {
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(inst, 'Dispatching inst must not be null') : void 0;
}
var listener = listenerAtPhase(inst, event, phase);
if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
}
}
/**
* Collect dispatches (must be entirely collected before dispatching - see unit
* tests). Lazily allocate the array to conserve memory. We must loop through
* each event and perform the traversal for each one. We cannot perform a
* single traversal for the entire collection of events because each event may
* have a different target.
*/
function accumulateTwoPhaseDispatchesSingle(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
EventPluginUtils.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
}
}
/**
* Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
*/
function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
var targetInst = event._targetInst;
var parentInst = targetInst ? EventPluginUtils.getParentInstance(targetInst) : null;
EventPluginUtils.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
}
}
/**
* Accumulates without regard to direction, does not look for phased
* registration names. Same as `accumulateDirectDispatchesSingle` but without
* requiring that the `dispatchMarker` be the same as the dispatched ID.
*/
function accumulateDispatches(inst, ignoredDirection, event) {
if (event && event.dispatchConfig.registrationName) {
var registrationName = event.dispatchConfig.registrationName;
var listener = getListener(inst, registrationName);
if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
}
}
}
/**
* Accumulates dispatches on an `SyntheticEvent`, but only for the
* `dispatchMarker`.
* @param {SyntheticEvent} event
*/
function accumulateDirectDispatchesSingle(event) {
if (event && event.dispatchConfig.registrationName) {
accumulateDispatches(event._targetInst, null, event);
}
}
function accumulateTwoPhaseDispatches(events) {
forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
}
function accumulateTwoPhaseDispatchesSkipTarget(events) {
forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
}
function accumulateEnterLeaveDispatches(leave, enter, from, to) {
EventPluginUtils.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
}
function accumulateDirectDispatches(events) {
forEachAccumulated(events, accumulateDirectDispatchesSingle);
}
/**
* A small set of propagation patterns, each of which will accept a small amount
* of information, and generate a set of "dispatch ready event objects" - which
* are sets of events that have already been annotated with a set of dispatched
* listener functions/ids. The API is designed this way to discourage these
* propagation strategies from actually executing the dispatches, since we
* always want to collect the entire set of dispatches before executing event a
* single one.
*
* @constructor EventPropagators
*/
var EventPropagators = {
accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
accumulateDirectDispatches: accumulateDirectDispatches,
accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
};
module.exports = EventPropagators;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
/**
* `ReactInstanceMap` maintains a mapping from a public facing stateful
* instance (key) and the internal representation (value). This allows public
* methods to accept the user facing instance as an argument and map them back
* to internal methods.
*/
// TODO: Replace this with ES6: var ReactInstanceMap = new Map();
var ReactInstanceMap = {
/**
* This API should be called `delete` but we'd have to make sure to always
* transform these to strings for IE support. When this transform is fully
* supported we can rename it.
*/
remove: function (key) {
key._reactInternalInstance = undefined;
},
get: function (key) {
return key._reactInternalInstance;
},
has: function (key) {
return key._reactInternalInstance !== undefined;
},
set: function (key, value) {
key._reactInternalInstance = value;
}
};
module.exports = ReactInstanceMap;
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var SyntheticEvent = __webpack_require__(13);
var getEventTarget = __webpack_require__(47);
/**
* @interface UIEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var UIEventInterface = {
view: function (event) {
if (event.view) {
return event.view;
}
var target = getEventTarget(event);
if (target.window === target) {
// target is a window object
return target;
}
var doc = target.ownerDocument;
// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
if (doc) {
return doc.defaultView || doc.parentWindow;
} else {
return window;
}
},
detail: function (event) {
return event.detail || 0;
}
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticEvent}
*/
function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);
module.exports = SyntheticUIEvent;
/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var emptyObject = {};
if (process.env.NODE_ENV !== 'production') {
Object.freeze(emptyObject);
}
module.exports = emptyObject;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
var _prodInvariant = __webpack_require__(4);
var invariant = __webpack_require__(2);
/**
* Injectable ordering of event plugins.
*/
var eventPluginOrder = null;
/**
* Injectable mapping from names to event plugin modules.
*/
var namesToPlugins = {};
/**
* Recomputes the plugin list using the injected plugins and plugin ordering.
*
* @private
*/
function recomputePluginOrdering() {
if (!eventPluginOrder) {
// Wait until an `eventPluginOrder` is injected.
return;
}
for (var pluginName in namesToPlugins) {
var pluginModule = namesToPlugins[pluginName];
var pluginIndex = eventPluginOrder.indexOf(pluginName);
!(pluginIndex > -1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : _prodInvariant('96', pluginName) : void 0;
if (EventPluginRegistry.plugins[pluginIndex]) {
continue;
}
!pluginModule.extractEvents ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : _prodInvariant('97', pluginName) : void 0;
EventPluginRegistry.plugins[pluginIndex] = pluginModule;
var publishedEvents = pluginModule.eventTypes;
for (var eventName in publishedEvents) {
!publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : _prodInvariant('98', eventName, pluginName) : void 0;
}
}
}
/**
* Publishes an event so that it can be dispatched by the supplied plugin.
*
* @param {object} dispatchConfig Dispatch configuration for the event.
* @param {object} PluginModule Plugin publishing the event.
* @return {boolean} True if the event was successfully published.
* @private
*/
function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
!!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : _prodInvariant('99', eventName) : void 0;
EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
if (phasedRegistrationNames) {
for (var phaseName in phasedRegistrationNames) {
if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
var phasedRegistrationName = phasedRegistrationNames[phaseName];
publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
}
}
return true;
} else if (dispatchConfig.registrationName) {
publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);
return true;
}
return false;
}
/**
* Publishes a registration name that is used to identify dispatched events and
* can be used with `EventPluginHub.putListener` to register listeners.
*
* @param {string} registrationName Registration name to add.
* @param {object} PluginModule Plugin publishing the event.
* @private
*/
function publishRegistrationName(registrationName, pluginModule, eventName) {
!!EventPluginRegistry.registrationNameModules[registrationName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : _prodInvariant('100', registrationName) : void 0;
EventPluginRegistry.registrationNameModules[registrationName] = pluginModule;
EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
if (process.env.NODE_ENV !== 'production') {
var lowerCasedName = registrationName.toLowerCase();
EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName;
if (registrationName === 'onDoubleClick') {
EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName;
}
}
}
/**
* Registers plugins so that they can extract and dispatch events.
*
* @see {EventPluginHub}
*/
var EventPluginRegistry = {
/**
* Ordered list of injected plugins.
*/
plugins: [],
/**
* Mapping from event name to dispatch config
*/
eventNameDispatchConfigs: {},
/**
* Mapping from registration name to plugin module
*/
registrationNameModules: {},
/**
* Mapping from registration name to event name
*/
registrationNameDependencies: {},
/**
* Mapping from lowercase registration names to the properly cased version,
* used to warn in the case of missing event handlers. Available
* only in __DEV__.
* @type {Object}
*/
possibleRegistrationNames: process.env.NODE_ENV !== 'production' ? {} : null,
// Trust the developer to only use possibleRegistrationNames in __DEV__
/**
* Injects an ordering of plugins (by plugin name). This allows the ordering
* to be decoupled from injection of the actual plugins so that ordering is
* always deterministic regardless of packaging, on-the-fly injection, etc.
*
* @param {array} InjectedEventPluginOrder
* @internal
* @see {EventPluginHub.injection.injectEventPluginOrder}
*/
injectEventPluginOrder: function (injectedEventPluginOrder) {
!!eventPluginOrder ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : _prodInvariant('101') : void 0;
// Clone the ordering so it cannot be dynamically mutated.
eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
recomputePluginOrdering();
},
/**
* Injects plugins to be used by `EventPluginHub`. The plugin names must be
* in the ordering injected by `injectEventPluginOrder`.
*
* Plugins can be injected as part of page initialization or on-the-fly.
*
* @param {object} injectedNamesToPlugins Map from names to plugin modules.
* @internal
* @see {EventPluginHub.injection.injectEventPluginsByName}
*/
injectEventPluginsByName: function (injectedNamesToPlugins) {
var isOrderingDirty = false;
for (var pluginName in injectedNamesToPlugins) {
if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
continue;
}
var pluginModule = injectedNamesToPlugins[pluginName];
if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
!!namesToPlugins[pluginName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : _prodInvariant('102', pluginName) : void 0;
namesToPlugins[pluginName] = pluginModule;
isOrderingDirty = true;
}
}
if (isOrderingDirty) {
recomputePluginOrdering();
}
},
/**
* Looks up the plugin for the supplied event.
*
* @param {object} event A synthetic event.
* @return {?object} The plugin that created the supplied event.
* @internal
*/
getPluginModuleForEvent: function (event) {
var dispatchConfig = event.dispatchConfig;
if (dispatchConfig.registrationName) {
return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null;
}
if (dispatchConfig.phasedRegistrationNames !== undefined) {
// pulling phasedRegistrationNames out of dispatchConfig helps Flow see
// that it is not undefined.
var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
for (var phase in phasedRegistrationNames) {
if (!phasedRegistrationNames.hasOwnProperty(phase)) {
continue;
}
var pluginModule = EventPluginRegistry.registrationNameModules[phasedRegistrationNames[phase]];
if (pluginModule) {
return pluginModule;
}
}
}
return null;
},
/**
* Exposed for unit testing.
* @private
*/
_resetEventPlugins: function () {
eventPluginOrder = null;
for (var pluginName in namesToPlugins) {
if (namesToPlugins.hasOwnProperty(pluginName)) {
delete namesToPlugins[pluginName];
}
}
EventPluginRegistry.plugins.length = 0;
var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;
for (var eventName in eventNameDispatchConfigs) {
if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {
delete eventNameDispatchConfigs[eventName];
}
}
var registrationNameModules = EventPluginRegistry.registrationNameModules;
for (var registrationName in registrationNameModules) {
if (registrationNameModules.hasOwnProperty(registrationName)) {
delete registrationNameModules[registrationName];
}
}
if (process.env.NODE_ENV !== 'production') {
var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames;
for (var lowerCasedName in possibleRegistrationNames) {
if (possibleRegistrationNames.hasOwnProperty(lowerCasedName)) {
delete possibleRegistrationNames[lowerCasedName];
}
}
}
}
};
module.exports = EventPluginRegistry;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _assign = __webpack_require__(5);
var EventPluginRegistry = __webpack_require__(27);
var ReactEventEmitterMixin = __webpack_require__(237);
var ViewportMetrics = __webpack_require__(73);
var getVendorPrefixedEventName = __webpack_require__(272);
var isEventSupported = __webpack_require__(48);
/**
* Summary of `ReactBrowserEventEmitter` event handling:
*
* - Top-level delegation is used to trap most native browser events. This
* may only occur in the main thread and is the responsibility of
* ReactEventListener, which is injected and can therefore support pluggable
* event sources. This is the only work that occurs in the main thread.
*
* - We normalize and de-duplicate events to account for browser quirks. This
* may be done in the worker thread.
*
* - Forward these native events (with the associated top-level type used to
* trap it) to `EventPluginHub`, which in turn will ask plugins if they want
* to extract any synthetic events.
*
* - The `EventPluginHub` will then process each event by annotating them with
* "dispatches", a sequence of listeners and IDs that care about that event.
*
* - The `EventPluginHub` then dispatches the events.
*
* Overview of React and the event system:
*
* +------------+ .
* | DOM | .
* +------------+ .
* | .
* v .
* +------------+ .
* | ReactEvent | .
* | Listener | .
* +------------+ . +-----------+
* | . +--------+|SimpleEvent|
* | . | |Plugin |
* +-----|------+ . v +-----------+
* | | | . +--------------+ +------------+
* | +-----------.--->|EventPluginHub| | Event |
* | | . | | +-----------+ | Propagators|
* | ReactEvent | . | | |TapEvent | |------------|
* | Emitter | . | |<---+|Plugin | |other plugin|
* | | . | | +-----------+ | utilities |
* | +-----------.--->| | +------------+
* | | | . +--------------+
* +-----|------+ . ^ +-----------+
* | . | |Enter/Leave|
* + . +-------+|Plugin |
* +-------------+ . +-----------+
* | application | .
* |-------------| .
* | | .
* | | .
* +-------------+ .
* .
* React Core . General Purpose Event Plugin System
*/
var hasEventPageXY;
var alreadyListeningTo = {};
var isMonitoringScrollValue = false;
var reactTopListenersCounter = 0;
// For events like 'submit' which don't consistently bubble (which we trap at a
// lower node than `document`), binding at `document` would cause duplicate
// events so we don't include them here
var topEventMapping = {
topAbort: 'abort',
topAnimationEnd: getVendorPrefixedEventName('animationend') || 'animationend',
topAnimationIteration: getVendorPrefixedEventName('animationiteration') || 'animationiteration',
topAnimationStart: getVendorPrefixedEventName('animationstart') || 'animationstart',
topBlur: 'blur',
topCanPlay: 'canplay',
topCanPlayThrough: 'canplaythrough',
topChange: 'change',
topClick: 'click',
topCompositionEnd: 'compositionend',
topCompositionStart: 'compositionstart',
topCompositionUpdate: 'compositionupdate',
topContextMenu: 'contextmenu',
topCopy: 'copy',
topCut: 'cut',
topDoubleClick: 'dblclick',
topDrag: 'drag',
topDragEnd: 'dragend',
topDragEnter: 'dragenter',
topDragExit: 'dragexit',
topDragLeave: 'dragleave',
topDragOver: 'dragover',
topDragStart: 'dragstart',
topDrop: 'drop',
topDurationChange: 'durationchange',
topEmptied: 'emptied',
topEncrypted: 'encrypted',
topEnded: 'ended',
topError: 'error',
topFocus: 'focus',
topInput: 'input',
topKeyDown: 'keydown',
topKeyPress: 'keypress',
topKeyUp: 'keyup',
topLoadedData: 'loadeddata',
topLoadedMetadata: 'loadedmetadata',
topLoadStart: 'loadstart',
topMouseDown: 'mousedown',
topMouseMove: 'mousemove',
topMouseOut: 'mouseout',
topMouseOver: 'mouseover',
topMouseUp: 'mouseup',
topPaste: 'paste',
topPause: 'pause',
topPlay: 'play',
topPlaying: 'playing',
topProgress: 'progress',
topRateChange: 'ratechange',
topScroll: 'scroll',
topSeeked: 'seeked',
topSeeking: 'seeking',
topSelectionChange: 'selectionchange',
topStalled: 'stalled',
topSuspend: 'suspend',
topTextInput: 'textInput',
topTimeUpdate: 'timeupdate',
topTouchCancel: 'touchcancel',
topTouchEnd: 'touchend',
topTouchMove: 'touchmove',
topTouchStart: 'touchstart',
topTransitionEnd: getVendorPrefixedEventName('transitionend') || 'transitionend',
topVolumeChange: 'volumechange',
topWaiting: 'waiting',
topWheel: 'wheel'
};
/**
* To ensure no conflicts with other potential React instances on the page
*/
var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);
function getListeningForDocument(mountAt) {
// In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`
// directly.
if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {
mountAt[topListenersIDKey] = reactTopListenersCounter++;
alreadyListeningTo[mountAt[topListenersIDKey]] = {};
}
return alreadyListeningTo[mountAt[topListenersIDKey]];
}
/**
* `ReactBrowserEventEmitter` is used to attach top-level event listeners. For
* example:
*
* EventPluginHub.putListener('myID', 'onClick', myFunction);
*
* This would allocate a "registration" of `('onClick', myFunction)` on 'myID'.
*
* @internal
*/
var ReactBrowserEventEmitter = _assign({}, ReactEventEmitterMixin, {
/**
* Injectable event backend
*/
ReactEventListener: null,
injection: {
/**
* @param {object} ReactEventListener
*/
injectReactEventListener: function (ReactEventListener) {
ReactEventListener.setHandleTopLevel(ReactBrowserEventEmitter.handleTopLevel);
ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;
}
},
/**
* Sets whether or not any created callbacks should be enabled.
*
* @param {boolean} enabled True if callbacks should be enabled.
*/
setEnabled: function (enabled) {
if (ReactBrowserEventEmitter.ReactEventListener) {
ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);
}
},
/**
* @return {boolean} True if callbacks are enabled.
*/
isEnabled: function () {
return !!(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled());
},
/**
* We listen for bubbled touch events on the document object.
*
* Firefox v8.01 (and possibly others) exhibited strange behavior when
* mounting `onmousemove` events at some node that was not the document
* element. The symptoms were that if your mouse is not moving over something
* contained within that mount point (for example on the background) the
* top-level listeners for `onmousemove` won't be called. However, if you
* register the `mousemove` on the document object, then it will of course
* catch all `mousemove`s. This along with iOS quirks, justifies restricting
* top-level listeners to the document object only, at least for these
* movement types of events and possibly all events.
*
* @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
*
* Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but
* they bubble to document.
*
* @param {string} registrationName Name of listener (e.g. `onClick`).
* @param {object} contentDocumentHandle Document which owns the container
*/
listenTo: function (registrationName, contentDocumentHandle) {
var mountAt = contentDocumentHandle;
var isListening = getListeningForDocument(mountAt);
var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName];
for (var i = 0; i < dependencies.length; i++) {
var dependency = dependencies[i];
if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {
if (dependency === 'topWheel') {
if (isEventSupported('wheel')) {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'wheel', mountAt);
} else if (isEventSupported('mousewheel')) {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'mousewheel', mountAt);
} else {
// Firefox needs to capture a different mouse scroll event.
// @see http://www.quirksmode.org/dom/events/tests/scroll.html
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'DOMMouseScroll', mountAt);
}
} else if (dependency === 'topScroll') {
if (isEventSupported('scroll', true)) {
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topScroll', 'scroll', mountAt);
} else {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topScroll', 'scroll', ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE);
}
} else if (dependency === 'topFocus' || dependency === 'topBlur') {
if (isEventSupported('focus', true)) {
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topFocus', 'focus', mountAt);
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topBlur', 'blur', mountAt);
} else if (isEventSupported('focusin')) {
// IE has `focusin` and `focusout` events which bubble.
// @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topFocus', 'focusin', mountAt);
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topBlur', 'focusout', mountAt);
}
// to make sure blur and focus event listeners are only attached once
isListening.topBlur = true;
isListening.topFocus = true;
} else if (topEventMapping.hasOwnProperty(dependency)) {
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(dependency, topEventMapping[dependency], mountAt);
}
isListening[dependency] = true;
}
}
},
trapBubbledEvent: function (topLevelType, handlerBaseName, handle) {
return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelType, handlerBaseName, handle);
},
trapCapturedEvent: function (topLevelType, handlerBaseName, handle) {
return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelType, handlerBaseName, handle);
},
/**
* Protect against document.createEvent() returning null
* Some popup blocker extensions appear to do this:
* https://github.com/facebook/react/issues/6887
*/
supportsEventPageXY: function () {
if (!document.createEvent) {
return false;
}
var ev = document.createEvent('MouseEvent');
return ev != null && 'pageX' in ev;
},
/**
* Listens to window scroll and resize events. We cache scroll values so that
* application code can access them without triggering reflows.
*
* ViewportMetrics is only used by SyntheticMouse/TouchEvent and only when
* pageX/pageY isn't supported (legacy browsers).
*
* NOTE: Scroll events do not bubble.
*
* @see http://www.quirksmode.org/dom/events/scroll.html
*/
ensureScrollValueMonitoring: function () {
if (hasEventPageXY === undefined) {
hasEventPageXY = ReactBrowserEventEmitter.supportsEventPageXY();
}
if (!hasEventPageXY && !isMonitoringScrollValue) {
var refresh = ViewportMetrics.refreshScrollValues;
ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);
isMonitoringScrollValue = true;
}
}
});
module.exports = ReactBrowserEventEmitter;
/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var SyntheticUIEvent = __webpack_require__(25);
var ViewportMetrics = __webpack_require__(73);
var getEventModifierState = __webpack_require__(46);
/**
* @interface MouseEvent
* @see http://www.w3.org/TR/DOM-Level-3-Events/
*/
var MouseEventInterface = {
screenX: null,
screenY: null,
clientX: null,
clientY: null,
ctrlKey: null,
shiftKey: null,
altKey: null,
metaKey: null,
getModifierState: getEventModifierState,
button: function (event) {
// Webkit, Firefox, IE9+
// which: 1 2 3
// button: 0 1 2 (standard)
var button = event.button;
if ('which' in event) {
return button;
}
// IE<9
// which: undefined
// button: 0 0 0
// button: 1 4 2 (onmouseup)
return button === 2 ? 2 : button === 4 ? 1 : 0;
},
buttons: null,
relatedTarget: function (event) {
return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement);
},
// "Proprietary" Interface.
pageX: function (event) {
return 'pageX' in event ? event.pageX : event.clientX + ViewportMetrics.currentScrollLeft;
},
pageY: function (event) {
return 'pageY' in event ? event.pageY : event.clientY + ViewportMetrics.currentScrollTop;
}
};
/**
* @param {object} dispatchConfig Configuration used to dispatch this event.
* @param {string} dispatchMarker Marker identifying the event target.
* @param {object} nativeEvent Native browser event.
* @extends {SyntheticUIEvent}
*/
function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);
module.exports = SyntheticMouseEvent;
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
var _prodInvariant = __webpack_require__(4);
var invariant = __webpack_require__(2);
var OBSERVED_ERROR = {};
/**
* `Transaction` creates a black box that is able to wrap any method such that
* certain invariants are maintained before and after the method is invoked
* (Even if an exception is thrown while invoking the wrapped method). Whoever
* instantiates a transaction can provide enforcers of the invariants at
* creation time. The `Transaction` class itself will supply one additional
* automatic invariant for you - the invariant that any transaction instance
* should not be run while it is already being run. You would typically create a
* single instance of a `Transaction` for reuse multiple times, that potentially
* is used to wrap several different methods. Wrappers are extremely simple -
* they only require implementing two methods.
*
* <pre>
* wrappers (injected at creation time)
* + +
* | |
* +-----------------|--------|--------------+
* | v | |
* | +---------------+ | |
* | +--| wrapper1 |---|----+ |
* | | +---------------+ v | |
* | | +-------------+ | |
* | | +----| wrapper2 |--------+ |
* | | | +-------------+ | | |
* | | | | | |
* | v v v v | wrapper
* | +---+ +---+ +---------+ +---+ +---+ | invariants
* perform(anyMethod) | | | | | | | | | | | | maintained
* +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|-------->
* | | | | | | | | | | | |
* | | | | | | | | | | | |
* | | | | | | | | | | | |
* | +---+ +---+ +---------+ +---+ +---+ |
* | initialize close |
* +-----------------------------------------+
* </pre>
*
* Use cases:
* - Preserving the input selection ranges before/after reconciliation.
* Restoring selection even in the event of an unexpected error.
* - Deactivating events while rearranging the DOM, preventing blurs/focuses,
* while guaranteeing that afterwards, the event system is reactivated.
* - Flushing a queue of collected DOM mutations to the main UI thread after a
* reconciliation takes place in a worker thread.
* - Invoking any collected `componentDidUpdate` callbacks after rendering new
* content.
* - (Future use case): Wrapping particular flushes of the `ReactWorker` queue
* to preserve the `scrollTop` (an automatic scroll aware DOM).
* - (Future use case): Layout calculations before and after DOM updates.
*
* Transactional plugin API:
* - A module that has an `initialize` method that returns any precomputation.
* - and a `close` method that accepts the precomputation. `close` is invoked
* when the wrapped process is completed, or has failed.
*
* @param {Array<TransactionalWrapper>} transactionWrapper Wrapper modules
* that implement `initialize` and `close`.
* @return {Transaction} Single transaction for reuse in thread.
*
* @class Transaction
*/
var TransactionImpl = {
/**
* Sets up this instance so that it is prepared for collecting metrics. Does
* so such that this setup method may be used on an instance that is already
* initialized, in a way that does not consume additional memory upon reuse.
* That can be useful if you decide to make your subclass of this mixin a
* "PooledClass".
*/
reinitializeTransaction: function () {
this.transactionWrappers = this.getTransactionWrappers();
if (this.wrapperInitData) {
this.wrapperInitData.length = 0;
} else {
this.wrapperInitData = [];
}
this._isInTransaction = false;
},
_isInTransaction: false,
/**
* @abstract
* @return {Array<TransactionWrapper>} Array of transaction wrappers.
*/
getTransactionWrappers: null,
isInTransaction: function () {
return !!this._isInTransaction;
},
/* eslint-disable space-before-function-paren */
/**
* Executes the function within a safety window. Use this for the top level
* methods that result in large amounts of computation/mutations that would
* need to be safety checked. The optional arguments helps prevent the need
* to bind in many cases.
*
* @param {function} method Member of scope to call.
* @param {Object} scope Scope to invoke from.
* @param {Object?=} a Argument to pass to the method.
* @param {Object?=} b Argument to pass to the method.
* @param {Object?=} c Argument to pass to the method.
* @param {Object?=} d Argument to pass to the method.
* @param {Object?=} e Argument to pass to the method.
* @param {Object?=} f Argument to pass to the method.
*
* @return {*} Return value from `method`.
*/
perform: function (method, scope, a, b, c, d, e, f) {
/* eslint-enable space-before-function-paren */
!!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.perform(...): Cannot initialize a transaction when there is already an outstanding transaction.') : _prodInvariant('27') : void 0;
var errorThrown;
var ret;
try {
this._isInTransaction = true;
// Catching errors makes debugging more difficult, so we start with
// errorThrown set to true before setting it to false after calling
// close -- if it's still set to true in the finally block, it means
// one of these calls threw.
errorThrown = true;
this.initializeAll(0);
ret = method.call(scope, a, b, c, d, e, f);
errorThrown = false;
} finally {
try {
if (errorThrown) {
// If `method` throws, prefer to show that stack trace over any thrown
// by invoking `closeAll`.
try {
this.closeAll(0);
} catch (err) {}
} else {
// Since `method` didn't throw, we don't want to silence the exception
// here.
this.closeAll(0);
}
} finally {
this._isInTransaction = false;
}
}
return ret;
},
initializeAll: function (startIndex) {
var transactionWrappers = this.transactionWrappers;
for (var i = startIndex; i < transactionWrappers.length; i++) {
var wrapper = transactionWrappers[i];
try {
// Catching errors makes debugging more difficult, so we start with the
// OBSERVED_ERROR state before overwriting it with the real return value
// of initialize -- if it's still set to OBSERVED_ERROR in the finally
// block, it means wrapper.initialize threw.
this.wrapperInitData[i] = OBSERVED_ERROR;
this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;
} finally {
if (this.wrapperInitData[i] === OBSERVED_ERROR) {
// The initializer for wrapper i threw an error; initialize the
// remaining wrappers but silence any exceptions from them to ensure
// that the first error is the one to bubble up.
try {
this.initializeAll(i + 1);
} catch (err) {}
}
}
}
},
/**
* Invokes each of `this.transactionWrappers.close[i]` functions, passing into
* them the respective return values of `this.transactionWrappers.init[i]`
* (`close`rs that correspond to initializers that failed will not be
* invoked).
*/
closeAll: function (startIndex) {
!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.closeAll(): Cannot close transaction when none are open.') : _prodInvariant('28') : void 0;
var transactionWrappers = this.transactionWrappers;
for (var i = startIndex; i < transactionWrappers.length; i++) {
var wrapper = transactionWrappers[i];
var initData = this.wrapperInitData[i];
var errorThrown;
try {
// Catching errors makes debugging more difficult, so we start with
// errorThrown set to true before setting it to false after calling
// close -- if it's still set to true in the finally block, it means
// wrapper.close threw.
errorThrown = true;
if (initData !== OBSERVED_ERROR && wrapper.close) {
wrapper.close.call(this, initData);
}
errorThrown = false;
} finally {
if (errorThrown) {
// The closer for wrapper i threw an error; close the remaining
// wrappers but silence any exceptions from them to ensure that the
// first error is the one to bubble up.
try {
this.closeAll(i + 1);
} catch (e) {}
}
}
}
this.wrapperInitData.length = 0;
}
};
module.exports = TransactionImpl;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2016-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* Based on the escape-html library, which is used under the MIT License below:
*
* Copyright (c) 2012-2013 TJ Holowaychuk
* Copyright (c) 2015 Andreas Lubbe
* Copyright (c) 2015 Tiancheng "Timothy" Gu
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* 'Software'), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
// code copied and modified from escape-html
/**
* Module variables.
* @private
*/
var matchHtmlRegExp = /["'&<>]/;
/**
* Escape special characters in the given string of html.
*
* @param {string} string The string to escape for inserting into HTML
* @return {string}
* @public
*/
function escapeHtml(string) {
var str = '' + string;
var match = matchHtmlRegExp.exec(str);
if (!match) {
return str;
}
var escape;
var html = '';
var index = 0;
var lastIndex = 0;
for (index = match.index; index < str.length; index++) {
switch (str.charCodeAt(index)) {
case 34:
// "
escape = '"';
break;
case 38:
// &
escape = '&';
break;
case 39:
// '
escape = '''; // modified from escape-html; used to be '''
break;
case 60:
// <
escape = '<';
break;
case 62:
// >
escape = '>';
break;
default:
continue;
}
if (lastIndex !== index) {
html += str.substring(lastIndex, index);
}
lastIndex = index + 1;
html += escape;
}
return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
}
// end code copied and modified from escape-html
/**
* Escapes text to prevent scripting attacks.
*
* @param {*} text Text value to escape.
* @return {string} An escaped string.
*/
function escapeTextContentForBrowser(text) {
if (typeof text === 'boolean' || typeof text === 'number') {
// this shortcircuit helps perf for types that we know will never have
// special characters, especially given that this function is used often
// for numeric dom ids.
return '' + text;
}
return escapeHtml(text);
}
module.exports = escapeTextContentForBrowser;
/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var ExecutionEnvironment = __webpack_require__(7);
var DOMNamespaces = __webpack_require__(37);
var WHITESPACE_TEST = /^[ \r\n\t\f]/;
var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;
var createMicrosoftUnsafeLocalFunction = __webpack_require__(44);
// SVG temp container for IE lacking innerHTML
var reusableSVGContainer;
/**
* Set the innerHTML property of a node, ensuring that whitespace is preserved
* even in IE8.
*
* @param {DOMElement} node
* @param {string} html
* @internal
*/
var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
// IE does not have innerHTML for SVG nodes, so instead we inject the
// new markup in a temp node and then move the child nodes across into
// the target node
if (node.namespaceURI === DOMNamespaces.svg && !('innerHTML' in node)) {
reusableSVGContainer = reusableSVGContainer || document.createElement('div');
reusableSVGContainer.innerHTML = '<svg>' + html + '</svg>';
var svgNode = reusableSVGContainer.firstChild;
while (svgNode.firstChild) {
node.appendChild(svgNode.firstChild);
}
} else {
node.innerHTML = html;
}
});
if (ExecutionEnvironment.canUseDOM) {
// IE8: When updating a just created node with innerHTML only leading
// whitespace is removed. When updating an existing node with innerHTML
// whitespace in root TextNodes is also collapsed.
// @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html
// Feature detection; only IE8 is known to behave improperly like this.
var testElement = document.createElement('div');
testElement.innerHTML = ' ';
if (testElement.innerHTML === '') {
setInnerHTML = function (node, html) {
// Magic theory: IE8 supposedly differentiates between added and updated
// nodes when processing innerHTML, innerHTML on updated nodes suffers
// from worse whitespace behavior. Re-adding a node like this triggers
// the initial and more favorable whitespace behavior.
// TODO: What to do on a detached node?
if (node.parentNode) {
node.parentNode.replaceChild(node, node);
}
// We also implement a workaround for non-visible tags disappearing into
// thin air on IE8, this only happens if there is no visible text
// in-front of the non-visible tags. Piggyback on the whitespace fix
// and simply check if any non-visible tags appear in the source.
if (WHITESPACE_TEST.test(html) || html[0] === '<' && NONVISIBLE_TEST.test(html)) {
// Recover leading whitespace by temporarily prepending any character.
// \uFEFF has the potential advantage of being zero-width/invisible.
// UglifyJS drops U+FEFF chars when parsing, so use String.fromCharCode
// in hopes that this is preserved even if "\uFEFF" is transformed to
// the actual Unicode character (by Babel, for example).
// https://github.com/mishoo/UglifyJS2/blob/v2.4.20/lib/parse.js#L216
node.innerHTML = String.fromCharCode(0xfeff) + html;
// deleteData leaves an empty `TextNode` which offsets the index of all
// children. Definitely want to avoid this.
var textNode = node.firstChild;
if (textNode.data.length === 1) {
node.removeChild(textNode);
} else {
textNode.deleteData(0, 1);
}
} else {
node.innerHTML = html;
}
};
}
testElement = null;
}
module.exports = setInnerHTML;
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*
*/
var canDefineProperty = false;
if (process.env.NODE_ENV !== 'production') {
try {
// $FlowFixMe https://github.com/facebook/flow/issues/285
Object.defineProperty({}, 'x', { get: function () {} });
canDefineProperty = true;
} catch (x) {
// IE will fail on defineProperty
}
}
module.exports = canDefineProperty;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, '__esModule', {
value: true
});
var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
var _stringHash = __webpack_require__(291);
var _stringHash2 = _interopRequireDefault(_stringHash);
/* ::
type Pair = [ string, any ];
type Pairs = Pair[];
type PairsMapper = (pair: Pair) => Pair;
type ObjectMap = { [id:string]: any };
*/
var mapObj = function mapObj(obj, /* : ObjectMap */
fn /* : PairsMapper */
) /* : ObjectMap */{
var keys = Object.keys(obj);
var mappedObj = {};
for (var i = 0; i < keys.length; i += 1) {
var _fn = fn([keys[i], obj[keys[i]]]);
var _fn2 = _slicedToArray(_fn, 2);
var newKey = _fn2[0];
var newValue = _fn2[1];
mappedObj[newKey] = newValue;
}
return mappedObj;
};
exports.mapObj = mapObj;
var UPPERCASE_RE = /([A-Z])/g;
var UPPERCASE_RE_TO_KEBAB = function UPPERCASE_RE_TO_KEBAB(match /* : string */) {
return (/* : string */'-' + match.toLowerCase()
);
};
var kebabifyStyleName = function kebabifyStyleName(string /* : string */) /* : string */{
var result = string.replace(UPPERCASE_RE, UPPERCASE_RE_TO_KEBAB);
if (result[0] === 'm' && result[1] === 's' && result[2] === '-') {
return '-' + result;
}
return result;
};
exports.kebabifyStyleName = kebabifyStyleName;
/**
* CSS properties which accept numbers but are not in units of "px".
* Taken from React's CSSProperty.js
*/
var isUnitlessNumber = {
animationIterationCount: true,
borderImageOutset: true,
borderImageSlice: true,
borderImageWidth: true,
boxFlex: true,
boxFlexGroup: true,
boxOrdinalGroup: true,
columnCount: true,
flex: true,
flexGrow: true,
flexPositive: true,
flexShrink: true,
flexNegative: true,
flexOrder: true,
gridRow: true,
gridColumn: true,
fontWeight: true,
lineClamp: true,
lineHeight: true,
opacity: true,
order: true,
orphans: true,
tabSize: true,
widows: true,
zIndex: true,
zoom: true,
// SVG-related properties
fillOpacity: true,
floodOpacity: true,
stopOpacity: true,
strokeDasharray: true,
strokeDashoffset: true,
strokeMiterlimit: true,
strokeOpacity: true,
strokeWidth: true
};
/**
* Taken from React's CSSProperty.js
*
* @param {string} prefix vendor-specific prefix, eg: Webkit
* @param {string} key style name, eg: transitionDuration
* @return {string} style name prefixed with `prefix`, properly camelCased, eg:
* WebkitTransitionDuration
*/
function prefixKey(prefix, key) {
return prefix + key.charAt(0).toUpperCase() + key.substring(1);
}
/**
* Support style names that may come passed in prefixed by adding permutations
* of vendor prefixes.
* Taken from React's CSSProperty.js
*/
var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
// infinite loop, because it iterates over the newly added props too.
// Taken from React's CSSProperty.js
Object.keys(isUnitlessNumber).forEach(function (prop) {
prefixes.forEach(function (prefix) {
isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
});
});
var stringifyValue = function stringifyValue(key, /* : string */
prop /* : any */
) /* : string */{
if (typeof prop === "number") {
if (isUnitlessNumber[key]) {
return "" + prop;
} else {
return prop + "px";
}
} else {
return '' + prop;
}
};
exports.stringifyValue = stringifyValue;
var stringifyAndImportantifyValue = function stringifyAndImportantifyValue(key, /* : string */
prop /* : any */
) {
return (/* : string */importantify(stringifyValue(key, prop))
);
};
exports.stringifyAndImportantifyValue = stringifyAndImportantifyValue;
// Turn a string into a hash string of base-36 values (using letters and numbers)
var hashString = function hashString(string /* : string */) {
return (/* string */(0, _stringHash2['default'])(string).toString(36)
);
};
exports.hashString = hashString;
// Hash a javascript object using JSON.stringify. This is very fast, about 3
// microseconds on my computer for a sample object:
// http://jsperf.com/test-hashfnv32a-hash/5
//
// Note that this uses JSON.stringify to stringify the objects so in order for
// this to produce consistent hashes browsers need to have a consistent
// ordering of objects. Ben Alpert says that Facebook depends on this, so we
// can probably depend on this too.
var hashObject = function hashObject(object /* : ObjectMap */) {
return (/* : string */hashString(JSON.stringify(object))
);
};
exports.hashObject = hashObject;
// Given a single style value string like the "b" from "a: b;", adds !important
// to generate "b !important".
var importantify = function importantify(string /* : string */) {
return (/* : string */
// Bracket string character access is very fast, and in the default case we
// normally don't expect there to be "!important" at the end of the string
// so we can use this simple check to take an optimized path. If there
// happens to be a "!" in this position, we follow up with a more thorough
// check.
string[string.length - 10] === '!' && string.slice(-11) === ' !important' ? string : string + ' !important'
);
};
/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @typechecks
*
*/
/*eslint-disable no-self-compare */
var hasOwnProperty = Object.prototype.hasOwnProperty;
/**
* inlined Object.is polyfill to avoid requiring consumers ship their own
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
*/
function is(x, y) {
// SameValue algorithm
if (x === y) {
// Steps 1-5, 7-10
// Steps 6.b-6.e: +0 != -0
// Added the nonzero y check to make Flow happy, but it is redundant
return x !== 0 || y !== 0 || 1 / x === 1 / y;
} else {
// Step 6.a: NaN == NaN
return x !== x && y !== y;
}
}
/**
* Performs equality by iterating through keys on an object and returning false
* when any key has values which are not strictly equal between the arguments.
* Returns true when the values of all keys are strictly equal.
*/
function shallowEqual(objA, objB) {
if (is(objA, objB)) {
return true;
}
if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
return false;
}
var keysA = Object.keys(objA);
var keysB = Object.keys(objB);
if (keysA.length !== keysB.length) {
return false;
}
// Test for A's keys different from B.
for (var i = 0; i < keysA.length; i++) {
if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
return false;
}
}
return true;
}
module.exports = shallowEqual;
/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var DOMLazyTree = __webpack_require__(18);
var Danger = __webpack_require__(210);
var ReactDOMComponentTree = __webpack_require__(6);
var ReactInstrumentation = __webpack_require__(9);
var createMicrosoftUnsafeLocalFunction = __webpack_require__(44);
var setInnerHTML = __webpack_require__(32);
var setTextContent = __webpack_require__(81);
function getNodeAfter(parentNode, node) {
// Special case for text components, which return [open, close] comments
// from getHostNode.
if (Array.isArray(node)) {
node = node[1];
}
return node ? node.nextSibling : parentNode.firstChild;
}
/**
* Inserts `childNode` as a child of `parentNode` at the `index`.
*
* @param {DOMElement} parentNode Parent node in which to insert.
* @param {DOMElement} childNode Child node to insert.
* @param {number} index Index at which to insert the child.
* @internal
*/
var insertChildAt = createMicrosoftUnsafeLocalFunction(function (parentNode, childNode, referenceNode) {
// We rely exclusively on `insertBefore(node, null)` instead of also using
// `appendChild(node)`. (Using `undefined` is not allowed by all browsers so
// we are careful to use `null`.)
parentNode.insertBefore(childNode, referenceNode);
});
function insertLazyTreeChildAt(parentNode, childTree, referenceNode) {
DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode);
}
function moveChild(parentNode, childNode, referenceNode) {
if (Array.isArray(childNode)) {
moveDelimitedText(parentNode, childNode[0], childNode[1], referenceNode);
} else {
insertChildAt(parentNode, childNode, referenceNode);
}
}
function removeChild(parentNode, childNode) {
if (Array.isArray(childNode)) {
var closingComment = childNode[1];
childNode = childNode[0];
removeDelimitedText(parentNode, childNode, closingComment);
parentNode.removeChild(closingComment);
}
parentNode.removeChild(childNode);
}
function moveDelimitedText(parentNode, openingComment, closingComment, referenceNode) {
var node = openingComment;
while (true) {
var nextNode = node.nextSibling;
insertChildAt(parentNode, node, referenceNode);
if (node === closingComment) {
break;
}
node = nextNode;
}
}
function removeDelimitedText(parentNode, startNode, closingComment) {
while (true) {
var node = startNode.nextSibling;
if (node === closingComment) {
// The closing comment is removed by ReactMultiChild.
break;
} else {
parentNode.removeChild(node);
}
}
}
function replaceDelimitedText(openingComment, closingComment, stringText) {
var parentNode = openingComment.parentNode;
var nodeAfterComment = openingComment.nextSibling;
if (nodeAfterComment === closingComment) {
// There are no text nodes between the opening and closing comments; insert
// a new one if stringText isn't empty.
if (stringText) {
insertChildAt(parentNode, document.createTextNode(stringText), nodeAfterComment);
}
} else {
if (stringText) {
// Set the text content of the first node after the opening comment, and
// remove all following nodes up until the closing comment.
setTextContent(nodeAfterComment, stringText);
removeDelimitedText(parentNode, nodeAfterComment, closingComment);
} else {
removeDelimitedText(parentNode, openingComment, closingComment);
}
}
if (process.env.NODE_ENV !== 'production') {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: ReactDOMComponentTree.getInstanceFromNode(openingComment)._debugID,
type: 'replace text',
payload: stringText
});
}
}
var dangerouslyReplaceNodeWithMarkup = Danger.dangerouslyReplaceNodeWithMarkup;
if (process.env.NODE_ENV !== 'production') {
dangerouslyReplaceNodeWithMarkup = function (oldChild, markup, prevInstance) {
Danger.dangerouslyReplaceNodeWithMarkup(oldChild, markup);
if (prevInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: prevInstance._debugID,
type: 'replace with',
payload: markup.toString()
});
} else {
var nextInstance = ReactDOMComponentTree.getInstanceFromNode(markup.node);
if (nextInstance._debugID !== 0) {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: nextInstance._debugID,
type: 'mount',
payload: markup.toString()
});
}
}
};
}
/**
* Operations for updating with DOM children.
*/
var DOMChildrenOperations = {
dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup,
replaceDelimitedText: replaceDelimitedText,
/**
* Updates a component's children by processing a series of updates. The
* update configurations are each expected to have a `parentNode` property.
*
* @param {array<object>} updates List of update configurations.
* @internal
*/
processUpdates: function (parentNode, updates) {
if (process.env.NODE_ENV !== 'production') {
var parentNodeDebugID = ReactDOMComponentTree.getInstanceFromNode(parentNode)._debugID;
}
for (var k = 0; k < updates.length; k++) {
var update = updates[k];
switch (update.type) {
case 'INSERT_MARKUP':
insertLazyTreeChildAt(parentNode, update.content, getNodeAfter(parentNode, update.afterNode));
if (process.env.NODE_ENV !== 'production') {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: parentNodeDebugID,
type: 'insert child',
payload: {
toIndex: update.toIndex,
content: update.content.toString()
}
});
}
break;
case 'MOVE_EXISTING':
moveChild(parentNode, update.fromNode, getNodeAfter(parentNode, update.afterNode));
if (process.env.NODE_ENV !== 'production') {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: parentNodeDebugID,
type: 'move child',
payload: { fromIndex: update.fromIndex, toIndex: update.toIndex }
});
}
break;
case 'SET_MARKUP':
setInnerHTML(parentNode, update.content);
if (process.env.NODE_ENV !== 'production') {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: parentNodeDebugID,
type: 'replace children',
payload: update.content.toString()
});
}
break;
case 'TEXT_CONTENT':
setTextContent(parentNode, update.content);
if (process.env.NODE_ENV !== 'production') {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: parentNodeDebugID,
type: 'replace text',
payload: update.content.toString()
});
}
break;
case 'REMOVE_NODE':
removeChild(parentNode, update.fromNode);
if (process.env.NODE_ENV !== 'production') {
ReactInstrumentation.debugTool.onHostOperation({
instanceID: parentNodeDebugID,
type: 'remove child',
payload: { fromIndex: update.fromIndex }
});
}
break;
}
}
}
};
module.exports = DOMChildrenOperations;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var DOMNamespaces = {
html: 'http://www.w3.org/1999/xhtml',
mathml: 'http://www.w3.org/1998/Math/MathML',
svg: 'http://www.w3.org/2000/svg'
};
module.exports = DOMNamespaces;
/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {/**
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
var _prodInvariant = __webpack_require__(4);
var ReactErrorUtils = __webpack_require__(42);
var invariant = __webpack_require__(2);
var warning = __webpack_require__(3);
/**
* Injected dependencies:
*/
/**
* - `ComponentTree`: [required] Module that can convert between React instances
* and actual node references.
*/
var ComponentTree;
var TreeTraversal;
var injection = {
injectComponentTree: function (Injected) {
ComponentTree = Injected;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.') : void 0;
}
},
injectTreeTraversal: function (Injected) {
TreeTraversal = Injected;
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.isAncestor && Injected.getLowestCommonAncestor, 'EventPluginUtils.injection.injectTreeTraversal(...): Injected ' + 'module is missing isAncestor or getLowestCommonAncestor.') : void 0;
}
}
};
function isEndish(topLevelType) {
return topLevelType === 'topMouseUp' || topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';
}
function isMoveish(topLevelType) {
return topLevelType === 'topMouseMove' || topLevelType === 'topTouchMove';
}
function isStartish(topLevelType) {
return topLevelType === 'topMouseDown' || topLevelType === 'topTouchStart';
}
var validateEventDispatches;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches = function (event) {
var dispatchListeners = event._dispatchListeners;
var dispatchInstances = event._dispatchInstances;
var listenersIsArr = Array.isArray(dispatchListeners);
var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
var instancesIsArr = Array.isArray(dispatchInstances);
var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
process.env.NODE_ENV !== 'production' ? warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : void 0;
};
}
/**
* Dispatch the event to the listener.
* @param {SyntheticEvent} event SyntheticEvent to handle
* @param {boolean} simulated If the event is simulated (changes exn behavior)
* @param {function} listener Application-level callback
* @param {*} inst Internal component instance
*/
function executeDispatch(event, simulated, listener, inst) {
var type = event.type || 'unknown-event';
event.currentTarget = EventPluginUtils.getNodeFromInstance(inst);
if (simulated) {
ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event);
} else {
ReactErrorUtils.invokeGuardedCallback(type, listener, event);
}
event.currentTarget = null;
}
/**
* Standard/simple iteration through an event's collected dispatches.
*/
function executeDispatchesInOrder(event, simulated) {
var dispatchListeners = event._dispatchListeners;
var dispatchInstances = event._dispatchInstances;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
if (Array.isArray(dispatchListeners)) {
for (var i = 0; i < dispatchListeners.length; i++) {
if (event.isPropagationStopped()) {
break;
}
// Listeners and Instances are two parallel arrays that are always in sync.
executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);
}
} else if (dispatchListeners) {
executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
}
event._dispatchListeners = null;
event._dispatchInstances = null;
}
/**
* Standard/simple iteration through an event's collected dispatches, but stops
* at the first dispatch execution returning true, and returns that id.
*
* @return {?string} id of the first dispatch execution who's listener returns
* true, or null if no listener returned true.
*/
function executeDispatchesInOrderStopAtTrueImpl(event) {
var dispatchListeners = event._dispatchListeners;
var dispatchInstances = event._dispatchInstances;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
if (Array.isArray(dispatchListeners)) {
for (var i = 0; i < dispatchListeners.length; i++) {
if (event.isPropagationStopped()) {
break;
}
// Listeners and Instances are two parallel arrays that are always in sync.
if (dispatchListeners[i](event, dispatchInstances[i])) {
return dispatchInstances[i];
}
}
} else if (dispatchListeners) {
if (dispatchListeners(event, dispatchInstances)) {
return dispatchInstances;
}
}
return null;
}
/**
* @see executeDispatchesInOrderStopAtTrueImpl
*/
function executeDispatchesInOrderStopAtTrue(event) {
var ret = executeDispatchesInOrderStopAtTrueImpl(event);
event._dispatchInstances = null;
event._dispatchListeners = null;
return ret;
}
/**
* Execution of a "direct" dispatch - there must be at most one dispatch
* accumulated on the event or it is considered an error. It doesn't really make
* sense for an event with multiple dispatches (bubbled) to keep track of the
* return values at each dispatch execution, but it does tend to make sense when
* dealing with "direct" dispatches.
*
* @return {*} The return value of executing the single dispatch.
*/
function executeDirectDispatch(event) {
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
var dispatchListener = event._dispatchListeners;
var dispatchInstance = event._dispatchInstances;
!!Array.isArray(dispatchListener) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : _prodInvariant('103') : void 0;
event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
var res = dispatchListener ? dispatchListener(event) : null;
event.currentTarget = null;
event._dispatchListeners = null;
event._dispatchInstances = null;
return res;
}
/**
* @param {SyntheticEvent} event
* @return {boolean} True iff number of dispatches accumulated is greater than 0.
*/
function hasDispatches(event) {
return !!event._dispatchListeners;
}
/**
* General utilities that are useful in creating custom Event Plugins.
*/
var EventPluginUtils = {
isEndish: isEndish,
isMoveish: isMoveish,
isStartish: isStartish,
executeDirectDispatch: executeDirectDispatch,
executeDispatchesInOrder: executeDispatchesInOrder,
executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
hasDispatches: hasDispatches,
getInstanceFromNode: function (node) {
return ComponentTree.getInstanceFromNode(node);
},
getNodeFromInstance: function (node) {
return ComponentTree.getNodeFromInstance(node);
},
isAncestor: function (a, b) {
return TreeTraversal.isAncestor(a, b);
},
getLowestCommonAncestor: function (a, b) {
return TreeTraversal.getLowestCommonAncestor(a, b);
},
getParentInstance: function (inst) {
return TreeTraversal.getParentInstance(inst);
},
traverseTwoPhase: function (target, fn, arg) {
return TreeTraversal.traverseTwoPhase(target, fn, arg);
},
traverseEnterLeave: function (from, to, fn, argFrom, argTo) {
return TreeTraversal.traverseEnterLeave(from, to, fn, argFrom, argTo);
},
injection: injection
};
module.exports = EventPluginUtils;
/* WEBPACK VAR INJECTION */}.call(exports, _
gitextract_x65iedph/ ├── .babelrc ├── .gitignore ├── .npmignore ├── LICENSE ├── README.md ├── dev/ │ ├── App.js │ ├── index.html │ ├── index.js │ ├── server.js │ └── webpack-dev-server.config.js ├── examples/ │ ├── App.js │ ├── dist/ │ │ ├── app.js │ │ └── index.html │ ├── index.html │ ├── index.js │ ├── server.js │ └── webpack-examples-server.config.js ├── lib/ │ ├── bling/ │ │ ├── puffIn.js │ │ ├── puffOut.js │ │ ├── vanishIn.js │ │ └── vanishOut.js │ ├── boing/ │ │ ├── boingInUp.js │ │ └── boingOutDown.js │ ├── bomb/ │ │ ├── bombLeftOut.js │ │ └── bombRightOut.js │ ├── index.js │ ├── magic/ │ │ ├── magic.js │ │ ├── swap.js │ │ ├── twisterInDown.js │ │ └── twisterInUp.js │ ├── math/ │ │ ├── foolishIn.js │ │ ├── foolishOut.js │ │ ├── holeIn.js │ │ ├── holeOut.js │ │ ├── swashIn.js │ │ └── swashOut.js │ ├── perspective/ │ │ ├── perspectiveDown.js │ │ ├── perspectiveDownReturn.js │ │ ├── perspectiveLeft.js │ │ ├── perspectiveLeftReturn.js │ │ ├── perspectiveRight.js │ │ ├── perspectiveRightReturn.js │ │ ├── perspectiveUp.js │ │ └── perspectiveUpReturn.js │ ├── rotate/ │ │ ├── rotateDownIn.js │ │ ├── rotateDownOut.js │ │ ├── rotateLeftIn.js │ │ ├── rotateLeftOut.js │ │ ├── rotateRightIn.js │ │ ├── rotateRightOut.js │ │ ├── rotateUpIn.js │ │ └── rotateUpOut.js │ ├── slide/ │ │ ├── slideDown.js │ │ ├── slideDownReturn.js │ │ ├── slideLeft.js │ │ ├── slideLeftReturn.js │ │ ├── slideRight.js │ │ ├── slideRightReturn.js │ │ ├── slideUp.js │ │ └── slideUpReturn.js │ ├── space/ │ │ ├── spaceInDown.js │ │ ├── spaceInLeft.js │ │ ├── spaceInRight.js │ │ ├── spaceInUp.js │ │ ├── spaceOutDown.js │ │ ├── spaceOutLeft.js │ │ ├── spaceOutRight.js │ │ └── spaceOutUp.js │ ├── staticEffects/ │ │ ├── openDownLeft.js │ │ ├── openDownLeftReturn.js │ │ ├── openDownRight.js │ │ ├── openDownRightReturn.js │ │ ├── openUpLeft.js │ │ ├── openUpLeftReturn.js │ │ ├── openUpRight.js │ │ └── openUpRightReturn.js │ ├── staticEffectsOut/ │ │ ├── openDownLeftOut.js │ │ ├── openDownRightOut.js │ │ ├── openUpLeftOut.js │ │ └── openUpRightOut.js │ ├── tin/ │ │ ├── tinDownIn.js │ │ ├── tinDownOut.js │ │ ├── tinLeftIn.js │ │ ├── tinLeftOut.js │ │ ├── tinRightIn.js │ │ ├── tinRightOut.js │ │ ├── tinUpIn.js │ │ └── tinUpOut.js │ └── utils/ │ ├── types.js │ └── utils.js ├── package.json ├── src/ │ ├── bling/ │ │ ├── puffIn.js │ │ ├── puffOut.js │ │ ├── vanishIn.js │ │ └── vanishOut.js │ ├── boing/ │ │ ├── boingInUp.js │ │ └── boingOutDown.js │ ├── bomb/ │ │ ├── bombLeftOut.js │ │ └── bombRightOut.js │ ├── index.js │ ├── magic/ │ │ ├── magic.js │ │ ├── swap.js │ │ ├── twisterInDown.js │ │ └── twisterInUp.js │ ├── math/ │ │ ├── foolishIn.js │ │ ├── foolishOut.js │ │ ├── holeIn.js │ │ ├── holeOut.js │ │ ├── swashIn.js │ │ └── swashOut.js │ ├── perspective/ │ │ ├── perspectiveDown.js │ │ ├── perspectiveDownReturn.js │ │ ├── perspectiveLeft.js │ │ ├── perspectiveLeftReturn.js │ │ ├── perspectiveRight.js │ │ ├── perspectiveRightReturn.js │ │ ├── perspectiveUp.js │ │ └── perspectiveUpReturn.js │ ├── rotate/ │ │ ├── rotateDownIn.js │ │ ├── rotateDownOut.js │ │ ├── rotateLeftIn.js │ │ ├── rotateLeftOut.js │ │ ├── rotateRightIn.js │ │ ├── rotateRightOut.js │ │ ├── rotateUpIn.js │ │ └── rotateUpOut.js │ ├── slide/ │ │ ├── slideDown.js │ │ ├── slideDownReturn.js │ │ ├── slideLeft.js │ │ ├── slideLeftReturn.js │ │ ├── slideRight.js │ │ ├── slideRightReturn.js │ │ ├── slideUp.js │ │ └── slideUpReturn.js │ ├── space/ │ │ ├── spaceInDown.js │ │ ├── spaceInLeft.js │ │ ├── spaceInRight.js │ │ ├── spaceInUp.js │ │ ├── spaceOutDown.js │ │ ├── spaceOutLeft.js │ │ ├── spaceOutRight.js │ │ └── spaceOutUp.js │ ├── staticEffects/ │ │ ├── openDownLeft.js │ │ ├── openDownLeftReturn.js │ │ ├── openDownRight.js │ │ ├── openDownRightReturn.js │ │ ├── openUpLeft.js │ │ ├── openUpLeftReturn.js │ │ ├── openUpRight.js │ │ └── openUpRightReturn.js │ ├── staticEffectsOut/ │ │ ├── openDownLeftOut.js │ │ ├── openDownRightOut.js │ │ ├── openUpLeftOut.js │ │ └── openUpRightOut.js │ ├── tin/ │ │ ├── tinDownIn.js │ │ ├── tinDownOut.js │ │ ├── tinLeftIn.js │ │ ├── tinLeftOut.js │ │ ├── tinRightIn.js │ │ ├── tinRightOut.js │ │ ├── tinUpIn.js │ │ └── tinUpOut.js │ └── utils/ │ ├── types.js │ └── utils.js └── webpack-production.config.js
SYMBOL INDEX (441 symbols across 5 files)
FILE: dev/App.js
class App (line 33) | class App extends Component {
method constructor (line 34) | constructor(props, context) {
method render (line 41) | render() {
FILE: examples/App.js
class App (line 97) | class App extends Component {
method constructor (line 98) | constructor(props, context) {
method handleBtnClick (line 106) | handleBtnClick(e) {
method render (line 128) | render() {
FILE: examples/dist/app.js
function __webpack_require__ (line 6) | function __webpack_require__(moduleId) {
function defaultSetTimout (line 84) | function defaultSetTimout() {
function defaultClearTimeout (line 87) | function defaultClearTimeout () {
function runTimeout (line 110) | function runTimeout(fun) {
function runClearTimeout (line 135) | function runClearTimeout(marker) {
function cleanUpNextTick (line 167) | function cleanUpNextTick() {
function drainQueue (line 182) | function drainQueue() {
function Item (line 220) | function Item(fun, array) {
function noop (line 234) | function noop() {}
function _toConsumableArray (line 270) | function _toConsumableArray(arr) {
function invariant (line 411) | function invariant(condition, format, a, b, c, d, e, f) {
function reactProdInvariant (line 526) | function reactProdInvariant(code) {
function toObject (line 563) | function toObject(val) {
function shouldUseNative (line 571) | function shouldUseNative() {
function shouldPrecacheNode (line 673) | function shouldPrecacheNode(node, nodeID) {
function getRenderedHostOrTextFromComponent (line 684) | function getRenderedHostOrTextFromComponent(component) {
function precacheNode (line 696) | function precacheNode(inst, node) {
function uncacheNode (line 702) | function uncacheNode(inst) {
function precacheChildNodes (line 724) | function precacheChildNodes(inst, node) {
function getClosestInstanceFromNode (line 757) | function getClosestInstanceFromNode(node) {
function getInstanceFromNode (line 791) | function getInstanceFromNode(node) {
function getNodeFromInstance (line 804) | function getNodeFromInstance(inst) {
function isNative (line 904) | function isNative(fn) {
function purgeDeep (line 1013) | function purgeDeep(id) {
function describeComponentFrame (line 1023) | function describeComponentFrame(name, source, ownerName) {
function getDisplayName (line 1027) | function getDisplayName(element) {
function describeID (line 1039) | function describeID(id) {
function makeEmptyFunction (line 1308) | function makeEmptyFunction(arg) {
function ensureInjected (line 1367) | function ensureInjected() {
function ReactUpdatesFlushTransaction (line 1401) | function ReactUpdatesFlushTransaction() {
function batchedUpdates (line 1431) | function batchedUpdates(callback, a, b, c, d, e) {
function mountOrderComparator (line 1443) | function mountOrderComparator(c1, c2) {
function runBatchedUpdates (line 1447) | function runBatchedUpdates(transaction) {
function enqueueUpdate (line 1526) | function enqueueUpdate(component) {
function asap (line 1550) | function asap(callback, context) {
function SyntheticEvent (line 1685) | function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeE...
function getPooledWarningPropertyDefinition (line 1868) | function getPooledWarningPropertyDefinition(propName, getVal) {
function checkMask (line 1915) | function checkMask(value, bitmask) {
function hasValidRef (line 2259) | function hasValidRef(config) {
function hasValidKey (line 2271) | function hasValidKey(config) {
function defineKeyPropWarningGetter (line 2283) | function defineKeyPropWarningGetter(props, displayName) {
function defineRefPropWarningGetter (line 2297) | function defineRefPropWarningGetter(props, displayName) {
function isPrefixedValue (line 2583) | function isPrefixedValue(value) {
function insertTreeChildren (line 2625) | function insertTreeChildren(tree) {
function replaceChildWithTree (line 2658) | function replaceChildWithTree(oldNode, newTree) {
function queueChild (line 2663) | function queueChild(parentTree, childTree) {
function queueHTML (line 2671) | function queueHTML(tree, html) {
function queueText (line 2679) | function queueText(tree, text) {
function toString (line 2687) | function toString() {
function DOMLazyTree (line 2691) | function DOMLazyTree(node) {
function attachRefs (line 2733) | function attachRefs() {
function reactProdInvariant (line 3037) | function reactProdInvariant(code) {
function isInteractive (line 3122) | function isInteractive(tag) {
function shouldPreventMouseEvent (line 3126) | function shouldPreventMouseEvent(name, type, props) {
function listenerAtPhase (line 3363) | function listenerAtPhase(inst, event, propagationPhase) {
function accumulateDirectionalDispatches (line 3374) | function accumulateDirectionalDispatches(inst, phase, event) {
function accumulateTwoPhaseDispatchesSingle (line 3392) | function accumulateTwoPhaseDispatchesSingle(event) {
function accumulateTwoPhaseDispatchesSingleSkipTarget (line 3401) | function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
function accumulateDispatches (line 3414) | function accumulateDispatches(inst, ignoredDirection, event) {
function accumulateDirectDispatchesSingle (line 3430) | function accumulateDirectDispatchesSingle(event) {
function accumulateTwoPhaseDispatches (line 3436) | function accumulateTwoPhaseDispatches(events) {
function accumulateTwoPhaseDispatchesSkipTarget (line 3440) | function accumulateTwoPhaseDispatchesSkipTarget(events) {
function accumulateEnterLeaveDispatches (line 3444) | function accumulateEnterLeaveDispatches(leave, enter, from, to) {
function accumulateDirectDispatches (line 3448) | function accumulateDirectDispatches(events) {
function SyntheticUIEvent (line 3576) | function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, n...
function recomputePluginOrdering (line 3643) | function recomputePluginOrdering() {
function publishEventForPlugin (line 3672) | function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
function publishRegistrationName (line 3700) | function publishRegistrationName(registrationName, pluginModule, eventNa...
function getListeningForDocument (line 4024) | function getListeningForDocument(mountAt) {
function SyntheticMouseEvent (line 4259) | function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent...
function escapeHtml (line 4555) | function escapeHtml(string) {
function escapeTextContentForBrowser (line 4612) | function escapeTextContentForBrowser(text) {
function sliceIterator (line 4766) | function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = ...
function _interopRequireDefault (line 4768) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function prefixKey (line 4866) | function prefixKey(prefix, key) {
function is (line 4968) | function is(x, y) {
function shallowEqual (line 4986) | function shallowEqual(objA, objB) {
function getNodeAfter (line 5038) | function getNodeAfter(parentNode, node) {
function insertLazyTreeChildAt (line 5062) | function insertLazyTreeChildAt(parentNode, childTree, referenceNode) {
function moveChild (line 5066) | function moveChild(parentNode, childNode, referenceNode) {
function removeChild (line 5074) | function removeChild(parentNode, childNode) {
function moveDelimitedText (line 5084) | function moveDelimitedText(parentNode, openingComment, closingComment, r...
function removeDelimitedText (line 5096) | function removeDelimitedText(parentNode, startNode, closingComment) {
function replaceDelimitedText (line 5108) | function replaceDelimitedText(openingComment, closingComment, stringText) {
function isEndish (line 5314) | function isEndish(topLevelType) {
function isMoveish (line 5318) | function isMoveish(topLevelType) {
function isStartish (line 5321) | function isStartish(topLevelType) {
function executeDispatch (line 5348) | function executeDispatch(event, simulated, listener, inst) {
function executeDispatchesInOrder (line 5362) | function executeDispatchesInOrder(event, simulated) {
function executeDispatchesInOrderStopAtTrueImpl (line 5390) | function executeDispatchesInOrderStopAtTrueImpl(event) {
function executeDispatchesInOrderStopAtTrue (line 5417) | function executeDispatchesInOrderStopAtTrue(event) {
function executeDirectDispatch (line 5433) | function executeDirectDispatch(event) {
function hasDispatches (line 5452) | function hasDispatches(event) {
function escape (line 5520) | function escape(key) {
function unescape (line 5539) | function unescape(key) {
function _assertSingleLink (line 5595) | function _assertSingleLink(inputProps) {
function _assertValueLink (line 5598) | function _assertValueLink(inputProps) {
function _assertCheckedLink (line 5603) | function _assertCheckedLink(inputProps) {
function getDeclarationErrorAddendum (line 5625) | function getDeclarationErrorAddendum(owner) {
function invokeGuardedCallback (line 5775) | function invokeGuardedCallback(name, func, a) {
function enqueueUpdate (line 5856) | function enqueueUpdate(internalInstance) {
function formatUnexpectedArgument (line 5860) | function formatUnexpectedArgument(arg) {
function getInternalInstanceReadyForUpdate (line 5873) | function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
function getEventCharCode (line 6130) | function getEventCharCode(nativeEvent) {
function modifierStateGetter (line 6187) | function modifierStateGetter(keyArg) {
function getEventModifierState (line 6197) | function getEventModifierState(nativeEvent) {
function getEventTarget (line 6226) | function getEventTarget(nativeEvent) {
function isEventSupported (line 6280) | function isEventSupported(eventNameSuffix, capture) {
function shouldUpdateReactComponent (line 6331) | function shouldUpdateReactComponent(prevElement, nextElement) {
function _interopRequireDefault (line 6816) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function defineProperties (line 7172) | function defineProperties(target, props) { for (var i = 0; i < props.len...
function _classCallCheck (line 7174) | function _classCallCheck(instance, Constructor) { if (!(instance instanc...
function OrderedElements (line 7184) | function OrderedElements() {
function focusNode (line 7382) | function focusNode(node) {
function getActiveElement (line 7421) | function getActiveElement(doc) /*?DOMElement*/{
function capitalizeString (line 7446) | function capitalizeString(str) {
function prefixKey (line 7567) | function prefixKey(prefix, key) {
function _classCallCheck (line 7672) | function _classCallCheck(instance, Constructor) { if (!(instance instanc...
function CallbackQueue (line 7691) | function CallbackQueue(arg) {
function isAttributeNameSafe (line 7803) | function isAttributeNameSafe(attributeName) {
function shouldIgnoreValue (line 7819) | function shouldIgnoreValue(propertyInfo, value) {
function updateOptionsIfPendingUpdateAndMounted (line 8063) | function updateOptionsIfPendingUpdateAndMounted() {
function getDeclarationErrorAddendum (line 8076) | function getDeclarationErrorAddendum(owner) {
function checkSelectPropTypes (line 8092) | function checkSelectPropTypes(inst, props) {
function updateOptions (line 8121) | function updateOptions(inst, multiple, propValue) {
function _handleChange (line 8227) | function _handleChange(event) {
function createInternalComponent (line 8340) | function createInternalComponent(element) {
function createInstanceForText (line 8349) | function createInstanceForText(text) {
function isTextComponent (line 8357) | function isTextComponent(component) {
function isInDocument (line 8392) | function isInDocument(node) {
function firstDifferenceIndex (line 8552) | function firstDifferenceIndex(string1, string2) {
function getReactRootElementInContainer (line 8567) | function getReactRootElementInContainer(container) {
function internalGetID (line 8579) | function internalGetID(node) {
function mountComponentIntoNode (line 8594) | function mountComponentIntoNode(wrapperInstance, container, transaction,...
function batchedMountComponentIntoNode (line 8621) | function batchedMountComponentIntoNode(componentInstance, container, sho...
function unmountComponentFromNode (line 8638) | function unmountComponentFromNode(instance, container, safely) {
function hasNonRootReactChild (line 8667) | function hasNonRootReactChild(container) {
function nodeIsRenderedByOtherInstance (line 8683) | function nodeIsRenderedByOtherInstance(container) {
function isValidContainer (line 8695) | function isValidContainer(node) {
function isReactNode (line 8706) | function isReactNode(node) {
function getHostRootInstanceInContainer (line 8710) | function getHostRootInstanceInContainer(container) {
function getTopLevelWrapperInContainer (line 8716) | function getTopLevelWrapperInContainer(container) {
function accumulateInto (line 9164) | function accumulateInto(current, next) {
function forEachAccumulated (line 9217) | function forEachAccumulated(arr, cb, scope) {
function getHostComponentFromComposite (line 9244) | function getHostComponentFromComposite(inst) {
function getTextContentAccessor (line 9285) | function getTextContentAccessor() {
function isCheckable (line 9313) | function isCheckable(elem) {
function getTracker (line 9319) | function getTracker(inst) {
function attachTracker (line 9323) | function attachTracker(inst, tracker) {
function detachTracker (line 9327) | function detachTracker(inst) {
function getValueFromNode (line 9331) | function getValueFromNode(node) {
function getDeclarationErrorAddendum (line 9453) | function getDeclarationErrorAddendum(owner) {
function isInternalComponentType (line 9470) | function isInternalComponentType(type) {
function instantiateReactComponent (line 9482) | function instantiateReactComponent(node, shouldHaveDebugID) {
function isTextInputElement (line 9593) | function isTextInputElement(elem) {
function getComponentKey (line 9712) | function getComponentKey(component, index) {
function traverseAllChildrenImpl (line 9731) | function traverseAllChildrenImpl(children, nameSoFar, callback, traverse...
function traverseAllChildren (line 9833) | function traverseAllChildren(children, callback, traverseContext) {
function ReactComponent (line 9872) | function ReactComponent(props, context, updater) {
function ReactPureComponent (line 9967) | function ReactPureComponent(props, context, updater) {
function ComponentDummy (line 9977) | function ComponentDummy() {}
function getDeclarationErrorAddendum (line 10047) | function getDeclarationErrorAddendum() {
function getSourceInfoErrorAddendum (line 10057) | function getSourceInfoErrorAddendum(elementProps) {
function getCurrentComponentErrorInfo (line 10074) | function getCurrentComponentErrorInfo(parentType) {
function validateExplicitKey (line 10097) | function validateExplicitKey(element, parentType) {
function validateChildKeys (line 10132) | function validateChildKeys(node, parentType) {
function validatePropTypes (line 10171) | function validatePropTypes(element) {
function warnNoop (line 10290) | function warnNoop(publicInstance, callerName) {
function getIteratorFn (line 10407) | function getIteratorFn(maybeIterable) {
function defineProperties (line 10427) | function defineProperties(target, props) { for (var i = 0; i < props.len...
function _interopRequireWildcard (line 10439) | function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { ret...
function _interopRequireDefault (line 10441) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function _classCallCheck (line 10443) | function _classCallCheck(instance, Constructor) { if (!(instance instanc...
function _possibleConstructorReturn (line 10445) | function _possibleConstructorReturn(self, call) { if (!self) { throw new...
function _inherits (line 10447) | function _inherits(subClass, superClass) { if (typeof superClass !== "fu...
function App (line 10518) | function App(props, context) {
function sliceIterator (line 10807) | function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = ...
function _interopRequireDefault (line 10969) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function _interopRequireDefault (line 11287) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function throwFirstError (line 11344) | function throwFirstError() {
function asap (line 11359) | function asap(task) {
function RawTask (line 11372) | function RawTask() {
function rawAsap (line 11419) | function rawAsap(task) {
function flush (line 11451) | function flush() {
function makeRequestCallFromMutationObserver (line 11545) | function makeRequestCallFromMutationObserver(callback) {
function makeRequestCallFromTimer (line 11596) | function makeRequestCallFromTimer(callback) {
function _interopRequireDefault (line 11651) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function _interopRequireDefault (line 12213) | function _interopRequireDefault(obj) {
function identity (line 14194) | function identity(fn) {
function factory (line 14209) | function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {
function _interopRequireDefault (line 15116) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function hyphenateProperty (line 15118) | function hyphenateProperty(property) {
function camelize (line 15150) | function camelize(string) {
function camelizeStyleName (line 15195) | function camelizeStyleName(string) {
function containsNode (line 15224) | function containsNode(outerNode, innerNode) {
function toArray (line 15271) | function toArray(obj) {
function hasArrayNature (line 15319) | function hasArrayNature(obj) {
function createArrayFromMixed (line 15362) | function createArrayFromMixed(obj) {
function getNodeName (line 15415) | function getNodeName(markup) {
function createNodesFromMarkup (line 15430) | function createNodesFromMarkup(markup, handleScript) {
function getMarkupWrap (line 15543) | function getMarkupWrap(nodeName) {
function getUnboundedScrollPosition (line 15589) | function getUnboundedScrollPosition(scrollable) {
function hyphenate (line 15634) | function hyphenate(string) {
function hyphenateStyleName (line 15676) | function hyphenateStyleName(string) {
function isNode (line 15702) | function isNode(object) {
function isTextNode (line 15732) | function isTextNode(object) {
function memoizeStringOnly (line 15759) | function memoizeStringOnly(callback) {
function toHyphenLower (line 15845) | function toHyphenLower(match) {
function hyphenateStyleName (line 15849) | function hyphenateStyleName(name) {
function _interopRequireDefault (line 15889) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function createPrefixer (line 15891) | function createPrefixer(_ref) {
function _interopRequireDefault (line 15952) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function calc (line 15955) | function calc(property, value) {
function _interopRequireDefault (line 15980) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function crossFade (line 15984) | function crossFade(property, value) {
function cursor (line 16013) | function cursor(property, value) {
function _interopRequireDefault (line 16038) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function filter (line 16042) | function filter(property, value) {
function flex (line 16067) | function flex(property, value) {
function flexboxIE (line 16102) | function flexboxIE(property, value, style) {
function flexboxOld (line 16135) | function flexboxOld(property, value, style) {
function _interopRequireDefault (line 16170) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function gradient (line 16176) | function gradient(property, value) {
function _interopRequireDefault (line 16201) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function imageSet (line 16205) | function imageSet(property, value) {
function position (line 16225) | function position(property, value) {
function sizing (line 16262) | function sizing(property, value) {
function _interopRequireDefault (line 16295) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function prefixValue (line 16313) | function prefixValue(value, propertyPrefixMap) {
function transition (line 16342) | function transition(property, value, style, propertyPrefixMap) {
function addIfNew (line 16381) | function addIfNew(list, value) {
function addNewValuesOnly (line 16387) | function addNewValuesOnly(list, values) {
function isObject (line 16409) | function isObject(value) {
function _interopRequireDefault (line 16430) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
function prefixProperty (line 16432) | function prefixProperty(prefixProperties, property, style) {
function prefixValue (line 16453) | function prefixValue(plugins, property, value, style, metaData) {
function checkPropTypes (line 16512) | function checkPropTypes(typeSpecs, values, location, componentName, getS...
function emptyFunctionThatReturnsNull (line 16614) | function emptyFunctionThatReturnsNull() {
function getIteratorFn (line 16637) | function getIteratorFn(maybeIterable) {
function is (line 16722) | function is(x, y) {
function PropTypeError (line 16742) | function PropTypeError(message) {
function createChainableTypeChecker (line 16749) | function createChainableTypeChecker(validate) {
function createPrimitiveTypeChecker (line 16807) | function createPrimitiveTypeChecker(expectedType) {
function createAnyTypeChecker (line 16824) | function createAnyTypeChecker() {
function createArrayOfTypeChecker (line 16828) | function createArrayOfTypeChecker(typeChecker) {
function createElementTypeChecker (line 16849) | function createElementTypeChecker() {
function createElementTypeTypeChecker (line 16861) | function createElementTypeTypeChecker() {
function createInstanceTypeChecker (line 16873) | function createInstanceTypeChecker(expectedClass) {
function createEnumTypeChecker (line 16885) | function createEnumTypeChecker(expectedValues) {
function createObjectOfTypeChecker (line 16920) | function createObjectOfTypeChecker(typeChecker) {
function createUnionTypeChecker (line 16943) | function createUnionTypeChecker(arrayOfTypeCheckers) {
function createNodeChecker (line 16973) | function createNodeChecker() {
function createShapeTypeChecker (line 16983) | function createShapeTypeChecker(shapeTypes) {
function createStrictShapeTypeChecker (line 17005) | function createStrictShapeTypeChecker(shapeTypes) {
function isNode (line 17035) | function isNode(propValue) {
function isSymbol (line 17082) | function isSymbol(propType, propValue) {
function getPropType (line 17107) | function getPropType(propValue) {
function getPreciseType (line 17126) | function getPreciseType(propValue) {
function getPostfixForTypeWarning (line 17143) | function getPostfixForTypeWarning(value) {
function getClassName (line 17159) | function getClassName(propValue) {
function isPresto (line 17324) | function isPresto() {
function isKeypressCommand (line 17372) | function isKeypressCommand(nativeEvent) {
function getCompositionEventType (line 17384) | function getCompositionEventType(topLevelType) {
function isFallbackCompositionStart (line 17403) | function isFallbackCompositionStart(topLevelType, nativeEvent) {
function isFallbackCompositionEnd (line 17414) | function isFallbackCompositionEnd(topLevelType, nativeEvent) {
function getDataFromCustomEvent (line 17442) | function getDataFromCustomEvent(nativeEvent) {
function extractCompositionEvent (line 17456) | function extractCompositionEvent(topLevelType, targetInst, nativeEvent, ...
function getNativeBeforeInputChars (line 17508) | function getNativeBeforeInputChars(topLevelType, nativeEvent) {
function getFallbackBeforeInputChars (line 17562) | function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
function extractBeforeInputEvent (line 17616) | function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, ...
function createAndAccumulateChangeEvent (line 17922) | function createAndAccumulateChangeEvent(inst, nativeEvent, target) {
function shouldUseChangeEvent (line 17937) | function shouldUseChangeEvent(elem) {
function manualDispatchChangeEvent (line 17948) | function manualDispatchChangeEvent(nativeEvent) {
function runEventInBatch (line 17965) | function runEventInBatch(event) {
function startWatchingForChangeEventIE8 (line 17970) | function startWatchingForChangeEventIE8(target, targetInst) {
function stopWatchingForChangeEventIE8 (line 17976) | function stopWatchingForChangeEventIE8() {
function getInstIfValueChanged (line 17985) | function getInstIfValueChanged(targetInst, nativeEvent) {
function getTargetInstForChangeEvent (line 17994) | function getTargetInstForChangeEvent(topLevelType, targetInst) {
function handleEventsForChangeEventIE8 (line 18000) | function handleEventsForChangeEventIE8(topLevelType, target, targetInst) {
function startWatchingForValueChange (line 18027) | function startWatchingForValueChange(target, targetInst) {
function stopWatchingForValueChange (line 18037) | function stopWatchingForValueChange() {
function handlePropertyChange (line 18051) | function handlePropertyChange(nativeEvent) {
function handleEventsForInputEventPolyfill (line 18060) | function handleEventsForInputEventPolyfill(topLevelType, target, targetI...
function getTargetInstForInputEventPolyfill (line 18083) | function getTargetInstForInputEventPolyfill(topLevelType, targetInst, na...
function shouldUseClickEvent (line 18102) | function shouldUseClickEvent(elem) {
function getTargetInstForClickEvent (line 18110) | function getTargetInstForClickEvent(topLevelType, targetInst, nativeEven...
function getTargetInstForInputOrChangeEvent (line 18116) | function getTargetInstForInputOrChangeEvent(topLevelType, targetInst, na...
function handleControlledInputBlur (line 18122) | function handleControlledInputBlur(inst, node) {
function FallbackCompositionState (line 18412) | function FallbackCompositionState(root) {
function instantiateChild (line 18752) | function instantiateChild(childInstances, child, name, selfDebugID) {
function StatelessComponent (line 18949) | function StatelessComponent(Component) {}
function warnIfInvalidElement (line 18957) | function warnIfInvalidElement(Component, element) {
function shouldConstruct (line 18964) | function shouldConstruct(Component) {
function isPureComponent (line 18968) | function isPureComponent(Component) {
function measureLifeCyclePerf (line 18973) | function measureLifeCyclePerf(fn, debugID, timerType) {
function getDeclarationErrorAddendum (line 19993) | function getDeclarationErrorAddendum(internalInstance) {
function friendlyStringify (line 20006) | function friendlyStringify(obj) {
function checkAndWarnForMutatedStyle (line 20032) | function checkAndWarnForMutatedStyle(style1, style2, component) {
function assertValidProps (line 20062) | function assertValidProps(component, props) {
function enqueuePutListener (line 20082) | function enqueuePutListener(inst, registrationName, listener, transactio...
function putListener (line 20102) | function putListener() {
function inputPostMount (line 20107) | function inputPostMount() {
function textareaPostMount (line 20112) | function textareaPostMount() {
function optionPostMount (line 20117) | function optionPostMount() {
function trackInputValue (line 20179) | function trackInputValue() {
function trapBubbledEventsLocal (line 20183) | function trapBubbledEventsLocal() {
function postUpdateSelectWrapper (line 20223) | function postUpdateSelectWrapper() {
function validateDangerousTag (line 20270) | function validateDangerousTag(tag) {
function isCustomComponent (line 20277) | function isCustomComponent(tagName, props) {
function ReactDOMComponent (line 20297) | function ReactDOMComponent(element) {
function ReactDOMContainerInfo (line 20962) | function ReactDOMContainerInfo(topLevelWrapper, node) {
function forceUpdateIfMounted (line 21134) | function forceUpdateIfMounted() {
function isControlled (line 21141) | function isControlled(props) {
function _handleChange (line 21341) | function _handleChange(event) {
function validateProperty (line 21415) | function validateProperty(tagName, name, debugID) {
function warnInvalidARIAProps (line 21441) | function warnInvalidARIAProps(debugID, element) {
function handleElement (line 21462) | function handleElement(debugID, element) {
function handleElement (line 21510) | function handleElement(debugID, element) {
function flattenChildren (line 21560) | function flattenChildren(children) {
function isCollapsed (line 21687) | function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {
function getIEOffsets (line 21705) | function getIEOffsets(node) {
function getModernOffsets (line 21728) | function getModernOffsets(node) {
function setIEOffsets (line 21790) | function setIEOffsets(node, offsets) {
function setModernOffsets (line 21824) | function setModernOffsets(node, offsets) {
function forceUpdateIfMounted (line 22071) | function forceUpdateIfMounted() {
function _handleChange (line 22197) | function _handleChange(event) {
function getLowestCommonAncestor (line 22230) | function getLowestCommonAncestor(instA, instB) {
function isAncestor (line 22270) | function isAncestor(instA, instB) {
function getParentInstance (line 22286) | function getParentInstance(inst) {
function traverseTwoPhase (line 22295) | function traverseTwoPhase(inst, fn, arg) {
function traverseEnterLeave (line 22317) | function traverseEnterLeave(from, to, fn, argFrom, argTo) {
function handleElement (line 22441) | function handleElement(debugID, element) {
function callHook (line 22490) | function callHook(event, fn, context, arg1, arg2, arg3, arg4, arg5) {
function emitEvent (line 22499) | function emitEvent(event, arg1, arg2, arg3, arg4, arg5) {
function clearHistory (line 22522) | function clearHistory() {
function getTreeSnapshot (line 22527) | function getTreeSnapshot(registeredIDs) {
function resetMeasurements (line 22544) | function resetMeasurements() {
function checkDebugID (line 22571) | function checkDebugID(debugID) {
function beginLifeCycleTimer (line 22582) | function beginLifeCycleTimer(debugID, timerType) {
function endLifeCycleTimer (line 22596) | function endLifeCycleTimer(debugID, timerType) {
function pauseCurrentLifeCycleTimer (line 22617) | function pauseCurrentLifeCycleTimer() {
function resumeCurrentLifeCycleTimer (line 22631) | function resumeCurrentLifeCycleTimer() {
function shouldMark (line 22648) | function shouldMark(debugID) {
function markBegin (line 22663) | function markBegin(debugID, markType) {
function markEnd (line 22673) | function markEnd(debugID, markType) {
function ReactDefaultBatchingStrategyTransaction (line 22864) | function ReactDefaultBatchingStrategyTransaction() {
function inject (line 22936) | function inject() {
function runEventQueueInBatch (line 23028) | function runEventQueueInBatch(events) {
function findParent (line 23077) | function findParent(inst) {
function TopLevelCallbackBookKeeping (line 23090) | function TopLevelCallbackBookKeeping(topLevelType, nativeEvent) {
function handleTopLevelImpl (line 23104) | function handleTopLevelImpl(bookKeeping) {
function scrollValueMonitor (line 23124) | function scrollValueMonitor(cb) {
function makeInsertMarkup (line 23408) | function makeInsertMarkup(markup, afterNode, toIndex) {
function makeMove (line 23427) | function makeMove(child, afterNode, toIndex) {
function makeRemove (line 23445) | function makeRemove(child, node) {
function makeSetMarkup (line 23463) | function makeSetMarkup(markup) {
function makeTextContent (line 23481) | function makeTextContent(textContent) {
function enqueue (line 23497) | function enqueue(queue, update) {
function processQueue (line 23510) | function processQueue(inst, updateQueue) {
function isValidOwner (line 23847) | function isValidOwner(object) {
function ReactReconcileTransaction (line 24062) | function ReactReconcileTransaction(useCreateElement) {
function attachRef (line 24150) | function attachRef(ref, component, owner) {
function detachRef (line 24159) | function detachRef(ref, component, owner) {
function ReactServerRenderingTransaction (line 24266) | function ReactServerRenderingTransaction(renderToStaticMarkup) {
function _classCallCheck (line 24332) | function _classCallCheck(instance, Constructor) { if (!(instance instanc...
function warnNoop (line 24338) | function warnNoop(publicInstance, callerName) {
function ReactServerUpdateQueue (line 24354) | function ReactServerUpdateQueue(transaction) {
function getSelection (line 24836) | function getSelection(node) {
function constructSelectEvent (line 24867) | function constructSelectEvent(nativeEvent, nativeEventTarget) {
function getDictionaryKey (line 25047) | function getDictionaryKey(inst) {
function isInteractive (line 25053) | function isInteractive(tag) {
function SyntheticAnimationEvent (line 25236) | function SyntheticAnimationEvent(dispatchConfig, dispatchMarker, nativeE...
function SyntheticClipboardEvent (line 25277) | function SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeE...
function SyntheticCompositionEvent (line 25316) | function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativ...
function SyntheticDragEvent (line 25355) | function SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent,...
function SyntheticFocusEvent (line 25394) | function SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent...
function SyntheticInputEvent (line 25434) | function SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent...
function SyntheticKeyboardEvent (line 25521) | function SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEv...
function SyntheticTouchEvent (line 25569) | function SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent...
function SyntheticTransitionEvent (line 25611) | function SyntheticTransitionEvent(dispatchConfig, dispatchMarker, native...
function SyntheticWheelEvent (line 25665) | function SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent...
function adler32 (line 25696) | function adler32(data) {
function checkReactTypeSpec (line 25768) | function checkReactTypeSpec(typeSpecs, values, location, componentName, ...
function dangerousStyleValue (line 25842) | function dangerousStyleValue(name, value, component, isCustomProperty) {
function findDOMNode (line 25927) | function findDOMNode(componentOrElement) {
function flattenSingleChildIntoContext (line 25995) | function flattenSingleChildIntoContext(traverseContext, child, name, sel...
function flattenChildren (line 26019) | function flattenChildren(children, selfDebugID) {
function getEventKey (line 26122) | function getEventKey(nativeEvent) {
function getIteratorFn (line 26188) | function getIteratorFn(maybeIterable) {
function getLeafNode (line 26219) | function getLeafNode(node) {
function getSiblingNode (line 26233) | function getSiblingNode(node) {
function getNodeForCharacterOffset (line 26249) | function getNodeForCharacterOffset(root, offset) {
function makePrefixMap (line 26298) | function makePrefixMap(styleProp, eventName) {
function getVendorPrefixedEventName (line 26358) | function getVendorPrefixedEventName(eventName) {
function quoteAttributeValueForBrowser (line 26401) | function quoteAttributeValueForBrowser(value) {
function isValidElementType (line 26473) | function isValidElementType(type) {
function typeOf (line 26533) | function typeOf(object) {
function isAsyncMode (line 26590) | function isAsyncMode(object) {
function isConcurrentMode (line 26600) | function isConcurrentMode(object) {
function isContextConsumer (line 26603) | function isContextConsumer(object) {
function isContextProvider (line 26606) | function isContextProvider(object) {
function isElement (line 26609) | function isElement(object) {
function isForwardRef (line 26612) | function isForwardRef(object) {
function isFragment (line 26615) | function isFragment(object) {
function isLazy (line 26618) | function isLazy(object) {
function isMemo (line 26621) | function isMemo(object) {
function isPortal (line 26624) | function isPortal(object) {
function isProfiler (line 26627) | function isProfiler(object) {
function isStrictMode (line 26630) | function isStrictMode(object) {
function isSuspense (line 26633) | function isSuspense(object) {
function y (line 26686) | function y(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(...
function z (line 26686) | function z(a){return y(a)===m}
function escape (line 26730) | function escape(key) {
function unescape (line 26749) | function unescape(key) {
function escapeUserProvidedKey (line 26910) | function escapeUserProvidedKey(text) {
function ForEachBookKeeping (line 26922) | function ForEachBookKeeping(forEachFunction, forEachContext) {
function forEachSingleChild (line 26934) | function forEachSingleChild(bookKeeping, child, name) {
function forEachChildren (line 26953) | function forEachChildren(children, forEachFunc, forEachContext) {
function MapBookKeeping (line 26971) | function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) {
function mapSingleChildIntoContext (line 26987) | function mapSingleChildIntoContext(bookKeeping, child, childKey) {
function mapIntoWithKeyPrefixInternal (line 27008) | function mapIntoWithKeyPrefixInternal(children, array, prefix, func, con...
function mapChildren (line 27031) | function mapChildren(children, func, context) {
function forEachSingleChildDummy (line 27040) | function forEachSingleChildDummy(traverseContext, child, name) {
function countChildren (line 27053) | function countChildren(children, context) {
function toArray (line 27063) | function toArray(children) {
function checkReactTypeSpec (line 27388) | function checkReactTypeSpec(typeSpecs, values, location, componentName, ...
function getNextDebugID (line 27475) | function getNextDebugID() {
function onlyChild (line 27515) | function onlyChild(children) {
function getComponentKey (line 27571) | function getComponentKey(component, index) {
function traverseAllChildrenImpl (line 27590) | function traverseAllChildrenImpl(children, nameSoFar, callback, traverse...
function traverseAllChildren (line 27692) | function traverseAllChildren(children, callback, traverseContext) {
function hash (line 27710) | function hash(str) {
FILE: lib/index.js
function _interopRequireDefault (line 288) | function _interopRequireDefault(obj) { return obj && obj.__esModule ? ob...
FILE: lib/utils/utils.js
function _toConsumableArray (line 7) | function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i ...
Condensed preview — 165 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,051K chars).
[
{
"path": ".babelrc",
"chars": 127,
"preview": "{\n \"presets\": [\"es2015\", \"react\"],\n \"plugins\": [\n \"transform-object-rest-spread\",\n \"transform-export-extensions\""
},
{
"path": ".gitignore",
"chars": 578,
"preview": "# Logs\nlogs\n*.log\nnpm-debug.log*\n\n# Runtime data\npids\n*.pid\n*.seed\n\n# Directory for instrumented libs generated by jscov"
},
{
"path": ".npmignore",
"chars": 38,
"preview": "src\n__test__\nexamples\nnode_modules\ndev"
},
{
"path": "LICENSE",
"chars": 1066,
"preview": "MIT License\n\nCopyright (c) 2017 react-map\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
},
{
"path": "README.md",
"chars": 3851,
"preview": "# react-magic\n\n[](https://www.npmjs.com/package/react-magic)\n<a "
},
{
"path": "dev/App.js",
"chars": 1166,
"preview": "import React, { Component, PropTypes } from 'react';\nimport { StyleSheet, css } from 'aphrodite';\n\nimport spaceOutUp fro"
},
{
"path": "dev/index.html",
"chars": 186,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n\n<head>\n <meta charset=\"UTF-8\">\n <title>App</title>\n</head>\n\n<body>\n <div id='"
},
{
"path": "dev/index.js",
"chars": 145,
"preview": "import React from 'react';\nimport ReactDOM from 'react-dom';\nimport App from './App';\n\nReactDOM.render(<App />,document."
},
{
"path": "dev/server.js",
"chars": 337,
"preview": "const WebpackDevServer = require('webpack-dev-server');\nconst webpack = require('webpack');\nconst config = require('./we"
},
{
"path": "dev/webpack-dev-server.config.js",
"chars": 767,
"preview": "const webpack = require('webpack');\nconst path = require('path');\nconst buildPath = path.resolve(__dirname, 'dist');\ncon"
},
{
"path": "examples/App.js",
"chars": 8703,
"preview": "import React, { Component, PropTypes } from 'react';\nimport { StyleSheet, css } from 'aphrodite/no-important';\n\nimport *"
},
{
"path": "examples/dist/app.js",
"chars": 894863,
"preview": "/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/**"
},
{
"path": "examples/dist/index.html",
"chars": 194,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n\n<head>\n <meta charset=\"UTF-8\">\n <title>React-Magic</title>\n</head>\n\n<body>\n <"
},
{
"path": "examples/index.html",
"chars": 655,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n\n<head>\n <meta charset=\"UTF-8\">\n <title>React-Magic</title>\n</head>\n\n<body>\n <"
},
{
"path": "examples/index.js",
"chars": 149,
"preview": "import React from 'react';\nimport ReactDOM from 'react-dom';\nimport App from './App';\n\nReactDOM.render(<App />,\n docu"
},
{
"path": "examples/server.js",
"chars": 347,
"preview": "const WebpackDevServer = require('webpack-dev-server');\nconst webpack = require('webpack');\nconst config = require('./we"
},
{
"path": "examples/webpack-examples-server.config.js",
"chars": 767,
"preview": "const webpack = require('webpack');\nconst path = require('path');\nconst buildPath = path.resolve(__dirname, 'dist');\ncon"
},
{
"path": "lib/bling/puffIn.js",
"chars": 444,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/bling/puffOut.js",
"chars": 446,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/bling/vanishIn.js",
"chars": 449,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/bling/vanishOut.js",
"chars": 451,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/boing/boingInUp.js",
"chars": 597,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/boing/boingOutDown.js",
"chars": 924,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/bomb/bombLeftOut.js",
"chars": 599,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/bomb/bombRightOut.js",
"chars": 597,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/index.js",
"chars": 13464,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.spaceOutUp = exports.spaceOutRig"
},
{
"path": "lib/magic/magic.js",
"chars": 450,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/magic/swap.js",
"chars": 479,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/magic/twisterInDown.js",
"chars": 625,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/magic/twisterInUp.js",
"chars": 616,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/math/foolishIn.js",
"chars": 856,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/math/foolishOut.js",
"chars": 855,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/math/holeIn.js",
"chars": 443,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/math/holeOut.js",
"chars": 445,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/math/swashIn.js",
"chars": 468,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/math/swashOut.js",
"chars": 470,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveDown.js",
"chars": 464,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveDownReturn.js",
"chars": 476,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveLeft.js",
"chars": 458,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveLeftReturn.js",
"chars": 470,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveRight.js",
"chars": 465,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveRightReturn.js",
"chars": 477,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveUp.js",
"chars": 453,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/perspective/perspectiveUpReturn.js",
"chars": 465,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateDownIn.js",
"chars": 558,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateDownOut.js",
"chars": 560,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateLeftIn.js",
"chars": 555,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateLeftOut.js",
"chars": 557,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateRightIn.js",
"chars": 556,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateRightOut.js",
"chars": 558,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateUpIn.js",
"chars": 550,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/rotate/rotateUpOut.js",
"chars": 552,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideDown.js",
"chars": 348,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideDownReturn.js",
"chars": 360,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideLeft.js",
"chars": 349,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideLeftReturn.js",
"chars": 361,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideRight.js",
"chars": 350,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideRightReturn.js",
"chars": 362,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideUp.js",
"chars": 345,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/slide/slideUpReturn.js",
"chars": 357,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceInDown.js",
"chars": 491,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceInLeft.js",
"chars": 488,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceInRight.js",
"chars": 493,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceInUp.js",
"chars": 484,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceOutDown.js",
"chars": 493,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceOutLeft.js",
"chars": 490,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceOutRight.js",
"chars": 495,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/space/spaceOutUp.js",
"chars": 486,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openDownLeft.js",
"chars": 442,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openDownLeftReturn.js",
"chars": 454,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openDownRight.js",
"chars": 445,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openDownRightReturn.js",
"chars": 457,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openUpLeft.js",
"chars": 431,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openUpLeftReturn.js",
"chars": 443,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openUpRight.js",
"chars": 436,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffects/openUpRightReturn.js",
"chars": 448,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffectsOut/openDownLeftOut.js",
"chars": 480,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffectsOut/openDownRightOut.js",
"chars": 483,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffectsOut/openUpLeftOut.js",
"chars": 469,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/staticEffectsOut/openUpRightOut.js",
"chars": 474,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinDownIn.js",
"chars": 495,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinDownOut.js",
"chars": 497,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinLeftIn.js",
"chars": 496,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinLeftOut.js",
"chars": 498,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinRightIn.js",
"chars": 497,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinRightOut.js",
"chars": 499,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinUpIn.js",
"chars": 492,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/tin/tinUpOut.js",
"chars": 494,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _utils = require('../utils/utils');"
},
{
"path": "lib/utils/types.js",
"chars": 13,
"preview": "\"use strict\";"
},
{
"path": "lib/utils/utils.js",
"chars": 3018,
"preview": "'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nfunction _toConsumableArray(arr) { if ("
},
{
"path": "package.json",
"chars": 1270,
"preview": "{\n \"name\": \"react-magic\",\n \"version\": \"0.2.4\",\n \"description\": \"A collection of magic animations for react components"
},
{
"path": "src/bling/puffIn.js",
"chars": 395,
"preview": "// @flow\nimport { compose, scale,blur } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst p"
},
{
"path": "src/bling/puffOut.js",
"chars": 397,
"preview": "// @flow\nimport { compose, scale,blur } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst p"
},
{
"path": "src/bling/vanishIn.js",
"chars": 400,
"preview": "// @flow\nimport { compose, scale,blur } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst v"
},
{
"path": "src/bling/vanishOut.js",
"chars": 402,
"preview": "// @flow\nimport { compose, scale,blur } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst v"
},
{
"path": "src/boing/boingInUp.js",
"chars": 579,
"preview": "// @flow\nimport { compose,perspective ,rotateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';"
},
{
"path": "src/boing/boingOutDown.js",
"chars": 917,
"preview": "// @flow\nimport { compose, perspective, rotateX, rotateY } from '../utils/utils';\nimport type { Animation } from '../uti"
},
{
"path": "src/bomb/bombLeftOut.js",
"chars": 528,
"preview": "// @flow\nimport { compose, rotate,blur } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst "
},
{
"path": "src/bomb/bombRightOut.js",
"chars": 526,
"preview": "// @flow\nimport { compose, rotate,blur } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst "
},
{
"path": "src/index.js",
"chars": 3674,
"preview": "//magic\nexport magic from './magic/magic';\nexport swap from './magic/swap';\nexport twisterInDown from './magic/twisterIn"
},
{
"path": "src/magic/magic.js",
"chars": 429,
"preview": "// @flow\nimport { compose, scale, rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\ncons"
},
{
"path": "src/magic/swap.js",
"chars": 463,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/magic/twisterInDown.js",
"chars": 609,
"preview": "// @flow\nimport { compose, scale, rotate, translateY } from '../utils/utils';\nimport type { Animation } from '../utils/t"
},
{
"path": "src/magic/twisterInUp.js",
"chars": 600,
"preview": "// @flow\nimport { compose, scale, rotate, translateY } from '../utils/utils';\nimport type { Animation } from '../utils/t"
},
{
"path": "src/math/foolishIn.js",
"chars": 833,
"preview": "// @flow\nimport { compose, scale, rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\ncons"
},
{
"path": "src/math/foolishOut.js",
"chars": 832,
"preview": "// @flow\nimport { compose, scale, rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\ncons"
},
{
"path": "src/math/holeIn.js",
"chars": 419,
"preview": "// @flow\nimport { compose, scale, rotateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\ncon"
},
{
"path": "src/math/holeOut.js",
"chars": 421,
"preview": "// @flow\nimport { compose, scale, rotateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\ncon"
},
{
"path": "src/math/swashIn.js",
"chars": 421,
"preview": "// @flow\nimport { scale } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst swashIn: Animat"
},
{
"path": "src/math/swashOut.js",
"chars": 423,
"preview": "// @flow\nimport { scale } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst swashOut: Anima"
},
{
"path": "src/perspective/perspectiveDown.js",
"chars": 448,
"preview": "// @flow\nimport { compose, perspective, rotateX } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/perspective/perspectiveDownReturn.js",
"chars": 460,
"preview": "// @flow\nimport { compose, perspective, rotateX } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/perspective/perspectiveLeft.js",
"chars": 442,
"preview": "// @flow\nimport { compose, perspective, rotateY } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/perspective/perspectiveLeftReturn.js",
"chars": 454,
"preview": "// @flow\nimport { compose, perspective, rotateY } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/perspective/perspectiveRight.js",
"chars": 449,
"preview": "// @flow\nimport { compose, perspective, rotateY } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/perspective/perspectiveRightReturn.js",
"chars": 461,
"preview": "// @flow\nimport { compose, perspective, rotateY } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/perspective/perspectiveUp.js",
"chars": 437,
"preview": "// @flow\nimport { compose, perspective, rotateX } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/perspective/perspectiveUpReturn.js",
"chars": 449,
"preview": "// @flow\nimport { compose, perspective, rotateX } from '../utils/utils';\nimport type { Animation } from '../utils/types'"
},
{
"path": "src/rotate/rotateDownIn.js",
"chars": 549,
"preview": "// @flow\nimport { compose, perspective, rotateX, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/rotate/rotateDownOut.js",
"chars": 551,
"preview": "// @flow\nimport { compose, perspective, rotateX, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/rotate/rotateLeftIn.js",
"chars": 546,
"preview": "// @flow\nimport { compose, perspective, rotateY, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/rotate/rotateLeftOut.js",
"chars": 548,
"preview": "// @flow\nimport { compose, perspective, rotateY, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/rotate/rotateRightIn.js",
"chars": 547,
"preview": "// @flow\nimport { compose, perspective, rotateY, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/rotate/rotateRightOut.js",
"chars": 549,
"preview": "// @flow\nimport { compose, perspective, rotateY, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/rotate/rotateUpIn.js",
"chars": 541,
"preview": "// @flow\nimport { compose, perspective, rotateX, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/rotate/rotateUpOut.js",
"chars": 543,
"preview": "// @flow\nimport { compose, perspective, rotateX, translateZ } from '../utils/utils';\nimport type { Animation } from '../"
},
{
"path": "src/slide/slideDown.js",
"chars": 318,
"preview": "// @flow\nimport { translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideDown:"
},
{
"path": "src/slide/slideDownReturn.js",
"chars": 330,
"preview": "// @flow\nimport { translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideDownR"
},
{
"path": "src/slide/slideLeft.js",
"chars": 319,
"preview": "// @flow\nimport { translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideLeft:"
},
{
"path": "src/slide/slideLeftReturn.js",
"chars": 331,
"preview": "// @flow\nimport { translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideLeftR"
},
{
"path": "src/slide/slideRight.js",
"chars": 320,
"preview": "// @flow\nimport { translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideRight"
},
{
"path": "src/slide/slideRightReturn.js",
"chars": 332,
"preview": "// @flow\nimport { translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideRight"
},
{
"path": "src/slide/slideUp.js",
"chars": 315,
"preview": "// @flow\nimport { translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideUp: A"
},
{
"path": "src/slide/slideUpReturn.js",
"chars": 327,
"preview": "// @flow\nimport { translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst slideUpRet"
},
{
"path": "src/space/spaceInDown.js",
"chars": 475,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/space/spaceInLeft.js",
"chars": 472,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/space/spaceInRight.js",
"chars": 477,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/space/spaceInUp.js",
"chars": 468,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/space/spaceOutDown.js",
"chars": 477,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/space/spaceOutLeft.js",
"chars": 474,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/space/spaceOutRight.js",
"chars": 479,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/space/spaceOutUp.js",
"chars": 470,
"preview": "// @flow\nimport { compose, scale, translateXY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n"
},
{
"path": "src/staticEffects/openDownLeft.js",
"chars": 408,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openDownLeft: "
},
{
"path": "src/staticEffects/openDownLeftReturn.js",
"chars": 420,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openDownLeftRe"
},
{
"path": "src/staticEffects/openDownRight.js",
"chars": 411,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openDownRight:"
},
{
"path": "src/staticEffects/openDownRightReturn.js",
"chars": 423,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openDownRightR"
},
{
"path": "src/staticEffects/openUpLeft.js",
"chars": 397,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openUpLeft: An"
},
{
"path": "src/staticEffects/openUpLeftReturn.js",
"chars": 409,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openUpLeftRetu"
},
{
"path": "src/staticEffects/openUpRight.js",
"chars": 402,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openUpRight: A"
},
{
"path": "src/staticEffects/openUpRightReturn.js",
"chars": 414,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openUpRightRet"
},
{
"path": "src/staticEffectsOut/openDownLeftOut.js",
"chars": 444,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openDownLeftOu"
},
{
"path": "src/staticEffectsOut/openDownRightOut.js",
"chars": 447,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openDownRightO"
},
{
"path": "src/staticEffectsOut/openUpLeftOut.js",
"chars": 435,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openUpLeftOut:"
},
{
"path": "src/staticEffectsOut/openUpRightOut.js",
"chars": 440,
"preview": "// @flow\nimport { rotate } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\nconst openUpRightOut"
},
{
"path": "src/tin/tinDownIn.js",
"chars": 478,
"preview": "// @flow\nimport { compose, scale, translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/tin/tinDownOut.js",
"chars": 480,
"preview": "// @flow\nimport { compose, scale, translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/tin/tinLeftIn.js",
"chars": 479,
"preview": "// @flow\nimport { compose, scale, translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/tin/tinLeftOut.js",
"chars": 481,
"preview": "// @flow\nimport { compose, scale, translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/tin/tinRightIn.js",
"chars": 480,
"preview": "// @flow\nimport { compose, scale, translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/tin/tinRightOut.js",
"chars": 482,
"preview": "// @flow\nimport { compose, scale, translateX } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/tin/tinUpIn.js",
"chars": 475,
"preview": "// @flow\nimport { compose, scale, translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/tin/tinUpOut.js",
"chars": 477,
"preview": "// @flow\nimport { compose, scale, translateY } from '../utils/utils';\nimport type { Animation } from '../utils/types';\n\n"
},
{
"path": "src/utils/types.js",
"chars": 170,
"preview": "// @flow\n\nexport type CSSValue = string | number\n\nexport type Keyframe = {\n [property: string]: CSSValue,\n}\n\nexport typ"
},
{
"path": "src/utils/utils.js",
"chars": 2212,
"preview": "// @flow\nimport type { CSSValue } from './types';\n\n/**\n * Composes a variable number of CSS helper functions.\n * Returns"
},
{
"path": "webpack-production.config.js",
"chars": 1424,
"preview": "const webpack = require('webpack');\nconst path = require('path');\nconst buildPath = path.resolve(__dirname, 'dist');\n\nco"
}
]
About this extraction
This page contains the full source code of the react-map/react-magic GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 165 files (983.0 KB), approximately 250.9k tokens, and a symbol index with 441 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.