DoomRye/2017-06-08_509bba0
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Add files

Browse source
This commit is contained in:
DoomRye 2022-07-26 10:06:20 -07:00
commit bb80829159
18195 changed files with 2122994 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

30
509bba0_unpacked/~/animated/src/Animated.js Executable file
View file

@ -0,0 +1,30 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
// Note(vjeux): this would be better as an interface but flow doesn't
// support them yet
class Animated {
__attach(): void {}
__detach(): void {}
__getValue(): any {}
__getAnimatedValue(): any { return this.__getValue(); }
__addChild(child: Animated) {}
__removeChild(child: Animated) {}
__getChildren(): Array<Animated> { return []; }
}
module.exports = Animated;
// WEBPACK FOOTER //
// ./~/animated/src/Animated.js

83
509bba0_unpacked/~/animated/src/AnimatedAddition.js Executable file
View file

@ -0,0 +1,83 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var AnimatedWithChildren = require('./AnimatedWithChildren');
var Animated = require('./Animated');
var AnimatedValue = require('./AnimatedValue');
var Interpolation = require('./Interpolation');
var AnimatedInterpolation = require('./AnimatedInterpolation');
import type { InterpolationConfigType } from './Interpolation';
class AnimatedAddition extends AnimatedWithChildren {
_a: Animated;
_b: Animated;
_aListener: number;
_bListener: number;
_listeners: {[key: number]: ValueListenerCallback};
constructor(a: Animated | number, b: Animated | number) {
super();
this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
this._listeners = {};
}
__getValue(): number {
return this._a.__getValue() + this._b.__getValue();
}
addListener(callback: ValueListenerCallback): string {
if (!this._aListener && this._a.addListener) {
this._aListener = this._a.addListener(() => {
for (var key in this._listeners) {
this._listeners[key]({value: this.__getValue()});
}
})
}
if (!this._bListener && this._b.addListener) {
this._bListener = this._b.addListener(() => {
for (var key in this._listeners) {
this._listeners[key]({value: this.__getValue()});
}
})
}
var id = guid();
this._listeners[id] = callback;
return id;
}
removeListener(id: string): void {
delete this._listeners[id];
}
interpolate(config: InterpolationConfigType): AnimatedInterpolation {
return new AnimatedInterpolation(this, Interpolation.create(config));
}
__attach(): void {
this._a.__addChild(this);
this._b.__addChild(this);
}
__detach(): void {
this._a.__removeChild(this);
this._b.__removeChild(this);
}
}
module.exports = AnimatedAddition;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedAddition.js

79
509bba0_unpacked/~/animated/src/AnimatedInterpolation.js Executable file
View file

@ -0,0 +1,79 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedWithChildren = require('./AnimatedWithChildren');
var invariant = require('invariant');
var Interpolation = require('./Interpolation');
var guid = require('./guid');
import type { ValueListenerCallback } from './AnimatedValue';
class AnimatedInterpolation extends AnimatedWithChildren {
_parent: Animated;
_interpolation: (input: number) => number | string;
_listeners: {[key: number]: ValueListenerCallback};
_parentListener: number;
constructor(parent: Animated, interpolation: (input: number) => number | string) {
super();
this._parent = parent;
this._interpolation = interpolation;
this._listeners = {};
}
__getValue(): number | string {
var parentValue: number = this._parent.__getValue();
invariant(
typeof parentValue === 'number',
'Cannot interpolate an input which is not a number.'
);
return this._interpolation(parentValue);
}
addListener(callback: ValueListenerCallback): string {
if (!this._parentListener) {
this._parentListener = this._parent.addListener(() => {
for (var key in this._listeners) {
this._listeners[key]({value: this.__getValue()});
}
})
}
var id = guid();
this._listeners[id] = callback;
return id;
}
removeListener(id: string): void {
delete this._listeners[id];
}
interpolate(config: InterpolationConfigType): AnimatedInterpolation {
return new AnimatedInterpolation(this, Interpolation.create(config));
}
__attach(): void {
this._parent.__addChild(this);
}
__detach(): void {
this._parent.__removeChild(this);
this._parentListener = this._parent.removeListener(this._parentListener);
}
}
module.exports = AnimatedInterpolation;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedInterpolation.js

72
509bba0_unpacked/~/animated/src/AnimatedModulo.js Executable file
View file

@ -0,0 +1,72 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedWithChildren = require('./AnimatedWithChildren');
var AnimatedInterpolation = require('./AnimatedInterpolation');
var Interpolation = require('./Interpolation');
import type { InterpolationConfigType } from './Interpolation';
class AnimatedModulo extends AnimatedWithChildren {
_a: Animated;
_modulus: number; // TODO(lmr): Make modulus able to be an animated value
_aListener: number;
_listeners: {[key: number]: ValueListenerCallback};
constructor(a: Animated, modulus: number) {
super();
this._a = a;
this._modulus = modulus;
this._listeners = {};
}
__getValue(): number {
return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
}
addListener(callback: ValueListenerCallback): string {
if (!this._aListener) {
this._aListener = this._a.addListener(() => {
for (var key in this._listeners) {
this._listeners[key]({value: this.__getValue()});
}
})
}
var id = guid();
this._listeners[id] = callback;
return id;
}
removeListener(id: string): void {
delete this._listeners[id];
}
interpolate(config: InterpolationConfigType): AnimatedInterpolation {
return new AnimatedInterpolation(this, Interpolation.create(config));
}
__attach(): void {
this._a.__addChild(this);
}
__detach(): void {
this._a.__removeChild(this);
}
}
module.exports = AnimatedModulo;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedModulo.js

83
509bba0_unpacked/~/animated/src/AnimatedMultiplication.js Executable file
View file

@ -0,0 +1,83 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var AnimatedWithChildren = require('./AnimatedWithChildren');
var Animated = require('./Animated');
var AnimatedValue = require('./AnimatedValue');
var AnimatedInterpolation = require('./AnimatedInterpolation');
var Interpolation = require('./Interpolation');
import type { InterpolationConfigType } from './Interpolation';
class AnimatedMultiplication extends AnimatedWithChildren {
_a: Animated;
_b: Animated;
_aListener: number;
_bListener: number;
_listeners: {[key: number]: ValueListenerCallback};
constructor(a: Animated | number, b: Animated | number) {
super();
this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
this._listeners = {};
}
__getValue(): number {
return this._a.__getValue() * this._b.__getValue();
}
addListener(callback: ValueListenerCallback): string {
if (!this._aListener && this._a.addListener) {
this._aListener = this._a.addListener(() => {
for (var key in this._listeners) {
this._listeners[key]({value: this.__getValue()});
}
})
}
if (!this._bListener && this._b.addListener) {
this._bListener = this._b.addListener(() => {
for (var key in this._listeners) {
this._listeners[key]({value: this.__getValue()});
}
})
}
var id = guid();
this._listeners[id] = callback;
return id;
}
removeListener(id: string): void {
delete this._listeners[id];
}
interpolate(config: InterpolationConfigType): AnimatedInterpolation {
return new AnimatedInterpolation(this, Interpolation.create(config));
}
__attach(): void {
this._a.__addChild(this);
this._b.__addChild(this);
}
__detach(): void {
this._a.__removeChild(this);
this._b.__removeChild(this);
}
}
module.exports = AnimatedMultiplication;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedMultiplication.js

88
509bba0_unpacked/~/animated/src/AnimatedProps.js Executable file
View file

@ -0,0 +1,88 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedStyle = require('./AnimatedStyle');
class AnimatedProps extends Animated {
_props: Object;
_callback: () => void;
constructor(
props: Object,
callback: () => void,
) {
super();
if (props.style) {
props = {
...props,
style: new AnimatedStyle(props.style),
};
}
this._props = props;
this._callback = callback;
this.__attach();
}
__getValue(): Object {
var props = {};
for (var key in this._props) {
var value = this._props[key];
if (value instanceof Animated) {
props[key] = value.__getValue();
} else {
props[key] = value;
}
}
return props;
}
__getAnimatedValue(): Object {
var props = {};
for (var key in this._props) {
var value = this._props[key];
if (value instanceof Animated) {
props[key] = value.__getAnimatedValue();
}
}
return props;
}
__attach(): void {
for (var key in this._props) {
var value = this._props[key];
if (value instanceof Animated) {
value.__addChild(this);
}
}
}
__detach(): void {
for (var key in this._props) {
var value = this._props[key];
if (value instanceof Animated) {
value.__removeChild(this);
}
}
}
update(): void {
this._callback();
}
}
module.exports = AnimatedProps;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedProps.js

81
509bba0_unpacked/~/animated/src/AnimatedStyle.js Executable file
View file

@ -0,0 +1,81 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedWithChildren = require('./AnimatedWithChildren');
var AnimatedTransform = require('./AnimatedTransform');
var FlattenStyle = require('./injectable/FlattenStyle');
class AnimatedStyle extends AnimatedWithChildren {
_style: Object;
constructor(style: any) {
super();
style = FlattenStyle.current(style) || {};
if (style.transform && !(style.transform instanceof Animated)) {
style = {
...style,
transform: new AnimatedTransform(style.transform),
};
}
this._style = style;
}
__getValue(): Object {
var style = {};
for (var key in this._style) {
var value = this._style[key];
if (value instanceof Animated) {
style[key] = value.__getValue();
} else {
style[key] = value;
}
}
return style;
}
__getAnimatedValue(): Object {
var style = {};
for (var key in this._style) {
var value = this._style[key];
if (value instanceof Animated) {
style[key] = value.__getAnimatedValue();
}
}
return style;
}
__attach(): void {
for (var key in this._style) {
var value = this._style[key];
if (value instanceof Animated) {
value.__addChild(this);
}
}
}
__detach(): void {
for (var key in this._style) {
var value = this._style[key];
if (value instanceof Animated) {
value.__removeChild(this);
}
}
}
}
module.exports = AnimatedStyle;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedStyle.js

64
509bba0_unpacked/~/animated/src/AnimatedTemplate.js Executable file
View file

@ -0,0 +1,64 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedWithChildren = require('./AnimatedWithChildren');
class AnimatedTemplate extends AnimatedWithChildren {
_strings: Array<string>;
_values: Array;
constructor(strings, values) {
super();
this._strings = strings;
this._values = values;
}
__transformValue(value): any {
if (value instanceof Animated) {
return value.__getValue();
} else {
return value;
}
}
__getValue(): String {
var value = this._strings[0];
for (var i = 0; i < this._values.length; ++i) {
value += this.__transformValue(this._values[i]) + this._strings[1 + i];
}
return value;
}
__attach(): void {
for (var i = 0; i < this._values.length; ++i) {
if (this._values[i] instanceof Animated) {
this._values[i].__addChild(this);
}
}
}
__detach(): void {
for (var i = 0; i < this._values.length; ++i) {
if (this._values[i] instanceof Animated) {
this._values[i].__removeChild(this);
}
}
}
}
module.exports = AnimatedTemplate;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedTemplate.js

66
509bba0_unpacked/~/animated/src/AnimatedTracking.js Executable file
View file

@ -0,0 +1,66 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedValue = require('./AnimatedValue');
import type { EndCallback } from './Animated';
class AnimatedTracking extends Animated {
_value: AnimatedValue;
_parent: Animated;
_callback: ?EndCallback;
_animationConfig: Object;
_animationClass: any;
constructor(
value: AnimatedValue,
parent: Animated,
animationClass: any,
animationConfig: Object,
callback?: ?EndCallback,
) {
super();
this._value = value;
this._parent = parent;
this._animationClass = animationClass;
this._animationConfig = animationConfig;
this._callback = callback;
this.__attach();
}
__getValue(): Object {
return this._parent.__getValue();
}
__attach(): void {
this._parent.__addChild(this);
}
__detach(): void {
this._parent.__removeChild(this);
}
update(): void {
this._value.animate(new this._animationClass({
...this._animationConfig,
toValue: (this._animationConfig.toValue: any).__getValue(),
}), this._callback);
}
}
module.exports = AnimatedTracking;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedTracking.js

83
509bba0_unpacked/~/animated/src/AnimatedTransform.js Executable file
View file

@ -0,0 +1,83 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedWithChildren = require('./AnimatedWithChildren');
class AnimatedTransform extends AnimatedWithChildren {
_transforms: Array<Object>;
constructor(transforms: Array<Object>) {
super();
this._transforms = transforms;
}
__getValue(): Array<Object> {
return this._transforms.map(transform => {
var result = {};
for (var key in transform) {
var value = transform[key];
if (value instanceof Animated) {
result[key] = value.__getValue();
} else {
result[key] = value;
}
}
return result;
});
}
__getAnimatedValue(): Array<Object> {
return this._transforms.map(transform => {
var result = {};
for (var key in transform) {
var value = transform[key];
if (value instanceof Animated) {
result[key] = value.__getAnimatedValue();
} else {
// All transform components needed to recompose matrix
result[key] = value;
}
}
return result;
});
}
__attach(): void {
this._transforms.forEach(transform => {
for (var key in transform) {
var value = transform[key];
if (value instanceof Animated) {
value.__addChild(this);
}
}
});
}
__detach(): void {
this._transforms.forEach(transform => {
for (var key in transform) {
var value = transform[key];
if (value instanceof Animated) {
value.__removeChild(this);
}
}
});
}
}
module.exports = AnimatedTransform;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedTransform.js

217
509bba0_unpacked/~/animated/src/AnimatedValue.js Executable file
View file

@ -0,0 +1,217 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var AnimatedWithChildren = require('./AnimatedWithChildren');
var InteractionManager = require('./injectable/InteractionManager');
var AnimatedInterpolation = require('./AnimatedInterpolation');
var Interpolation = require('./Interpolation');
var Animation = require('./Animation');
var guid = require('./guid');
var Set = global.Set || require('./SetPolyfill');
import type { EndCallback } from './Animation';
import type { InterpolationConfigType } from './Interpolation';
export type ValueListenerCallback = (state: {value: number}) => void;
/**
* Animated works by building a directed acyclic graph of dependencies
* transparently when you render your Animated components.
*
* new Animated.Value(0)
* .interpolate() .interpolate() new Animated.Value(1)
* opacity translateY scale
* style transform
* View#234 style
* View#123
*
* A) Top Down phase
* When an Animated.Value is updated, we recursively go down through this
* graph in order to find leaf nodes: the views that we flag as needing
* an update.
*
* B) Bottom Up phase
* When a view is flagged as needing an update, we recursively go back up
* in order to build the new value that it needs. The reason why we need
* this two-phases process is to deal with composite props such as
* transform which can receive values from multiple parents.
*/
function _flush(rootNode: AnimatedValue): void {
var animatedStyles = new Set();
function findAnimatedStyles(node) {
if (typeof node.update === 'function') {
animatedStyles.add(node);
} else {
node.__getChildren().forEach(findAnimatedStyles);
}
}
findAnimatedStyles(rootNode);
animatedStyles.forEach(animatedStyle => animatedStyle.update());
}
/**
* Standard value for driving animations. One `Animated.Value` can drive
* multiple properties in a synchronized fashion, but can only be driven by one
* mechanism at a time. Using a new mechanism (e.g. starting a new animation,
* or calling `setValue`) will stop any previous ones.
*/
class AnimatedValue extends AnimatedWithChildren {
_value: number;
_offset: number;
_animation: ?Animation;
_tracking: ?Animated;
_listeners: {[key: string]: ValueListenerCallback};
constructor(value: number) {
super();
this._value = value;
this._offset = 0;
this._animation = null;
this._listeners = {};
}
__detach() {
this.stopAnimation();
}
__getValue(): number {
return this._value + this._offset;
}
/**
* Directly set the value. This will stop any animations running on the value
* and update all the bound properties.
*/
setValue(value: number): void {
if (this._animation) {
this._animation.stop();
this._animation = null;
}
this._updateValue(value);
}
/**
* Sets an offset that is applied on top of whatever value is set, whether via
* `setValue`, an animation, or `Animated.event`. Useful for compensating
* things like the start of a pan gesture.
*/
setOffset(offset: number): void {
this._offset = offset;
}
/**
* Merges the offset value into the base value and resets the offset to zero.
* The final output of the value is unchanged.
*/
flattenOffset(): void {
this._value += this._offset;
this._offset = 0;
}
/**
* Adds an asynchronous listener to the value so you can observe updates from
* animations. This is useful because there is no way to
* synchronously read the value because it might be driven natively.
*/
addListener(callback: ValueListenerCallback): string {
var id = guid();
this._listeners[id] = callback;
return id;
}
removeListener(id: string): void {
delete this._listeners[id];
}
removeAllListeners(): void {
this._listeners = {};
}
/**
* Stops any running animation or tracking. `callback` is invoked with the
* final value after stopping the animation, which is useful for updating
* state to match the animation position with layout.
*/
stopAnimation(callback?: ?(value: number) => void): void {
this.stopTracking();
this._animation && this._animation.stop();
this._animation = null;
callback && callback(this.__getValue());
}
/**
* Interpolates the value before updating the property, e.g. mapping 0-1 to
* 0-10.
*/
interpolate(config: InterpolationConfigType): AnimatedInterpolation {
return new AnimatedInterpolation(this, Interpolation.create(config));
}
/**
* Typically only used internally, but could be used by a custom Animation
* class.
*/
animate(animation: Animation, callback: ?EndCallback): void {
var handle = null;
if (animation.__isInteraction) {
handle = InteractionManager.current.createInteractionHandle();
}
var previousAnimation = this._animation;
this._animation && this._animation.stop();
this._animation = animation;
animation.start(
this._value,
(value) => {
this._updateValue(value);
},
(result) => {
this._animation = null;
if (handle !== null) {
InteractionManager.current.clearInteractionHandle(handle);
}
callback && callback(result);
},
previousAnimation,
);
}
/**
* Typically only used internally.
*/
stopTracking(): void {
this._tracking && this._tracking.__detach();
this._tracking = null;
}
/**
* Typically only used internally.
*/
track(tracking: Animated): void {
this.stopTracking();
this._tracking = tracking;
}
_updateValue(value: number): void {
this._value = value;
_flush(this);
for (var key in this._listeners) {
this._listeners[key]({value: this.__getValue()});
}
}
}
module.exports = AnimatedValue;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedValue.js

165
509bba0_unpacked/~/animated/src/AnimatedValueXY.js Executable file
View file

@ -0,0 +1,165 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
var AnimatedValue = require('./AnimatedValue');
var AnimatedWithChildren = require('./AnimatedWithChildren');
var invariant = require('invariant');
var guid = require('./guid');
type ValueXYListenerCallback = (value: {x: number; y: number}) => void;
/**
* 2D Value for driving 2D animations, such as pan gestures. Almost identical
* API to normal `Animated.Value`, but multiplexed. Contains two regular
* `Animated.Value`s under the hood. Example:
*
*```javascript
* class DraggableView extends React.Component {
* constructor(props) {
* super(props);
* this.state = {
* pan: new Animated.ValueXY(), // inits to zero
* };
* this.state.panResponder = PanResponder.create({
* onStartShouldSetPanResponder: () => true,
* onPanResponderMove: Animated.event([null, {
* dx: this.state.pan.x, // x,y are Animated.Value
* dy: this.state.pan.y,
* }]),
* onPanResponderRelease: () => {
* Animated.spring(
* this.state.pan, // Auto-multiplexed
* {toValue: {x: 0, y: 0}} // Back to zero
* ).start();
* },
* });
* }
* render() {
* return (
* <Animated.View
* {...this.state.panResponder.panHandlers}
* style={this.state.pan.getLayout()}>
* {this.props.children}
* </Animated.View>
* );
* }
* }
*```
*/
class AnimatedValueXY extends AnimatedWithChildren {
x: AnimatedValue;
y: AnimatedValue;
_listeners: {[key: string]: {x: string; y: string}};
constructor(valueIn?: ?{x: number | AnimatedValue; y: number | AnimatedValue}) {
super();
var value: any = valueIn || {x: 0, y: 0}; // @flowfixme: shouldn't need `: any`
if (typeof value.x === 'number' && typeof value.y === 'number') {
this.x = new AnimatedValue(value.x);
this.y = new AnimatedValue(value.y);
} else {
invariant(
value.x instanceof AnimatedValue &&
value.y instanceof AnimatedValue,
'AnimatedValueXY must be initalized with an object of numbers or ' +
'AnimatedValues.'
);
this.x = value.x;
this.y = value.y;
}
this._listeners = {};
}
setValue(value: {x: number; y: number}) {
this.x.setValue(value.x);
this.y.setValue(value.y);
}
setOffset(offset: {x: number; y: number}) {
this.x.setOffset(offset.x);
this.y.setOffset(offset.y);
}
flattenOffset(): void {
this.x.flattenOffset();
this.y.flattenOffset();
}
__getValue(): {x: number; y: number} {
return {
x: this.x.__getValue(),
y: this.y.__getValue(),
};
}
stopAnimation(callback?: ?() => number): void {
this.x.stopAnimation();
this.y.stopAnimation();
callback && callback(this.__getValue());
}
addListener(callback: ValueXYListenerCallback): string {
var id = guid();
var jointCallback = ({value: number}) => {
callback(this.__getValue());
};
this._listeners[id] = {
x: this.x.addListener(jointCallback),
y: this.y.addListener(jointCallback),
};
return id;
}
removeListener(id: string): void {
this.x.removeListener(this._listeners[id].x);
this.y.removeListener(this._listeners[id].y);
delete this._listeners[id];
}
/**
* Converts `{x, y}` into `{left, top}` for use in style, e.g.
*
*```javascript
* style={this.state.anim.getLayout()}
*```
*/
getLayout(): {[key: string]: AnimatedValue} {
return {
left: this.x,
top: this.y,
};
}
/**
* Converts `{x, y}` into a useable translation transform, e.g.
*
*```javascript
* style={{
* transform: this.state.anim.getTranslateTransform()
* }}
*```
*/
getTranslateTransform(): Array<{[key: string]: AnimatedValue}> {
return [
{translateX: this.x},
{translateY: this.y}
];
}
}
module.exports = AnimatedValueXY;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedValueXY.js

52
509bba0_unpacked/~/animated/src/AnimatedWithChildren.js Executable file
View file

@ -0,0 +1,52 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
class AnimatedWithChildren extends Animated {
_children: Array<Animated>;
constructor() {
super();
this._children = [];
}
__addChild(child: Animated): void {
if (this._children.length === 0) {
this.__attach();
}
this._children.push(child);
}
__removeChild(child: Animated): void {
var index = this._children.indexOf(child);
if (index === -1) {
console.warn('Trying to remove a child that doesn\'t exist');
return;
}
this._children.splice(index, 1);
if (this._children.length === 0) {
this.__detach();
}
}
__getChildren(): Array<Animated> {
return this._children;
}
}
module.exports = AnimatedWithChildren;
// WEBPACK FOOTER //
// ./~/animated/src/AnimatedWithChildren.js

46
509bba0_unpacked/~/animated/src/Animation.js Executable file
View file

@ -0,0 +1,46 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
export type EndResult = {finished: bool};
export type EndCallback = (result: EndResult) => void;
export type AnimationConfig = {
isInteraction?: bool;
};
// Important note: start() and stop() will only be called at most once.
// Once an animation has been stopped or finished its course, it will
// not be reused.
class Animation {
__active: bool;
__isInteraction: bool;
__onEnd: ?EndCallback;
start(
fromValue: number,
onUpdate: (value: number) => void,
onEnd: ?EndCallback,
previousAnimation: ?Animation,
): void {}
stop(): void {}
// Helper function for subclasses to make sure onEnd is only called once.
__debouncedOnEnd(result: EndResult) {
var onEnd = this.__onEnd;
this.__onEnd = null;
onEnd && onEnd(result);
}
}
module.exports = Animation;
// WEBPACK FOOTER //
// ./~/animated/src/Animation.js

88
509bba0_unpacked/~/animated/src/DecayAnimation.js Executable file
View file

@ -0,0 +1,88 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animation = require('./Animation');
var RequestAnimationFrame = require('./injectable/RequestAnimationFrame');
var CancelAnimationFrame = require('./injectable/CancelAnimationFrame');
import type { AnimationConfig, EndCallback } from './Animation';
type DecayAnimationConfigSingle = AnimationConfig & {
velocity: number;
deceleration?: number;
};
class DecayAnimation extends Animation {
_startTime: number;
_lastValue: number;
_fromValue: number;
_deceleration: number;
_velocity: number;
_onUpdate: (value: number) => void;
_animationFrame: any;
constructor(
config: DecayAnimationConfigSingle,
) {
super();
this._deceleration = config.deceleration !== undefined ? config.deceleration : 0.998;
this._velocity = config.velocity;
this.__isInteraction = config.isInteraction !== undefined ? config.isInteraction : true;
}
start(
fromValue: number,
onUpdate: (value: number) => void,
onEnd: ?EndCallback,
): void {
this.__active = true;
this._lastValue = fromValue;
this._fromValue = fromValue;
this._onUpdate = onUpdate;
this.__onEnd = onEnd;
this._startTime = Date.now();
this._animationFrame = RequestAnimationFrame.current(this.onUpdate.bind(this));
}
onUpdate(): void {
var now = Date.now();
var value = this._fromValue +
(this._velocity / (1 - this._deceleration)) *
(1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
this._onUpdate(value);
if (Math.abs(this._lastValue - value) < 0.1) {
this.__debouncedOnEnd({finished: true});
return;
}
this._lastValue = value;
if (this.__active) {
this._animationFrame = RequestAnimationFrame.current(this.onUpdate.bind(this));
}
}
stop(): void {
this.__active = false;
CancelAnimationFrame.current(this._animationFrame);
this.__debouncedOnEnd({finished: false});
}
}
module.exports = DecayAnimation;
// WEBPACK FOOTER //
// ./~/animated/src/DecayAnimation.js

150
509bba0_unpacked/~/animated/src/Easing.js Executable file
View file

@ -0,0 +1,150 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var _bezier = require('./bezier');
/**
* This class implements common easing functions. The math is pretty obscure,
* but this cool website has nice visual illustrations of what they represent:
* http://xaedes.de/dev/transitions/
*/
class Easing {
static step0(n) {
return n > 0 ? 1 : 0;
}
static step1(n) {
return n >= 1 ? 1 : 0;
}
static linear(t) {
return t;
}
static ease(t: number): number {
return ease(t);
}
static quad(t) {
return t * t;
}
static cubic(t) {
return t * t * t;
}
static poly(n) {
return (t) => Math.pow(t, n);
}
static sin(t) {
return 1 - Math.cos(t * Math.PI / 2);
}
static circle(t) {
return 1 - Math.sqrt(1 - t * t);
}
static exp(t) {
return Math.pow(2, 10 * (t - 1));
}
/**
* A simple elastic interaction, similar to a spring. Default bounciness
* is 1, which overshoots a little bit once. 0 bounciness doesn't overshoot
* at all, and bounciness of N > 1 will overshoot about N times.
*
* Wolfram Plots:
*
* http://tiny.cc/elastic_b_1 (default bounciness = 1)
* http://tiny.cc/elastic_b_3 (bounciness = 3)
*/
static elastic(bounciness: number = 1): (t: number) => number {
var p = bounciness * Math.PI;
return (t) => 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
}
static back(s: number): (t: number) => number {
if (s === undefined) {
s = 1.70158;
}
return (t) => t * t * ((s + 1) * t - s);
}
static bounce(t: number): number {
if (t < 1 / 2.75) {
return 7.5625 * t * t;
}
if (t < 2 / 2.75) {
t -= 1.5 / 2.75;
return 7.5625 * t * t + 0.75;
}
if (t < 2.5 / 2.75) {
t -= 2.25 / 2.75;
return 7.5625 * t * t + 0.9375;
}
t -= 2.625 / 2.75;
return 7.5625 * t * t + 0.984375;
}
static bezier(
x1: number,
y1: number,
x2: number,
y2: number
): (t: number) => number {
return _bezier(x1, y1, x2, y2);
}
static in(
easing: (t: number) => number,
): (t: number) => number {
return easing;
}
/**
* Runs an easing function backwards.
*/
static out(
easing: (t: number) => number,
): (t: number) => number {
return (t) => 1 - easing(1 - t);
}
/**
* Makes any easing function symmetrical.
*/
static inOut(
easing: (t: number) => number,
): (t: number) => number {
return (t) => {
if (t < 0.5) {
return easing(t * 2) / 2;
}
return 1 - easing((1 - t) * 2) / 2;
};
}
}
var ease = Easing.bezier(0.42, 0, 1, 1);
module.exports = Easing;
// WEBPACK FOOTER //
// ./~/animated/src/Easing.js

295
509bba0_unpacked/~/animated/src/Interpolation.js Executable file
View file

@ -0,0 +1,295 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
/* eslint no-bitwise: 0 */
'use strict';
var normalizeColor = require('normalize-css-color');
var invariant = require('invariant');
type ExtrapolateType = 'extend' | 'identity' | 'clamp';
export type InterpolationConfigType = {
inputRange: Array<number>;
outputRange: (Array<number> | Array<string>);
easing?: ((input: number) => number);
extrapolate?: ExtrapolateType;
extrapolateLeft?: ExtrapolateType;
extrapolateRight?: ExtrapolateType;
};
var linear = (t) => t;
/**
* Very handy helper to map input ranges to output ranges with an easing
* function and custom behavior outside of the ranges.
*/
class Interpolation {
static create(config: InterpolationConfigType): (input: number) => number | string {
if (config.outputRange && typeof config.outputRange[0] === 'string') {
return createInterpolationFromStringOutputRange(config);
}
var outputRange: Array<number> = (config.outputRange: any);
checkInfiniteRange('outputRange', outputRange);
var inputRange = config.inputRange;
checkInfiniteRange('inputRange', inputRange);
checkValidInputRange(inputRange);
invariant(
inputRange.length === outputRange.length,
'inputRange (' + inputRange.length + ') and outputRange (' +
outputRange.length + ') must have the same length'
);
var easing = config.easing || linear;
var extrapolateLeft: ExtrapolateType = 'extend';
if (config.extrapolateLeft !== undefined) {
extrapolateLeft = config.extrapolateLeft;
} else if (config.extrapolate !== undefined) {
extrapolateLeft = config.extrapolate;
}
var extrapolateRight: ExtrapolateType = 'extend';
if (config.extrapolateRight !== undefined) {
extrapolateRight = config.extrapolateRight;
} else if (config.extrapolate !== undefined) {
extrapolateRight = config.extrapolate;
}
return (input) => {
invariant(
typeof input === 'number',
'Cannot interpolation an input which is not a number'
);
var range = findRange(input, inputRange);
return interpolate(
input,
inputRange[range],
inputRange[range + 1],
outputRange[range],
outputRange[range + 1],
easing,
extrapolateLeft,
extrapolateRight,
);
};
}
}
function interpolate(
input: number,
inputMin: number,
inputMax: number,
outputMin: number,
outputMax: number,
easing: ((input: number) => number),
extrapolateLeft: ExtrapolateType,
extrapolateRight: ExtrapolateType,
) {
var result = input;
// Extrapolate
if (result < inputMin) {
if (extrapolateLeft === 'identity') {
return result;
} else if (extrapolateLeft === 'clamp') {
result = inputMin;
} else if (extrapolateLeft === 'extend') {
// noop
}
}
if (result > inputMax) {
if (extrapolateRight === 'identity') {
return result;
} else if (extrapolateRight === 'clamp') {
result = inputMax;
} else if (extrapolateRight === 'extend') {
// noop
}
}
if (outputMin === outputMax) {
return outputMin;
}
if (inputMin === inputMax) {
if (input <= inputMin) {
return outputMin;
}
return outputMax;
}
// Input Range
if (inputMin === -Infinity) {
result = -result;
} else if (inputMax === Infinity) {
result = result - inputMin;
} else {
result = (result - inputMin) / (inputMax - inputMin);
}
// Easing
result = easing(result);
// Output Range
if (outputMin === -Infinity) {
result = -result;
} else if (outputMax === Infinity) {
result = result + outputMin;
} else {
result = result * (outputMax - outputMin) + outputMin;
}
return result;
}
function colorToRgba(input: string): string {
var int32Color = normalizeColor(input);
if (int32Color === null) {
return input;
}
int32Color = int32Color || 0; // $FlowIssue
var r = (int32Color & 0xff000000) >>> 24;
var g = (int32Color & 0x00ff0000) >>> 16;
var b = (int32Color & 0x0000ff00) >>> 8;
var a = (int32Color & 0x000000ff) / 255;
return `rgba(${r}, ${g}, ${b}, ${a})`;
}
var stringShapeRegex = /[0-9\.-]+/g;
/**
* Supports string shapes by extracting numbers so new values can be computed,
* and recombines those values into new strings of the same shape. Supports
* things like:
*
* rgba(123, 42, 99, 0.36) // colors
* -45deg // values with units
*/
function createInterpolationFromStringOutputRange(
config: InterpolationConfigType,
): (input: number) => string {
var outputRange: Array<string> = (config.outputRange: any);
invariant(outputRange.length >= 2, 'Bad output range');
outputRange = outputRange.map(colorToRgba);
checkPattern(outputRange);
// ['rgba(0, 100, 200, 0)', 'rgba(50, 150, 250, 0.5)']
// ->
// [
// [0, 50],
// [100, 150],
// [200, 250],
// [0, 0.5],
// ]
/* $FlowFixMe(>=0.18.0): `outputRange[0].match()` can return `null`. Need to
* guard against this possibility.
*/
var outputRanges = outputRange[0].match(stringShapeRegex).map(() => []);
outputRange.forEach(value => {
/* $FlowFixMe(>=0.18.0): `value.match()` can return `null`. Need to guard
* against this possibility.
*/
value.match(stringShapeRegex).forEach((number, i) => {
outputRanges[i].push(+number);
});
});
/* $FlowFixMe(>=0.18.0): `outputRange[0].match()` can return `null`. Need to
* guard against this possibility.
*/
var interpolations = outputRange[0].match(stringShapeRegex).map((value, i) => {
return Interpolation.create({
...config,
outputRange: outputRanges[i],
});
});
// rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to
// round the opacity (4th column).
const shouldRound = (/^rgb/).test(outputRange[0]);
return (input) => {
var i = 0;
// 'rgba(0, 100, 200, 0)'
// ->
// 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'
return outputRange[0].replace(stringShapeRegex, () => {
const val = interpolations[i++](input);
return String(shouldRound && i < 4 ? Math.round(val) : val);
});
};
}
function checkPattern(arr: Array<string>) {
var pattern = arr[0].replace(stringShapeRegex, '');
for (var i = 1; i < arr.length; ++i) {
invariant(
pattern === arr[i].replace(stringShapeRegex, ''),
'invalid pattern ' + arr[0] + ' and ' + arr[i],
);
}
}
function findRange(input: number, inputRange: Array<number>) {
for (var i = 1; i < inputRange.length - 1; ++i) {
if (inputRange[i] >= input) {
break;
}
}
return i - 1;
}
function checkValidInputRange(arr: Array<number>) {
invariant(arr.length >= 2, 'inputRange must have at least 2 elements');
for (var i = 1; i < arr.length; ++i) {
invariant(
arr[i] >= arr[i - 1],
/* $FlowFixMe(>=0.13.0) - In the addition expression below this comment,
* one or both of the operands may be something that doesn't cleanly
* convert to a string, like undefined, null, and object, etc. If you really
* mean this implicit string conversion, you can do something like
* String(myThing)
*/
'inputRange must be monotonically increasing ' + arr
);
}
}
function checkInfiniteRange(name: string, arr: Array<number>) {
invariant(arr.length >= 2, name + ' must have at least 2 elements');
invariant(
arr.length !== 2 || arr[0] !== -Infinity || arr[1] !== Infinity,
/* $FlowFixMe(>=0.13.0) - In the addition expression below this comment,
* one or both of the operands may be something that doesn't cleanly convert
* to a string, like undefined, null, and object, etc. If you really mean
* this implicit string conversion, you can do something like
* String(myThing)
*/
name + 'cannot be ]-infinity;+infinity[ ' + arr
);
}
module.exports = Interpolation;
// WEBPACK FOOTER //
// ./~/animated/src/Interpolation.js

31
509bba0_unpacked/~/animated/src/SetPolyfill.js Executable file
View file

@ -0,0 +1,31 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
'use strict';
function SetPolyfill() {
this._cache = [];
}
SetPolyfill.prototype.add = function(e) {
if (this._cache.indexOf(e) === -1) {
this._cache.push(e);
}
};
SetPolyfill.prototype.forEach = function(cb) {
this._cache.forEach(cb);
};
module.exports = SetPolyfill;
// WEBPACK FOOTER //
// ./~/animated/src/SetPolyfill.js

229
509bba0_unpacked/~/animated/src/SpringAnimation.js Executable file
View file

@ -0,0 +1,229 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animation = require('./Animation');
var AnimatedValue = require('./AnimatedValue');
var RequestAnimationFrame = require('./injectable/RequestAnimationFrame');
var CancelAnimationFrame = require('./injectable/CancelAnimationFrame');
var invariant = require('invariant');
var SpringConfig = require('./SpringConfig');
import type { AnimationConfig, EndCallback } from './Animation';
type SpringAnimationConfigSingle = AnimationConfig & {
toValue: number | AnimatedValue;
overshootClamping?: bool;
restDisplacementThreshold?: number;
restSpeedThreshold?: number;
velocity?: number;
bounciness?: number;
speed?: number;
tension?: number;
friction?: number;
};
function withDefault<T>(value: ?T, defaultValue: T): T {
if (value === undefined || value === null) {
return defaultValue;
}
return value;
}
class SpringAnimation extends Animation {
_overshootClamping: bool;
_restDisplacementThreshold: number;
_restSpeedThreshold: number;
_initialVelocity: ?number;
_lastVelocity: number;
_startPosition: number;
_lastPosition: number;
_fromValue: number;
_toValue: any;
_tension: number;
_friction: number;
_lastTime: number;
_onUpdate: (value: number) => void;
_animationFrame: any;
constructor(
config: SpringAnimationConfigSingle,
) {
super();
this._overshootClamping = withDefault(config.overshootClamping, false);
this._restDisplacementThreshold = withDefault(config.restDisplacementThreshold, 0.001);
this._restSpeedThreshold = withDefault(config.restSpeedThreshold, 0.001);
this._initialVelocity = config.velocity;
this._lastVelocity = withDefault(config.velocity, 0);
this._toValue = config.toValue;
this.__isInteraction = config.isInteraction !== undefined ? config.isInteraction : true;
var springConfig;
if (config.bounciness !== undefined || config.speed !== undefined) {
invariant(
config.tension === undefined && config.friction === undefined,
'You can only define bounciness/speed or tension/friction but not both',
);
springConfig = SpringConfig.fromBouncinessAndSpeed(
withDefault(config.bounciness, 8),
withDefault(config.speed, 12),
);
} else {
springConfig = SpringConfig.fromOrigamiTensionAndFriction(
withDefault(config.tension, 40),
withDefault(config.friction, 7),
);
}
this._tension = springConfig.tension;
this._friction = springConfig.friction;
}
start(
fromValue: number,
onUpdate: (value: number) => void,
onEnd: ?EndCallback,
previousAnimation: ?Animation,
): void {
this.__active = true;
this._startPosition = fromValue;
this._lastPosition = this._startPosition;
this._onUpdate = onUpdate;
this.__onEnd = onEnd;
this._lastTime = Date.now();
if (previousAnimation instanceof SpringAnimation) {
var internalState = previousAnimation.getInternalState();
this._lastPosition = internalState.lastPosition;
this._lastVelocity = internalState.lastVelocity;
this._lastTime = internalState.lastTime;
}
if (this._initialVelocity !== undefined &&
this._initialVelocity !== null) {
this._lastVelocity = this._initialVelocity;
}
this.onUpdate();
}
getInternalState(): Object {
return {
lastPosition: this._lastPosition,
lastVelocity: this._lastVelocity,
lastTime: this._lastTime,
};
}
onUpdate(): void {
var position = this._lastPosition;
var velocity = this._lastVelocity;
var tempPosition = this._lastPosition;
var tempVelocity = this._lastVelocity;
// If for some reason we lost a lot of frames (e.g. process large payload or
// stopped in the debugger), we only advance by 4 frames worth of
// computation and will continue on the next frame. It's better to have it
// running at faster speed than jumping to the end.
var MAX_STEPS = 64;
var now = Date.now();
if (now > this._lastTime + MAX_STEPS) {
now = this._lastTime + MAX_STEPS;
}
// We are using a fixed time step and a maximum number of iterations.
// The following post provides a lot of thoughts into how to build this
// loop: http://gafferongames.com/game-physics/fix-your-timestep/
var TIMESTEP_MSEC = 1;
var numSteps = Math.floor((now - this._lastTime) / TIMESTEP_MSEC);
for (var i = 0; i < numSteps; ++i) {
// Velocity is based on seconds instead of milliseconds
var step = TIMESTEP_MSEC / 1000;
// This is using RK4. A good blog post to understand how it works:
// http://gafferongames.com/game-physics/integration-basics/
var aVelocity = velocity;
var aAcceleration = this._tension * (this._toValue - tempPosition) - this._friction * tempVelocity;
var tempPosition = position + aVelocity * step / 2;
var tempVelocity = velocity + aAcceleration * step / 2;
var bVelocity = tempVelocity;
var bAcceleration = this._tension * (this._toValue - tempPosition) - this._friction * tempVelocity;
tempPosition = position + bVelocity * step / 2;
tempVelocity = velocity + bAcceleration * step / 2;
var cVelocity = tempVelocity;
var cAcceleration = this._tension * (this._toValue - tempPosition) - this._friction * tempVelocity;
tempPosition = position + cVelocity * step / 2;
tempVelocity = velocity + cAcceleration * step / 2;
var dVelocity = tempVelocity;
var dAcceleration = this._tension * (this._toValue - tempPosition) - this._friction * tempVelocity;
tempPosition = position + cVelocity * step / 2;
tempVelocity = velocity + cAcceleration * step / 2;
var dxdt = (aVelocity + 2 * (bVelocity + cVelocity) + dVelocity) / 6;
var dvdt = (aAcceleration + 2 * (bAcceleration + cAcceleration) + dAcceleration) / 6;
position += dxdt * step;
velocity += dvdt * step;
}
this._lastTime = now;
this._lastPosition = position;
this._lastVelocity = velocity;
this._onUpdate(position);
if (!this.__active) { // a listener might have stopped us in _onUpdate
return;
}
// Conditions for stopping the spring animation
var isOvershooting = false;
if (this._overshootClamping && this._tension !== 0) {
if (this._startPosition < this._toValue) {
isOvershooting = position > this._toValue;
} else {
isOvershooting = position < this._toValue;
}
}
var isVelocity = Math.abs(velocity) <= this._restSpeedThreshold;
var isDisplacement = true;
if (this._tension !== 0) {
isDisplacement = Math.abs(this._toValue - position) <= this._restDisplacementThreshold;
}
if (isOvershooting || (isVelocity && isDisplacement)) {
if (this._tension !== 0) {
// Ensure that we end up with a round value
this._onUpdate(this._toValue);
}
this.__debouncedOnEnd({finished: true});
return;
}
this._animationFrame = RequestAnimationFrame.current(this.onUpdate.bind(this));
}
stop(): void {
this.__active = false;
CancelAnimationFrame.current(this._animationFrame);
this.__debouncedOnEnd({finished: false});
}
}
module.exports = SpringAnimation;
// WEBPACK FOOTER //
// ./~/animated/src/SpringAnimation.js

106
509bba0_unpacked/~/animated/src/SpringConfig.js Executable file
View file

@ -0,0 +1,106 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
type SpringConfigType = {
tension: number,
friction: number,
};
function tensionFromOrigamiValue(oValue) {
return (oValue - 30) * 3.62 + 194;
}
function frictionFromOrigamiValue(oValue) {
return (oValue - 8) * 3 + 25;
}
function fromOrigamiTensionAndFriction(
tension: number,
friction: number,
): SpringConfigType {
return {
tension: tensionFromOrigamiValue(tension),
friction: frictionFromOrigamiValue(friction)
};
}
function fromBouncinessAndSpeed(
bounciness: number,
speed: number,
): SpringConfigType {
function normalize(value, startValue, endValue) {
return (value - startValue) / (endValue - startValue);
}
function projectNormal(n, start, end) {
return start + (n * (end - start));
}
function linearInterpolation(t, start, end) {
return t * end + (1 - t) * start;
}
function quadraticOutInterpolation(t, start, end) {
return linearInterpolation(2 * t - t * t, start, end);
}
function b3Friction1(x) {
return (0.0007 * Math.pow(x, 3)) -
(0.031 * Math.pow(x, 2)) + 0.64 * x + 1.28;
}
function b3Friction2(x) {
return (0.000044 * Math.pow(x, 3)) -
(0.006 * Math.pow(x, 2)) + 0.36 * x + 2;
}
function b3Friction3(x) {
return (0.00000045 * Math.pow(x, 3)) -
(0.000332 * Math.pow(x, 2)) + 0.1078 * x + 5.84;
}
function b3Nobounce(tension) {
if (tension <= 18) {
return b3Friction1(tension);
} else if (tension > 18 && tension <= 44) {
return b3Friction2(tension);
} else {
return b3Friction3(tension);
}
}
var b = normalize(bounciness / 1.7, 0, 20);
b = projectNormal(b, 0, 0.8);
var s = normalize(speed / 1.7, 0, 20);
var bouncyTension = projectNormal(s, 0.5, 200);
var bouncyFriction = quadraticOutInterpolation(
b,
b3Nobounce(bouncyTension),
0.01
);
return {
tension: tensionFromOrigamiValue(bouncyTension),
friction: frictionFromOrigamiValue(bouncyFriction)
};
}
module.exports = {
fromOrigamiTensionAndFriction,
fromBouncinessAndSpeed,
};
// WEBPACK FOOTER //
// ./~/animated/src/SpringConfig.js

115
509bba0_unpacked/~/animated/src/TimingAnimation.js Executable file
View file

@ -0,0 +1,115 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animation = require('./Animation');
var AnimatedValue = require('./AnimatedValue');
var Easing = require('./Easing');
var RequestAnimationFrame = require('./injectable/RequestAnimationFrame');
var CancelAnimationFrame = require('./injectable/CancelAnimationFrame');
import type { AnimationConfig, EndCallback } from './Animation';
var easeInOut = Easing.inOut(Easing.ease);
type TimingAnimationConfigSingle = AnimationConfig & {
toValue: number | AnimatedValue;
easing?: (value: number) => number;
duration?: number;
delay?: number;
};
class TimingAnimation extends Animation {
_startTime: number;
_fromValue: number;
_toValue: any;
_duration: number;
_delay: number;
_easing: (value: number) => number;
_onUpdate: (value: number) => void;
_animationFrame: any;
_timeout: any;
constructor(
config: TimingAnimationConfigSingle,
) {
super();
this._toValue = config.toValue;
this._easing = config.easing !== undefined ? config.easing : easeInOut;
this._duration = config.duration !== undefined ? config.duration : 500;
this._delay = config.delay !== undefined ? config.delay : 0;
this.__isInteraction = config.isInteraction !== undefined ? config.isInteraction : true;
}
start(
fromValue: number,
onUpdate: (value: number) => void,
onEnd: ?EndCallback,
): void {
this.__active = true;
this._fromValue = fromValue;
this._onUpdate = onUpdate;
this.__onEnd = onEnd;
var start = () => {
if (this._duration === 0) {
this._onUpdate(this._toValue);
this.__debouncedOnEnd({finished: true});
} else {
this._startTime = Date.now();
this._animationFrame = RequestAnimationFrame.current(this.onUpdate.bind(this));
}
};
if (this._delay) {
this._timeout = setTimeout(start, this._delay);
} else {
start();
}
}
onUpdate(): void {
var now = Date.now();
if (now >= this._startTime + this._duration) {
if (this._duration === 0) {
this._onUpdate(this._toValue);
} else {
this._onUpdate(
this._fromValue + this._easing(1) * (this._toValue - this._fromValue)
);
}
this.__debouncedOnEnd({finished: true});
return;
}
this._onUpdate(
this._fromValue +
this._easing((now - this._startTime) / this._duration) *
(this._toValue - this._fromValue)
);
if (this.__active) {
this._animationFrame = RequestAnimationFrame.current(this.onUpdate.bind(this));
}
}
stop(): void {
this.__active = false;
clearTimeout(this._timeout);
CancelAnimationFrame.current(this._animationFrame);
this.__debouncedOnEnd({finished: false});
}
}
module.exports = TimingAnimation;
// WEBPACK FOOTER //
// ./~/animated/src/TimingAnimation.js

110
509bba0_unpacked/~/animated/src/bezier.js Executable file
View file

@ -0,0 +1,110 @@
/**
* https://github.com/gre/bezier-easing
* BezierEasing - use bezier curve for transition easing function
* by Gaëtan Renaudeau 2014 - 2015 – MIT License
* @nolint
*/
// These values are established by empiricism with tests (tradeoff: performance VS precision)
var NEWTON_ITERATIONS = 4;
var NEWTON_MIN_SLOPE = 0.001;
var SUBDIVISION_PRECISION = 0.0000001;
var SUBDIVISION_MAX_ITERATIONS = 10;
var kSplineTableSize = 11;
var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
var float32ArraySupported = typeof Float32Array === 'function';
function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
function C (aA1) { return 3.0 * aA1; }
// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }
// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }
function binarySubdivide (aX, aA, aB, mX1, mX2) {
var currentX, currentT, i = 0;
do {
currentT = aA + (aB - aA) / 2.0;
currentX = calcBezier(currentT, mX1, mX2) - aX;
if (currentX > 0.0) {
aB = currentT;
} else {
aA = currentT;
}
} while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
return currentT;
}
function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
var currentSlope = getSlope(aGuessT, mX1, mX2);
if (currentSlope === 0.0) {
return aGuessT;
}
var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
aGuessT -= currentX / currentSlope;
}
return aGuessT;
}
module.exports = function bezier (mX1, mY1, mX2, mY2) {
if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) { // eslint-disable-line yoda
throw new Error('bezier x values must be in [0, 1] range');
}
// Precompute samples table
var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
if (mX1 !== mY1 || mX2 !== mY2) {
for (var i = 0; i < kSplineTableSize; ++i) {
sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
}
}
function getTForX (aX) {
var intervalStart = 0.0;
var currentSample = 1;
var lastSample = kSplineTableSize - 1;
for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
intervalStart += kSampleStepSize;
}
--currentSample;
// Interpolate to provide an initial guess for t
var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
var guessForT = intervalStart + dist * kSampleStepSize;
var initialSlope = getSlope(guessForT, mX1, mX2);
if (initialSlope >= NEWTON_MIN_SLOPE) {
return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
} else if (initialSlope === 0.0) {
return guessForT;
} else {
return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
}
}
return function BezierEasing (x) {
if (mX1 === mY1 && mX2 === mY2) {
return x; // linear
}
// Because JavaScript number are imprecise, we should guarantee the extremes are right.
if (x === 0) {
return 0;
}
if (x === 1) {
return 1;
}
return calcBezier(getTForX(x), mY1, mY2);
};
};
// WEBPACK FOOTER //
// ./~/animated/src/bezier.js

113
509bba0_unpacked/~/animated/src/createAnimatedComponent.js Executable file
View file

@ -0,0 +1,113 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var React = require('react');
var AnimatedProps = require('./AnimatedProps');
var ApplyAnimatedValues = require('./injectable/ApplyAnimatedValues');
function createAnimatedComponent(Component: any): any {
var refName = 'node';
class AnimatedComponent extends React.Component {
_propsAnimated: AnimatedProps;
componentWillUnmount() {
this._propsAnimated && this._propsAnimated.__detach();
}
setNativeProps(props) {
var didUpdate = ApplyAnimatedValues.current(this.refs[refName], props, this);
if (didUpdate === false) {
this.forceUpdate();
}
}
componentWillMount() {
this.attachProps(this.props);
}
attachProps(nextProps) {
var oldPropsAnimated = this._propsAnimated;
// The system is best designed when setNativeProps is implemented. It is
// able to avoid re-rendering and directly set the attributes that
// changed. However, setNativeProps can only be implemented on leaf
// native components. If you want to animate a composite component, you
// need to re-render it. In this case, we have a fallback that uses
// forceUpdate.
var callback = () => {
var didUpdate = ApplyAnimatedValues.current(this.refs[refName], this._propsAnimated.__getAnimatedValue(), this);
if (didUpdate === false) {
this.forceUpdate();
}
};
this._propsAnimated = new AnimatedProps(
nextProps,
callback,
);
// When you call detach, it removes the element from the parent list
// of children. If it goes to 0, then the parent also detaches itself
// and so on.
// An optimization is to attach the new elements and THEN detach the old
// ones instead of detaching and THEN attaching.
// This way the intermediate state isn't to go to 0 and trigger
// this expensive recursive detaching to then re-attach everything on
// the very next operation.
oldPropsAnimated && oldPropsAnimated.__detach();
}
componentWillReceiveProps(nextProps) {
this.attachProps(nextProps);
}
render() {
return (
<Component
{...this._propsAnimated.__getValue()}
ref={refName}
/>
);
}
}
AnimatedComponent.propTypes = {
style: function(props, propName, componentName) {
if (!Component.propTypes) {
return;
}
// TODO(lmr): We will probably bring this back in at some point, but maybe
// just a subset of the proptypes... We should have a common set of props
// that will be used for all platforms.
//
// for (var key in ViewStylePropTypes) {
// if (!Component.propTypes[key] && props[key] !== undefined) {
// console.error(
// 'You are setting the style `{ ' + key + ': ... }` as a prop. You ' +
// 'should nest it in a style object. ' +
// 'E.g. `{ style: { ' + key + ': ... } }`'
// );
// }
// }
}
};
return AnimatedComponent;
}
module.exports = createAnimatedComponent;
// WEBPACK FOOTER //
// ./~/animated/src/createAnimatedComponent.js

22
509bba0_unpacked/~/animated/src/guid.js Executable file
View file

@ -0,0 +1,22 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var _uniqueId = 0;
module.exports = function uniqueId(): string {
return String(_uniqueId++);
};
// WEBPACK FOOTER //
// ./~/animated/src/guid.js

518
509bba0_unpacked/~/animated/src/index.js Executable file
View file

@ -0,0 +1,518 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var invariant = require('invariant');
var Animated = require('./Animated');
var AnimatedValue = require('./AnimatedValue');
var AnimatedValueXY = require('./AnimatedValueXY');
var AnimatedAddition = require('./AnimatedAddition');
var AnimatedMultiplication = require('./AnimatedMultiplication');
var AnimatedModulo = require('./AnimatedModulo');
var AnimatedTemplate = require('./AnimatedTemplate');
var AnimatedTracking = require('./AnimatedTracking');
var isAnimated = require('./isAnimated');
var Animation = require('./Animation');
var TimingAnimation = require('./TimingAnimation');
var DecayAnimation = require('./DecayAnimation');
var SpringAnimation = require('./SpringAnimation');
import type { InterpolationConfigType } from './Interpolation';
import type { AnimationConfig, EndResult, EndCallback } from './Animation';
type TimingAnimationConfig = AnimationConfig & {
toValue: number | AnimatedValue | {x: number, y: number} | AnimatedValueXY;
easing?: (value: number) => number;
duration?: number;
delay?: number;
};
type DecayAnimationConfig = AnimationConfig & {
velocity: number | {x: number, y: number};
deceleration?: number;
};
type SpringAnimationConfig = AnimationConfig & {
toValue: number | AnimatedValue | {x: number, y: number} | AnimatedValueXY;
overshootClamping?: bool;
restDisplacementThreshold?: number;
restSpeedThreshold?: number;
velocity?: number | {x: number, y: number};
bounciness?: number;
speed?: number;
tension?: number;
friction?: number;
};
type CompositeAnimation = {
start: (callback?: ?EndCallback) => void;
stop: () => void;
};
var maybeVectorAnim = function(
value: AnimatedValue | AnimatedValueXY,
config: Object,
anim: (value: AnimatedValue, config: Object) => CompositeAnimation
): ?CompositeAnimation {
if (value instanceof AnimatedValueXY) {
var configX = {...config};
var configY = {...config};
for (var key in config) {
var {x, y} = config[key];
if (x !== undefined && y !== undefined) {
configX[key] = x;
configY[key] = y;
}
}
var aX = anim((value: AnimatedValueXY).x, configX);
var aY = anim((value: AnimatedValueXY).y, configY);
// We use `stopTogether: false` here because otherwise tracking will break
// because the second animation will get stopped before it can update.
return parallel([aX, aY], {stopTogether: false});
}
return null;
};
var spring = function(
value: AnimatedValue | AnimatedValueXY,
config: SpringAnimationConfig,
): CompositeAnimation {
return maybeVectorAnim(value, config, spring) || {
start: function(callback?: ?EndCallback): void {
var singleValue: any = value;
var singleConfig: any = config;
singleValue.stopTracking();
if (config.toValue instanceof Animated) {
singleValue.track(new AnimatedTracking(
singleValue,
config.toValue,
SpringAnimation,
singleConfig,
callback
));
} else {
singleValue.animate(new SpringAnimation(singleConfig), callback);
}
},
stop: function(): void {
value.stopAnimation();
},
};
};
var timing = function(
value: AnimatedValue | AnimatedValueXY,
config: TimingAnimationConfig,
): CompositeAnimation {
return maybeVectorAnim(value, config, timing) || {
start: function(callback?: ?EndCallback): void {
var singleValue: any = value;
var singleConfig: any = config;
singleValue.stopTracking();
if (config.toValue instanceof Animated) {
singleValue.track(new AnimatedTracking(
singleValue,
config.toValue,
TimingAnimation,
singleConfig,
callback
));
} else {
singleValue.animate(new TimingAnimation(singleConfig), callback);
}
},
stop: function(): void {
value.stopAnimation();
},
};
};
var decay = function(
value: AnimatedValue | AnimatedValueXY,
config: DecayAnimationConfig,
): CompositeAnimation {
return maybeVectorAnim(value, config, decay) || {
start: function(callback?: ?EndCallback): void {
var singleValue: any = value;
var singleConfig: any = config;
singleValue.stopTracking();
singleValue.animate(new DecayAnimation(singleConfig), callback);
},
stop: function(): void {
value.stopAnimation();
},
};
};
var sequence = function(
animations: Array<CompositeAnimation>,
): CompositeAnimation {
var current = 0;
return {
start: function(callback?: ?EndCallback) {
var onComplete = function(result) {
if (!result.finished) {
callback && callback(result);
return;
}
current++;
if (current === animations.length) {
callback && callback(result);
return;
}
animations[current].start(onComplete);
};
if (animations.length === 0) {
callback && callback({finished: true});
} else {
animations[current].start(onComplete);
}
},
stop: function() {
if (current < animations.length) {
animations[current].stop();
}
}
};
};
type ParallelConfig = {
stopTogether?: bool; // If one is stopped, stop all. default: true
}
var parallel = function(
animations: Array<CompositeAnimation>,
config?: ?ParallelConfig,
): CompositeAnimation {
var doneCount = 0;
// Make sure we only call stop() at most once for each animation
var hasEnded = {};
var stopTogether = !(config && config.stopTogether === false);
var result = {
start: function(callback?: ?EndCallback) {
if (doneCount === animations.length) {
callback && callback({finished: true});
return;
}
animations.forEach((animation, idx) => {
var cb = function(endResult) {
hasEnded[idx] = true;
doneCount++;
if (doneCount === animations.length) {
doneCount = 0;
callback && callback(endResult);
return;
}
if (!endResult.finished && stopTogether) {
result.stop();
}
};
if (!animation) {
cb({finished: true});
} else {
animation.start(cb);
}
});
},
stop: function(): void {
animations.forEach((animation, idx) => {
!hasEnded[idx] && animation.stop();
hasEnded[idx] = true;
});
}
};
return result;
};
var delay = function(time: number): CompositeAnimation {
// Would be nice to make a specialized implementation
return timing(new AnimatedValue(0), {toValue: 0, delay: time, duration: 0});
};
var stagger = function(
time: number,
animations: Array<CompositeAnimation>,
): CompositeAnimation {
return parallel(animations.map((animation, i) => {
return sequence([
delay(time * i),
animation,
]);
}));
};
type Mapping = {[key: string]: Mapping} | AnimatedValue;
type EventConfig = {listener?: ?Function};
var event = function(
argMapping: Array<?Mapping>,
config?: ?EventConfig,
): () => void {
return function(...args): void {
var traverse = function(recMapping, recEvt, key) {
if (typeof recEvt === 'number') {
invariant(
recMapping instanceof AnimatedValue,
'Bad mapping of type ' + typeof recMapping + ' for key ' + key +
', event value must map to AnimatedValue'
);
recMapping.setValue(recEvt);
return;
}
invariant(
typeof recMapping === 'object',
'Bad mapping of type ' + typeof recMapping + ' for key ' + key
);
invariant(
typeof recEvt === 'object',
'Bad event of type ' + typeof recEvt + ' for key ' + key
);
for (var key in recMapping) {
traverse(recMapping[key], recEvt[key], key);
}
};
argMapping.forEach((mapping, idx) => {
traverse(mapping, args[idx], 'arg' + idx);
});
if (config && config.listener) {
config.listener.apply(null, args);
}
};
};
/**
* Animations are an important part of modern UX, and the `Animated`
* library is designed to make them fluid, powerful, and easy to build and
* maintain.
*
* The simplest workflow is to create an `Animated.Value`, hook it up to one or
* more style attributes of an animated component, and then drive updates either
* via animations, such as `Animated.timing`, or by hooking into gestures like
* panning or scrolling via `Animated.event`. `Animated.Value` can also bind to
* props other than style, and can be interpolated as well. Here is a basic
* example of a container view that will fade in when it's mounted:
*
*```javascript
* class FadeInView extends React.Component {
* constructor(props) {
* super(props);
* this.state = {
* fadeAnim: new Animated.Value(0), // init opacity 0
* };
* }
* componentDidMount() {
* Animated.timing( // Uses easing functions
* this.state.fadeAnim, // The value to drive
* {toValue: 1}, // Configuration
* ).start(); // Don't forget start!
* }
* render() {
* return (
* <Animated.View // Special animatable View
* style={{opacity: this.state.fadeAnim}}> // Binds
* {this.props.children}
* </Animated.View>
* );
* }
* }
*```
*
* Note that only animatable components can be animated. `View`, `Text`, and
* `Image` are already provided, and you can create custom ones with
* `createAnimatedComponent`. These special components do the magic of binding
* the animated values to the properties, and do targeted native updates to
* avoid the cost of the react render and reconciliation process on every frame.
* They also handle cleanup on unmount so they are safe by default.
*
* Animations are heavily configurable. Custom and pre-defined easing
* functions, delays, durations, decay factors, spring constants, and more can
* all be tweaked depending on the type of animation.
*
* A single `Animated.Value` can drive any number of properties, and each
* property can be run through an interpolation first. An interpolation maps
* input ranges to output ranges, typically using a linear interpolation but
* also supports easing functions. By default, it will extrapolate the curve
* beyond the ranges given, but you can also have it clamp the output value.
*
* For example, you may want to think about your `Animated.Value` as going from
* 0 to 1, but animate the position from 150px to 0px and the opacity from 0 to
* 1. This can easily be done by modifying `style` in the example above like so:
*
*```javascript
* style={{
* opacity: this.state.fadeAnim, // Binds directly
* transform: [{
* translateY: this.state.fadeAnim.interpolate({
* inputRange: [0, 1],
* outputRange: [150, 0] // 0 : 150, 0.5 : 75, 1 : 0
* }),
* }],
* }}>
*```
*
* Animations can also be combined in complex ways using composition functions
* such as `sequence` and `parallel`, and can also be chained together simply
* by setting the `toValue` of one animation to be another `Animated.Value`.
*
* `Animated.ValueXY` is handy for 2D animations, like panning, and there are
* other helpful additions like `setOffset` and `getLayout` to aid with typical
* interaction patterns, like drag-and-drop.
*
* You can see more example usage in `AnimationExample.js`, the Gratuitous
* Animation App, and [Animations documentation guide](docs/animations.html).
*
* Note that `Animated` is designed to be fully serializable so that animations
* can be run in a high performance way, independent of the normal JavaScript
* event loop. This does influence the API, so keep that in mind when it seems a
* little trickier to do something compared to a fully synchronous system.
* Checkout `Animated.Value.addListener` as a way to work around some of these
* limitations, but use it sparingly since it might have performance
* implications in the future.
*/
module.exports = {
/**
* Standard value class for driving animations. Typically initialized with
* `new Animated.Value(0);`
*/
Value: AnimatedValue,
/**
* 2D value class for driving 2D animations, such as pan gestures.
*/
ValueXY: AnimatedValueXY,
/**
* Animates a value from an initial velocity to zero based on a decay
* coefficient.
*/
decay,
/**
* Animates a value along a timed easing curve. The `Easing` module has tons
* of pre-defined curves, or you can use your own function.
*/
timing,
/**
* Spring animation based on Rebound and Origami. Tracks velocity state to
* create fluid motions as the `toValue` updates, and can be chained together.
*/
spring,
/**
* Creates a new Animated value composed from two Animated values added
* together.
*/
add: function add(a: Animated, b: Animated): AnimatedAddition {
return new AnimatedAddition(a, b);
},
/**
* Creates a new Animated value composed from two Animated values multiplied
* together.
*/
multiply: function multiply(a: Animated, b: Animated): AnimatedMultiplication {
return new AnimatedMultiplication(a, b);
},
/**
* Creates a new Animated value that is the (non-negative) modulo of the
* provided Animated value
*/
modulo: function modulo(a: Animated, modulus: number): AnimatedModulo {
return new AnimatedModulo(a, modulus);
},
/**
* Creates a new Animated value that is the specified string, with each
* substitution expression being separately animated and interpolated.
*/
template: function template(strings, ...values) {
return new AnimatedTemplate(strings, values);
},
/**
* Starts an animation after the given delay.
*/
delay,
/**
* Starts an array of animations in order, waiting for each to complete
* before starting the next. If the current running animation is stopped, no
* following animations will be started.
*/
sequence,
/**
* Starts an array of animations all at the same time. By default, if one
* of the animations is stopped, they will all be stopped. You can override
* this with the `stopTogether` flag.
*/
parallel,
/**
* Array of animations may run in parallel (overlap), but are started in
* sequence with successive delays. Nice for doing trailing effects.
*/
stagger,
/**
* Takes an array of mappings and extracts values from each arg accordingly,
* then calls `setValue` on the mapped outputs. e.g.
*
*```javascript
* onScroll={Animated.event(
* [{nativeEvent: {contentOffset: {x: this._scrollX}}}]
* {listener}, // Optional async listener
* )
* ...
* onPanResponderMove: Animated.event([
* null, // raw event arg ignored
* {dx: this._panX}, // gestureState arg
* ]),
*```
*/
event,
/**
* Existential test to figure out if an object is an instance of the Animated
* class or not.
*/
isAnimated,
/**
* Make any React component Animatable. Used to create `Animated.View`, etc.
*/
createAnimatedComponent: require('./createAnimatedComponent'),
inject: {
ApplyAnimatedValues: require('./injectable/ApplyAnimatedValues').inject,
InteractionManager: require('./injectable/InteractionManager').inject,
FlattenStyle: require('./injectable/FlattenStyle').inject,
RequestAnimationFrame: require('./injectable/RequestAnimationFrame').inject,
CancelAnimationFrame: require('./injectable/CancelAnimationFrame').inject,
},
__PropsOnlyForTests: require('./AnimatedProps'),
};
// WEBPACK FOOTER //
// ./~/animated/src/index.js

31
509bba0_unpacked/~/animated/src/injectable/ApplyAnimatedValues.js Executable file
View file

@ -0,0 +1,31 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var ApplyAnimatedValues = {
current: function ApplyAnimatedValues(instance, props) {
if (instance.setNativeProps) {
instance.setNativeProps(props);
} else {
return false;
}
},
inject(apply) {
ApplyAnimatedValues.current = apply;
},
};
module.exports = ApplyAnimatedValues;
// WEBPACK FOOTER //
// ./~/animated/src/injectable/ApplyAnimatedValues.js

25
509bba0_unpacked/~/animated/src/injectable/CancelAnimationFrame.js Executable file
View file

@ -0,0 +1,25 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var CancelAnimationFrame = {
current: id => global.cancelAnimationFrame(id),
inject(injected) {
CancelAnimationFrame.current = injected;
},
};
module.exports = CancelAnimationFrame;
// WEBPACK FOOTER //
// ./~/animated/src/injectable/CancelAnimationFrame.js

25
509bba0_unpacked/~/animated/src/injectable/FlattenStyle.js Executable file
View file

@ -0,0 +1,25 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var FlattenStyle = {
current: style => style,
inject(flatten) {
FlattenStyle.current = flatten;
},
};
module.exports = FlattenStyle;
// WEBPACK FOOTER //
// ./~/animated/src/injectable/FlattenStyle.js

28
509bba0_unpacked/~/animated/src/injectable/InteractionManager.js Executable file
View file

@ -0,0 +1,28 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var InteractionManager = {
current: {
createInteractionHandle: function() {},
clearInteractionHandle: function() {},
},
inject(manager) {
InteractionManager.current = manager;
},
};
module.exports = InteractionManager;
// WEBPACK FOOTER //
// ./~/animated/src/injectable/InteractionManager.js

25
509bba0_unpacked/~/animated/src/injectable/RequestAnimationFrame.js Executable file
View file

@ -0,0 +1,25 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var RequestAnimationFrame = {
current: cb => global.requestAnimationFrame(cb),
inject(injected) {
RequestAnimationFrame.current = injected;
},
};
module.exports = RequestAnimationFrame;
// WEBPACK FOOTER //
// ./~/animated/src/injectable/RequestAnimationFrame.js

24
509bba0_unpacked/~/animated/src/isAnimated.js Executable file
View file

@ -0,0 +1,24 @@
/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @flow
*/
'use strict';
var Animated = require('./Animated');
function isAnimated(obj) {
return obj instanceof Animated;
}
module.exports = isAnimated;
// WEBPACK FOOTER //
// ./~/animated/src/isAnimated.js

12915
509bba0_unpacked/~/bodymovin/build/player/bodymovin.js Executable file
View file

File diff suppressed because it is too large Load diff

45
509bba0_unpacked/~/combokeys/plugins/global-bind/index.js Executable file
View file

@ -0,0 +1,45 @@
/* eslint-env node, browser */
'use strict'
/**
* adds a bindGlobal method to Combokeys that allows you to
* bind specific keyboard shortcuts that will still work
* inside a text input field
*
* usage:
* Combokeys.bindGlobal("ctrl+s", _saveChanges)
*/
module.exports = function (Combokeys) {
var globalCallbacks = {}
var originalStopCallback = Combokeys.stopCallback
Combokeys.stopCallback = function (e, element, combo, sequence) {
if (globalCallbacks[combo] || globalCallbacks[sequence]) {
return false
}
return originalStopCallback(e, element, combo)
}
Combokeys.bindGlobal = function (keys, callback, action) {
this.bind(keys, callback, action)
if (keys instanceof Array) {
for (var i = 0; i < keys.length; i++) {
globalCallbacks[keys[i]] = true
}
return
}
globalCallbacks[keys] = true
}
return Combokeys
}
//////////////////
// WEBPACK FOOTER
// ./~/combokeys/plugins/global-bind/index.js
// module id = 862
// module chunks = 2

2206
509bba0_unpacked/~/intl/locale-data/json/en.json Executable file
View file

File diff suppressed because it is too large Load diff

371
509bba0_unpacked/~/normalize-css-color/index.js Executable file
View file

@ -0,0 +1,371 @@
/*
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
function normalizeColor(color) {
var match;
if (typeof color === 'number') {
if (color >>> 0 === color && color >= 0 && color <= 0xffffffff) {
return color;
}
return null;
}
// Ordered based on occurrences on Facebook codebase
if ((match = matchers.hex6.exec(color))) {
return parseInt(match[1] + 'ff', 16) >>> 0;
}
if (names.hasOwnProperty(color)) {
return names[color];
}
if ((match = matchers.rgb.exec(color))) {
return (
parse255(match[1]) << 24 | // r
parse255(match[2]) << 16 | // g
parse255(match[3]) << 8 | // b
0x000000ff // a
) >>> 0;
}
if ((match = matchers.rgba.exec(color))) {
return (
parse255(match[1]) << 24 | // r
parse255(match[2]) << 16 | // g
parse255(match[3]) << 8 | // b
parse1(match[4]) // a
) >>> 0;
}
if ((match = matchers.hex3.exec(color))) {
return parseInt(
match[1] + match[1] + // r
match[2] + match[2] + // g
match[3] + match[3] + // b
'ff', // a
16
) >>> 0;
}
// https://drafts.csswg.org/css-color-4/#hex-notation
if ((match = matchers.hex8.exec(color))) {
return parseInt(match[1], 16) >>> 0;
}
if ((match = matchers.hex4.exec(color))) {
return parseInt(
match[1] + match[1] + // r
match[2] + match[2] + // g
match[3] + match[3] + // b
match[4] + match[4], // a
16
) >>> 0;
}
if ((match = matchers.hsl.exec(color))) {
return (
hslToRgb(
parse360(match[1]), // h
parsePercentage(match[2]), // s
parsePercentage(match[3]) // l
) |
0x000000ff // a
) >>> 0;
}
if ((match = matchers.hsla.exec(color))) {
return (
hslToRgb(
parse360(match[1]), // h
parsePercentage(match[2]), // s
parsePercentage(match[3]) // l
) |
parse1(match[4]) // a
) >>> 0;
}
return null;
}
function hue2rgb(p, q, t) {
if (t < 0) {
t += 1;
}
if (t > 1) {
t -= 1;
}
if (t < 1 / 6) {
return p + (q - p) * 6 * t;
}
if (t < 1 / 2) {
return q;
}
if (t < 2 / 3) {
return p + (q - p) * (2 / 3 - t) * 6;
}
return p;
}
function hslToRgb(h, s, l) {
var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
var p = 2 * l - q;
var r = hue2rgb(p, q, h + 1 / 3);
var g = hue2rgb(p, q, h);
var b = hue2rgb(p, q, h - 1 / 3);
return (
Math.round(r * 255) << 24 |
Math.round(g * 255) << 16 |
Math.round(b * 255) << 8
);
}
// var INTEGER = '[-+]?\\d+';
var NUMBER = '[-+]?\\d*\\.?\\d+';
var PERCENTAGE = NUMBER + '%';
function toArray(arrayLike) {
return Array.prototype.slice.call(arrayLike, 0);
}
function call() {
return '\\(\\s*(' + toArray(arguments).join(')\\s*,\\s*(') + ')\\s*\\)';
}
var matchers = {
rgb: new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER)),
rgba: new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER)),
hsl: new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE)),
hsla: new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER)),
hex3: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
hex4: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
hex6: /^#([0-9a-fA-F]{6})$/,
hex8: /^#([0-9a-fA-F]{8})$/,
};
function parse255(str) {
var int = parseInt(str, 10);
if (int < 0) {
return 0;
}
if (int > 255) {
return 255;
}
return int;
}
function parse360(str) {
var int = parseFloat(str);
return (((int % 360) + 360) % 360) / 360;
}
function parse1(str) {
var num = parseFloat(str);
if (num < 0) {
return 0;
}
if (num > 1) {
return 255;
}
return Math.round(num * 255);
}
function parsePercentage(str) {
// parseFloat conveniently ignores the final %
var int = parseFloat(str, 10);
if (int < 0) {
return 0;
}
if (int > 100) {
return 1;
}
return int / 100;
}
var names = {
transparent: 0x00000000,
// http://www.w3.org/TR/css3-color/#svg-color
aliceblue: 0xf0f8ffff,
antiquewhite: 0xfaebd7ff,
aqua: 0x00ffffff,
aquamarine: 0x7fffd4ff,
azure: 0xf0ffffff,
beige: 0xf5f5dcff,
bisque: 0xffe4c4ff,
black: 0x000000ff,
blanchedalmond: 0xffebcdff,
blue: 0x0000ffff,
blueviolet: 0x8a2be2ff,
brown: 0xa52a2aff,
burlywood: 0xdeb887ff,
burntsienna: 0xea7e5dff,
cadetblue: 0x5f9ea0ff,
chartreuse: 0x7fff00ff,
chocolate: 0xd2691eff,
coral: 0xff7f50ff,
cornflowerblue: 0x6495edff,
cornsilk: 0xfff8dcff,
crimson: 0xdc143cff,
cyan: 0x00ffffff,
darkblue: 0x00008bff,
darkcyan: 0x008b8bff,
darkgoldenrod: 0xb8860bff,
darkgray: 0xa9a9a9ff,
darkgreen: 0x006400ff,
darkgrey: 0xa9a9a9ff,
darkkhaki: 0xbdb76bff,
darkmagenta: 0x8b008bff,
darkolivegreen: 0x556b2fff,
darkorange: 0xff8c00ff,
darkorchid: 0x9932ccff,
darkred: 0x8b0000ff,
darksalmon: 0xe9967aff,
darkseagreen: 0x8fbc8fff,
darkslateblue: 0x483d8bff,
darkslategray: 0x2f4f4fff,
darkslategrey: 0x2f4f4fff,
darkturquoise: 0x00ced1ff,
darkviolet: 0x9400d3ff,
deeppink: 0xff1493ff,
deepskyblue: 0x00bfffff,
dimgray: 0x696969ff,
dimgrey: 0x696969ff,
dodgerblue: 0x1e90ffff,
firebrick: 0xb22222ff,
floralwhite: 0xfffaf0ff,
forestgreen: 0x228b22ff,
fuchsia: 0xff00ffff,
gainsboro: 0xdcdcdcff,
ghostwhite: 0xf8f8ffff,
gold: 0xffd700ff,
goldenrod: 0xdaa520ff,
gray: 0x808080ff,
green: 0x008000ff,
greenyellow: 0xadff2fff,
grey: 0x808080ff,
honeydew: 0xf0fff0ff,
hotpink: 0xff69b4ff,
indianred: 0xcd5c5cff,
indigo: 0x4b0082ff,
ivory: 0xfffff0ff,
khaki: 0xf0e68cff,
lavender: 0xe6e6faff,
lavenderblush: 0xfff0f5ff,
lawngreen: 0x7cfc00ff,
lemonchiffon: 0xfffacdff,
lightblue: 0xadd8e6ff,
lightcoral: 0xf08080ff,
lightcyan: 0xe0ffffff,
lightgoldenrodyellow: 0xfafad2ff,
lightgray: 0xd3d3d3ff,
lightgreen: 0x90ee90ff,
lightgrey: 0xd3d3d3ff,
lightpink: 0xffb6c1ff,
lightsalmon: 0xffa07aff,
lightseagreen: 0x20b2aaff,
lightskyblue: 0x87cefaff,
lightslategray: 0x778899ff,
lightslategrey: 0x778899ff,
lightsteelblue: 0xb0c4deff,
lightyellow: 0xffffe0ff,
lime: 0x00ff00ff,
limegreen: 0x32cd32ff,
linen: 0xfaf0e6ff,
magenta: 0xff00ffff,
maroon: 0x800000ff,
mediumaquamarine: 0x66cdaaff,
mediumblue: 0x0000cdff,
mediumorchid: 0xba55d3ff,
mediumpurple: 0x9370dbff,
mediumseagreen: 0x3cb371ff,
mediumslateblue: 0x7b68eeff,
mediumspringgreen: 0x00fa9aff,
mediumturquoise: 0x48d1ccff,
mediumvioletred: 0xc71585ff,
midnightblue: 0x191970ff,
mintcream: 0xf5fffaff,
mistyrose: 0xffe4e1ff,
moccasin: 0xffe4b5ff,
navajowhite: 0xffdeadff,
navy: 0x000080ff,
oldlace: 0xfdf5e6ff,
olive: 0x808000ff,
olivedrab: 0x6b8e23ff,
orange: 0xffa500ff,
orangered: 0xff4500ff,
orchid: 0xda70d6ff,
palegoldenrod: 0xeee8aaff,
palegreen: 0x98fb98ff,
paleturquoise: 0xafeeeeff,
palevioletred: 0xdb7093ff,
papayawhip: 0xffefd5ff,
peachpuff: 0xffdab9ff,
peru: 0xcd853fff,
pink: 0xffc0cbff,
plum: 0xdda0ddff,
powderblue: 0xb0e0e6ff,
purple: 0x800080ff,
rebeccapurple: 0x663399ff,
red: 0xff0000ff,
rosybrown: 0xbc8f8fff,
royalblue: 0x4169e1ff,
saddlebrown: 0x8b4513ff,
salmon: 0xfa8072ff,
sandybrown: 0xf4a460ff,
seagreen: 0x2e8b57ff,
seashell: 0xfff5eeff,
sienna: 0xa0522dff,
silver: 0xc0c0c0ff,
skyblue: 0x87ceebff,
slateblue: 0x6a5acdff,
slategray: 0x708090ff,
slategrey: 0x708090ff,
snow: 0xfffafaff,
springgreen: 0x00ff7fff,
steelblue: 0x4682b4ff,
tan: 0xd2b48cff,
teal: 0x008080ff,
thistle: 0xd8bfd8ff,
tomato: 0xff6347ff,
turquoise: 0x40e0d0ff,
violet: 0xee82eeff,
wheat: 0xf5deb3ff,
white: 0xffffffff,
whitesmoke: 0xf5f5f5ff,
yellow: 0xffff00ff,
yellowgreen: 0x9acd32ff,
};
function rgba(colorInt) {
var r = Math.round(((colorInt & 0xff000000) >>> 24));
var g = Math.round(((colorInt & 0x00ff0000) >>> 16));
var b = Math.round(((colorInt & 0x0000ff00) >>> 8));
var a = ((colorInt & 0x000000ff) >>> 0) / 255;
return {
r: r,
g: g,
b: b,
a: a,
};
};
normalizeColor.rgba = rgba;
module.exports = normalizeColor;
//////////////////
// WEBPACK FOOTER
// ./~/normalize-css-color/index.js
// module id = 2621
// module chunks = 2

541
509bba0_unpacked/~/punycode/punycode.js Executable file
View file

@ -0,0 +1,541 @@
/*! https://mths.be/punycode v1.4.1 by @mathias */
;(function(root) {
/** Detect free variables */
var freeExports = typeof exports == 'object' && exports &&
!exports.nodeType && exports;
var freeModule = typeof module == 'object' && module &&
!module.nodeType && module;
var freeGlobal = typeof global == 'object' && global;
if (
freeGlobal.global === freeGlobal ||
freeGlobal.window === freeGlobal ||
freeGlobal.self === freeGlobal
) {
root = freeGlobal;
}
/**
* The `punycode` object.
* @name punycode
* @type Object
*/
var punycode,
/** Highest positive signed 32-bit float value */
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
/** Bootstring parameters */
base = 36,
tMin = 1,
tMax = 26,
skew = 38,
damp = 700,
initialBias = 72,
initialN = 128, // 0x80
delimiter = '-', // '\x2D'
/** Regular expressions */
regexPunycode = /^xn--/,
regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
/** Error messages */
errors = {
'overflow': 'Overflow: input needs wider integers to process',
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
'invalid-input': 'Invalid input'
},
/** Convenience shortcuts */
baseMinusTMin = base - tMin,
floor = Math.floor,
stringFromCharCode = String.fromCharCode,
/** Temporary variable */
key;
/*--------------------------------------------------------------------------*/
/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function error(type) {
throw new RangeError(errors[type]);
}
/**
* A generic `Array#map` utility function.
* @private
* @param {Array} array The array to iterate over.
* @param {Function} callback The function that gets called for every array
* item.
* @returns {Array} A new array of values returned by the callback function.
*/
function map(array, fn) {
var length = array.length;
var result = [];
while (length--) {
result[length] = fn(array[length]);
}
return result;
}
/**
* A simple `Array#map`-like wrapper to work with domain name strings or email
* addresses.
* @private
* @param {String} domain The domain name or email address.
* @param {Function} callback The function that gets called for every
* character.
* @returns {Array} A new string of characters returned by the callback
* function.
*/
function mapDomain(string, fn) {
var parts = string.split('@');
var result = '';
if (parts.length > 1) {
// In email addresses, only the domain name should be punycoded. Leave
// the local part (i.e. everything up to `@`) intact.
result = parts[0] + '@';
string = parts[1];
}
// Avoid `split(regex)` for IE8 compatibility. See #17.
string = string.replace(regexSeparators, '\x2E');
var labels = string.split('.');
var encoded = map(labels, fn).join('.');
return result + encoded;
}
/**
* Creates an array containing the numeric code points of each Unicode
* character in the string. While JavaScript uses UCS-2 internally,
* this function will convert a pair of surrogate halves (each of which
* UCS-2 exposes as separate characters) into a single code point,
* matching UTF-16.
* @see `punycode.ucs2.encode`
* @see <https://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode.ucs2
* @name decode
* @param {String} string The Unicode input string (UCS-2).
* @returns {Array} The new array of code points.
*/
function ucs2decode(string) {
var output = [],
counter = 0,
length = string.length,
value,
extra;
while (counter < length) {
value = string.charCodeAt(counter++);
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
// high surrogate, and there is a next character
extra = string.charCodeAt(counter++);
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
} else {
// unmatched surrogate; only append this code unit, in case the next
// code unit is the high surrogate of a surrogate pair
output.push(value);
counter--;
}
} else {
output.push(value);
}
}
return output;
}
/**
* Creates a string based on an array of numeric code points.
* @see `punycode.ucs2.decode`
* @memberOf punycode.ucs2
* @name encode
* @param {Array} codePoints The array of numeric code points.
* @returns {String} The new Unicode string (UCS-2).
*/
function ucs2encode(array) {
return map(array, function(value) {
var output = '';
if (value > 0xFFFF) {
value -= 0x10000;
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
value = 0xDC00 | value & 0x3FF;
}
output += stringFromCharCode(value);
return output;
}).join('');
}
/**
* Converts a basic code point into a digit/integer.
* @see `digitToBasic()`
* @private
* @param {Number} codePoint The basic numeric code point value.
* @returns {Number} The numeric value of a basic code point (for use in
* representing integers) in the range `0` to `base - 1`, or `base` if
* the code point does not represent a value.
*/
function basicToDigit(codePoint) {
if (codePoint - 48 < 10) {
return codePoint - 22;
}
if (codePoint - 65 < 26) {
return codePoint - 65;
}
if (codePoint - 97 < 26) {
return codePoint - 97;
}
return base;
}
/**
* Converts a digit/integer into a basic code point.
* @see `basicToDigit()`
* @private
* @param {Number} digit The numeric value of a basic code point.
* @returns {Number} The basic code point whose value (when used for
* representing integers) is `digit`, which needs to be in the range
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
* used; else, the lowercase form is used. The behavior is undefined
* if `flag` is non-zero and `digit` has no uppercase form.
*/
function digitToBasic(digit, flag) {
// 0..25 map to ASCII a..z or A..Z
// 26..35 map to ASCII 0..9
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
}
/**
* Bias adaptation function as per section 3.4 of RFC 3492.
* https://tools.ietf.org/html/rfc3492#section-3.4
* @private
*/
function adapt(delta, numPoints, firstTime) {
var k = 0;
delta = firstTime ? floor(delta / damp) : delta >> 1;
delta += floor(delta / numPoints);
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
delta = floor(delta / baseMinusTMin);
}
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
}
/**
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
* symbols.
* @memberOf punycode
* @param {String} input The Punycode string of ASCII-only symbols.
* @returns {String} The resulting string of Unicode symbols.
*/
function decode(input) {
// Don't use UCS-2
var output = [],
inputLength = input.length,
out,
i = 0,
n = initialN,
bias = initialBias,
basic,
j,
index,
oldi,
w,
k,
digit,
t,
/** Cached calculation results */
baseMinusT;
// Handle the basic code points: let `basic` be the number of input code
// points before the last delimiter, or `0` if there is none, then copy
// the first basic code points to the output.
basic = input.lastIndexOf(delimiter);
if (basic < 0) {
basic = 0;
}
for (j = 0; j < basic; ++j) {
// if it's not a basic code point
if (input.charCodeAt(j) >= 0x80) {
error('not-basic');
}
output.push(input.charCodeAt(j));
}
// Main decoding loop: start just after the last delimiter if any basic code
// points were copied; start at the beginning otherwise.
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
// `index` is the index of the next character to be consumed.
// Decode a generalized variable-length integer into `delta`,
// which gets added to `i`. The overflow checking is easier
// if we increase `i` as we go, then subtract off its starting
// value at the end to obtain `delta`.
for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
if (index >= inputLength) {
error('invalid-input');
}
digit = basicToDigit(input.charCodeAt(index++));
if (digit >= base || digit > floor((maxInt - i) / w)) {
error('overflow');
}
i += digit * w;
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (digit < t) {
break;
}
baseMinusT = base - t;
if (w > floor(maxInt / baseMinusT)) {
error('overflow');
}
w *= baseMinusT;
}
out = output.length + 1;
bias = adapt(i - oldi, out, oldi == 0);
// `i` was supposed to wrap around from `out` to `0`,
// incrementing `n` each time, so we'll fix that now:
if (floor(i / out) > maxInt - n) {
error('overflow');
}
n += floor(i / out);
i %= out;
// Insert `n` at position `i` of the output
output.splice(i++, 0, n);
}
return ucs2encode(output);
}
/**
* Converts a string of Unicode symbols (e.g. a domain name label) to a
* Punycode string of ASCII-only symbols.
* @memberOf punycode
* @param {String} input The string of Unicode symbols.
* @returns {String} The resulting Punycode string of ASCII-only symbols.
*/
function encode(input) {
var n,
delta,
handledCPCount,
basicLength,
bias,
j,
m,
q,
k,
t,
currentValue,
output = [],
/** `inputLength` will hold the number of code points in `input`. */
inputLength,
/** Cached calculation results */
handledCPCountPlusOne,
baseMinusT,
qMinusT;
// Convert the input in UCS-2 to Unicode
input = ucs2decode(input);
// Cache the length
inputLength = input.length;
// Initialize the state
n = initialN;
delta = 0;
bias = initialBias;
// Handle the basic code points
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < 0x80) {
output.push(stringFromCharCode(currentValue));
}
}
handledCPCount = basicLength = output.length;
// `handledCPCount` is the number of code points that have been handled;
// `basicLength` is the number of basic code points.
// Finish the basic string - if it is not empty - with a delimiter
if (basicLength) {
output.push(delimiter);
}
// Main encoding loop:
while (handledCPCount < inputLength) {
// All non-basic code points < n have been handled already. Find the next
// larger one:
for (m = maxInt, j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue >= n && currentValue < m) {
m = currentValue;
}
}
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
// but guard against overflow
handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
error('overflow');
}
delta += (m - n) * handledCPCountPlusOne;
n = m;
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < n && ++delta > maxInt) {
error('overflow');
}
if (currentValue == n) {
// Represent delta as a generalized variable-length integer
for (q = delta, k = base; /* no condition */; k += base) {
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (q < t) {
break;
}
qMinusT = q - t;
baseMinusT = base - t;
output.push(
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
);
q = floor(qMinusT / baseMinusT);
}
output.push(stringFromCharCode(digitToBasic(q, 0)));
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
delta = 0;
++handledCPCount;
}
}
++delta;
++n;
}
return output.join('');
}
/**
* Converts a Punycode string representing a domain name or an email address
* to Unicode. Only the Punycoded parts of the input will be converted, i.e.
* it doesn't matter if you call it on a string that has already been
* converted to Unicode.
* @memberOf punycode
* @param {String} input The Punycoded domain name or email address to
* convert to Unicode.
* @returns {String} The Unicode representation of the given Punycode
* string.
*/
function toUnicode(input) {
return mapDomain(input, function(string) {
return regexPunycode.test(string)
? decode(string.slice(4).toLowerCase())
: string;
});
}
/**
* Converts a Unicode string representing a domain name or an email address to
* Punycode. Only the non-ASCII parts of the domain name will be converted,
* i.e. it doesn't matter if you call it with a domain that's already in
* ASCII.
* @memberOf punycode
* @param {String} input The domain name or email address to convert, as a
* Unicode string.
* @returns {String} The Punycode representation of the given domain name or
* email address.
*/
function toASCII(input) {
return mapDomain(input, function(string) {
return regexNonASCII.test(string)
? 'xn--' + encode(string)
: string;
});
}
/*--------------------------------------------------------------------------*/
/** Define the public API */
punycode = {
/**
* A string representing the current Punycode.js version number.
* @memberOf punycode
* @type String
*/
'version': '1.4.1',
/**
* An object of methods to convert from JavaScript's internal character
* representation (UCS-2) to Unicode code points, and back.
* @see <https://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode
* @type Object
*/
'ucs2': {
'decode': ucs2decode,
'encode': ucs2encode
},
'decode': decode,
'encode': encode,
'toASCII': toASCII,
'toUnicode': toUnicode
};
/** Expose `punycode` */
// Some AMD build optimizers, like r.js, check for specific condition patterns
// like the following:
if (
typeof define == 'function' &&
typeof define.amd == 'object' &&
define.amd
) {
define('punycode', function() {
return punycode;
});
} else if (freeExports && freeModule) {
if (module.exports == freeExports) {
// in Node.js, io.js, or RingoJS v0.8.0+
freeModule.exports = punycode;
} else {
// in Narwhal or RingoJS v0.7.0-
for (key in punycode) {
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
}
}
} else {
// in Rhino or a web browser
root.punycode = punycode;
}
}(this));
//////////////////
// WEBPACK FOOTER
// ./~/punycode/punycode.js
// module id = 1110
// module chunks = 2

92
509bba0_unpacked/~/querystring-es3/decode.js Executable file
View file

@ -0,0 +1,92 @@
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.
'use strict';
// If obj.hasOwnProperty has been overridden, then calling
// obj.hasOwnProperty(prop) will break.
// See: https://github.com/joyent/node/issues/1707
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
module.exports = function(qs, sep, eq, options) {
sep = sep || '&';
eq = eq || '=';
var obj = {};
if (typeof qs !== 'string' || qs.length === 0) {
return obj;
}
var regexp = /\+/g;
qs = qs.split(sep);
var maxKeys = 1000;
if (options && typeof options.maxKeys === 'number') {
maxKeys = options.maxKeys;
}
var len = qs.length;
// maxKeys <= 0 means that we should not limit keys count
if (maxKeys > 0 && len > maxKeys) {
len = maxKeys;
}
for (var i = 0; i < len; ++i) {
var x = qs[i].replace(regexp, '%20'),
idx = x.indexOf(eq),
kstr, vstr, k, v;
if (idx >= 0) {
kstr = x.substr(0, idx);
vstr = x.substr(idx + 1);
} else {
kstr = x;
vstr = '';
}
k = decodeURIComponent(kstr);
v = decodeURIComponent(vstr);
if (!hasOwnProperty(obj, k)) {
obj[k] = v;
} else if (isArray(obj[k])) {
obj[k].push(v);
} else {
obj[k] = [obj[k], v];
}
}
return obj;
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
//////////////////
// WEBPACK FOOTER
// ./~/querystring-es3/decode.js
// module id = 2686
// module chunks = 2

93
509bba0_unpacked/~/querystring-es3/encode.js Executable file
View file

@ -0,0 +1,93 @@
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.
'use strict';
var stringifyPrimitive = function(v) {
switch (typeof v) {
case 'string':
return v;
case 'boolean':
return v ? 'true' : 'false';
case 'number':
return isFinite(v) ? v : '';
default:
return '';
}
};
module.exports = function(obj, sep, eq, name) {
sep = sep || '&';
eq = eq || '=';
if (obj === null) {
obj = undefined;
}
if (typeof obj === 'object') {
return map(objectKeys(obj), function(k) {
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
if (isArray(obj[k])) {
return map(obj[k], function(v) {
return ks + encodeURIComponent(stringifyPrimitive(v));
}).join(sep);
} else {
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
}
}).join(sep);
}
if (!name) return '';
return encodeURIComponent(stringifyPrimitive(name)) + eq +
encodeURIComponent(stringifyPrimitive(obj));
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
function map (xs, f) {
if (xs.map) return xs.map(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
res.push(f(xs[i], i));
}
return res;
}
var objectKeys = Object.keys || function (obj) {
var res = [];
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
}
return res;
};
//////////////////
// WEBPACK FOOTER
// ./~/querystring-es3/encode.js
// module id = 2687
// module chunks = 2

12
509bba0_unpacked/~/querystring-es3/index.js Executable file
View file

@ -0,0 +1,12 @@
'use strict';
exports.decode = exports.parse = require('./decode');
exports.encode = exports.stringify = require('./encode');
//////////////////
// WEBPACK FOOTER
// ./~/querystring-es3/index.js
// module id = 433
// module chunks = 2

9
509bba0_unpacked/~/react-hot-loader/index.js vendored Executable file
View file

@ -0,0 +1,9 @@
module.exports = require('./lib/index');
//////////////////
// WEBPACK FOOTER
// ./~/react-hot-loader/index.js
// module id = 1208
// module chunks = 2

16
509bba0_unpacked/~/react-hot-loader/lib/AppContainer.js vendored Executable file
View file

@ -0,0 +1,16 @@
/* eslint-disable global-require */
'use strict';
if (!module.hot || process.env.NODE_ENV === 'production') {
module.exports = require('./AppContainer.prod');
} else {
module.exports = require('./AppContainer.dev');
}
//////////////////
// WEBPACK FOOTER
// ./~/react-hot-loader/lib/AppContainer.js
// module id = 2765
// module chunks = 2

46
509bba0_unpacked/~/react-hot-loader/lib/AppContainer.prod.js Executable file
View file

@ -0,0 +1,46 @@
/* eslint-disable react/prop-types */
'use strict';
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var React = require('react');
var Component = React.Component;
var AppContainer = function (_Component) {
_inherits(AppContainer, _Component);
function AppContainer() {
_classCallCheck(this, AppContainer);
return _possibleConstructorReturn(this, (AppContainer.__proto__ || Object.getPrototypeOf(AppContainer)).apply(this, arguments));
}
_createClass(AppContainer, [{
key: 'render',
value: function render() {
if (this.props.component) {
return React.createElement(this.props.component, this.props.props);
}
return React.Children.only(this.props.children);
}
}]);
return AppContainer;
}(Component);
module.exports = AppContainer;
//////////////////
// WEBPACK FOOTER
// ./~/react-hot-loader/lib/AppContainer.prod.js
// module id = 2766
// module chunks = 2

22
509bba0_unpacked/~/react-hot-loader/lib/index.js vendored Executable file
View file

@ -0,0 +1,22 @@
'use strict';
var AppContainer = require('./AppContainer');
module.exports = function warnAboutIncorrectUsage(arg) {
if (this && this.callback) {
throw new Error('React Hot Loader: The Webpack loader is now exported separately. ' + 'If you use Babel, we recommend that you remove "react-hot-loader" ' + 'from the "loaders" section of your Webpack configuration altogether, ' + 'and instead add "react-hot-loader/babel" to the "plugins" section ' + 'of your .babelrc file. ' + 'If you prefer not to use Babel, replace "react-hot-loader" or ' + '"react-hot" with "react-hot-loader/webpack" in the "loaders" section ' + 'of your Webpack configuration.');
} else if (arg && arg.types && arg.types.IfStatement) {
throw new Error('React Hot Loader: The Babel plugin is exported separately. ' + 'Replace "react-hot-loader" with "react-hot-loader/babel" ' + 'in the "plugins" section of your .babelrc file. ' + 'While we recommend the above, if you prefer not to use Babel, ' + 'you may remove "react-hot-loader" from the "plugins" section of ' + 'your .babelrc file altogether, and instead add ' + '"react-hot-loader/webpack" to the "loaders" section of your Webpack ' + 'configuration.');
} else {
throw new Error('React Hot Loader does not have a default export. ' + 'If you use the import statement, make sure to include the ' + 'curly braces: import { AppContainer } from "react-hot-loader". ' + 'If you use CommonJS, make sure to read the named export: ' + 'require("react-hot-loader").AppContainer.');
}
};
module.exports.AppContainer = AppContainer;
//////////////////
// WEBPACK FOOTER
// ./~/react-hot-loader/lib/index.js
// module id = 2767
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f004.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "4a7e8a1c38d2b205bf0ed66287dc3878.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f004.svg
// module id = 3139
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f0cf.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "094868bfb782f145d4fe5cd8dbc49cc7.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f0cf.svg
// module id = 3140
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f170.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "9d089e5b57d6e0963e78689371f9fa02.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f170.svg
// module id = 3141
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f171.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "cd5c9ccdf3c8d46d48107bfefcd4f44e.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f171.svg
// module id = 3142
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f17e.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "1379871eb798de836776ceb73641f44e.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f17e.svg
// module id = 3143
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f17f.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "e78fc07369f1bb9b2f4f13aa6d230b64.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f17f.svg
// module id = 3144
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f18e.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "f6025fcaa090a679651c6fe9d1bef154.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f18e.svg
// module id = 3145
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f191.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "e695fe6c90341251bc0fe15073c2d85b.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f191.svg
// module id = 3146
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f192.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "e49a859a67fa70d84f1f61590b93fc44.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f192.svg
// module id = 3147
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f193.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "a802da49292419853c585395032ab284.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f193.svg
// module id = 3148
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f194.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "4bbe2360c233d56fd84a488e1c724d0d.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f194.svg
// module id = 3149
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f195.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "02c27b408520f8a5cdcd82082c43f53e.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f195.svg
// module id = 3150
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f196.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "8e1bc7bf4c317925b1e82e4be8b39baf.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f196.svg
// module id = 3151
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f197.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "a61b14400491c0c070e80c99a05cda82.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f197.svg
// module id = 3152
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f198.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "c01d9aac648747651e03ecd7425a3cae.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f198.svg
// module id = 3153
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f199.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "f18cb914a14fb9e89f92c8be55bfc5e3.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f199.svg
// module id = 3154
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f19a.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "88eaec49c2caccea9de21e771de5d2c7.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f19a.svg
// module id = 3155
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1e8.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "15eb2b4336a23cbbfb2c7f65983674ca.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1e8.svg
// module id = 3156
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1e9.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "3f23733001b581f991045d7291133509.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1e9.svg
// module id = 3157
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1ea.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "dd6306705766171944ab989133b6dabe.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1ea.svg
// module id = 3158
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1eb.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "3c4b934ef4f5946945565c90236fd0fd.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1eb.svg
// module id = 3159
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1ec.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "4ccc37c261c2e2d826b64fa9ce3dadf8.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1ec.svg
// module id = 3160
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1ee.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "04fd4e2ef09ca386b46d09ea17ca6db9.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1ee.svg
// module id = 3161
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1f1.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "2f0edb2adbf57b52c544b19d6a91d65d.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1f1.svg
// module id = 3162
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1f2.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "afbffb7c24c3fbd62eed6347ec82e31c.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1f2.svg
// module id = 3163
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1f4.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "29fd528b0715dff4581d750d450253f2.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1f4.svg
// module id = 3164
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1f6.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "a0eeddbd92564fe91c151be1ed2df67a.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1f6.svg
// module id = 3165
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1f7.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "07a1c54d94b121d2766944c4ef3b5e69.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1f7.svg
// module id = 3166
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1f8.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "9a539501d669e53641503e73f4946b32.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1f8.svg
// module id = 3167
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1f9.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "6627a630cfc1a9673158ed0d459ed0b7.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1f9.svg
// module id = 3168
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1fa.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "0b8323ad8d6947ab2b5b874d8c12866d.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1fa.svg
// module id = 3169
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1fc.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "b48f39cb189ba3712796dc24dc626e4d.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1fc.svg
// module id = 3170
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1fd.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "4e76e551269f2f765ec756092d0a0735.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1fd.svg
// module id = 3171
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6-1f1ff.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "8db08f31f1918f1bc6295ebe255f5520.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6-1f1ff.svg
// module id = 3172
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e6.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "9d3334bc4be7f586fc00eb2772eb331f.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e6.svg
// module id = 3173
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1e6.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "5f8852008dba7fe14a901637f559183a.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1e6.svg
// module id = 3174
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1e7.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "2ea248c3dce94632b8b1d31d81aa768d.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1e7.svg
// module id = 3175
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1e9.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "0c1b838cd2f467f5292126544358506e.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1e9.svg
// module id = 3176
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1ea.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "703ed1cd4728c61677efc3239745dfa0.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1ea.svg
// module id = 3177
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1eb.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "ade4b25a1fd9a5965358a7e11a39af96.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1eb.svg
// module id = 3178
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1ec.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "1943b537414d2f03962fef04ef156678.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1ec.svg
// module id = 3179
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1ed.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "6797c37fc1cd62176211eb4aad06e8b6.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1ed.svg
// module id = 3180
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1ee.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "e054e26599b7b9fa70e4c713f3611c5c.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1ee.svg
// module id = 3181
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1ef.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "184022bedf637f627695ac4eb6764725.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1ef.svg
// module id = 3182
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f1.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "2c90c551745e2e9a7ed1ba5013a7754f.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f1.svg
// module id = 3183
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f2.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "19696347beb6c16e5a9d751085d948c5.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f2.svg
// module id = 3184
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f3.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "1e677b5cb2c717643a41f4b7155f09c9.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f3.svg
// module id = 3185
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f4.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "9216e2d5d9f0cf3ddb610e0dd9f098a7.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f4.svg
// module id = 3186
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f6.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "efb55b06db8c656043b6dcda51eeb399.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f6.svg
// module id = 3187
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f7.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "5e0529582f11d6d30e74ed3a28ac486e.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f7.svg
// module id = 3188
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f8.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "1b30231e4bde33e074de5871d51497f7.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f8.svg
// module id = 3189
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1f9.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "8b328c672b6f834102fe49fbfa6591d9.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1f9.svg
// module id = 3190
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1fb.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "aa5db0a8d2a08cd84d03c462dd322050.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1fb.svg
// module id = 3191
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1fc.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "d2c729f672dd737a22e7f3e403d41e71.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1fc.svg
// module id = 3192
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1fe.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "7ec13c049fe433a08fdc9545baec200e.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1fe.svg
// module id = 3193
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7-1f1ff.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "3cad4f8ee9dcbc15976920a33dc44ddc.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7-1f1ff.svg
// module id = 3194
// module chunks = 2

8
509bba0_unpacked/~/twemoji/2/svg/1f1e7.svg Executable file
View file

@ -0,0 +1,8 @@
module.exports = __webpack_public_path__ + "1f19240e4cb75bc359bf221d151a193e.svg";
//////////////////
// WEBPACK FOOTER
// ./~/twemoji/2/svg/1f1e7.svg
// module id = 3195
// module chunks = 2

Some files were not shown because too many files have changed in this diff Show more