__DEV__ = 
false;


__BUNDLE_START_TIME__ = Date.now();
(
function(global){


if(global.require){
return;}


var __DEV__=global.__DEV__;

var toString=Object.prototype.toString;













var modulesMap={},






dependencyMap={},



predefinedRefCounts={},

_counter=0,

REQUIRE_WHEN_READY=1,
USED_AS_TRANSPORT=2,

hop=Object.prototype.hasOwnProperty;

function _debugUnresolvedDependencies(names){
var unresolved=Array.prototype.slice.call(names);
var visited={};
var ii,name,module,dependency;

while(unresolved.length) {
name = unresolved.shift();
if(visited[name]){
continue;}

visited[name] = true;

module = modulesMap[name];
if(!module || !module.waiting){
continue;}


for(ii = 0;ii < module.dependencies.length;ii++) {
dependency = module.dependencies[ii];
if(!modulesMap[dependency] || modulesMap[dependency].waiting){
unresolved.push(dependency);}}}




for(name in visited) if(hop.call(visited,name)){
unresolved.push(name);}


var messages=[];
for(ii = 0;ii < unresolved.length;ii++) {
name = unresolved[ii];
var message=name;
module = modulesMap[name];
if(!module){
message += ' is not defined';}else 
if(!module.waiting){
message += ' is ready';}else 
{
var unresolvedDependencies=[];
for(var jj=0;jj < module.dependencies.length;jj++) {
dependency = module.dependencies[jj];
if(!modulesMap[dependency] || modulesMap[dependency].waiting){
unresolvedDependencies.push(dependency);}}


message += ' is waiting for ' + unresolvedDependencies.join(', ');}

messages.push(message);}

return messages.join('\n');}





function ModuleError(msg){
this.name = 'ModuleError';
this.message = msg;
this.stack = Error(msg).stack;
this.framesToPop = 2;}

ModuleError.prototype = Object.create(Error.prototype);
ModuleError.prototype.constructor = ModuleError;

var _performance=
global.performance || 
global.msPerformance || 
global.webkitPerformance || {};

if(!_performance.now){
_performance = global.Date;}


var _now=_performance?
_performance.now.bind(_performance):function(){return 0;};

var _factoryStackCount=0;
var _factoryTime=0;
var _totalFactories=0;
var _inGuard=false;
























































function require(id){
var module=modulesMap[id],dep,i,msg;
if(module && module.exports){


if(module.refcount-- === 1){
delete modulesMap[id];}

return module.exports;}

if(global.ErrorUtils && !_inGuard){
_inGuard = true;
try{
var ret=require.apply(this,arguments);}
catch(e) {
global.ErrorUtils.reportFatalError(e);}

_inGuard = false;
return ret;}


if(!module){
msg = 'Requiring unknown module "' + id + '"';
if(__DEV__){
msg += '. If you are sure the module is there, try restarting the packager.';}

throw new ModuleError(msg);}


if(module.hasError){
throw new ModuleError(
'Requiring module "' + id + '" which threw an exception');}



if(module.waiting){
throw new ModuleError(
'Requiring module "' + id + '" with unresolved dependencies: ' + 
_debugUnresolvedDependencies([id]));}



var exports=module.exports = {};
var factory=module.factory;
if(toString.call(factory) === '[object Function]'){
var args=[],
dependencies=module.dependencies,
length=dependencies.length,
ret;
if(module.special & USED_AS_TRANSPORT){
length = Math.min(length,factory.length);}

try{
for(i = 0;args.length < length;i++) {
dep = dependencies[i];
if(!module.inlineRequires[dep]){
args.push(dep === 'module'?module:
dep === 'exports'?exports:
require.call(null,dep));}}



++_totalFactories;
if(_factoryStackCount++ === 0){
_factoryTime -= _now();}

try{
ret = factory.apply(module.context || global,args);}
catch(e) {
if(modulesMap.ex && modulesMap.erx){


var ex=require.call(null,'ex');
var erx=require.call(null,'erx');
var messageWithParams=erx(e.message);
if(messageWithParams[0].indexOf(' from module "%s"') < 0){
messageWithParams[0] += ' from module "%s"';
messageWithParams[messageWithParams.length] = id;}

e.message = ex.apply(null,messageWithParams);}

throw e;}finally 
{
if(--_factoryStackCount === 0){
_factoryTime += _now();}}}


catch(e) {
module.hasError = true;
module.exports = null;
throw e;}

if(ret){
if(__DEV__){
if(typeof ret != 'object' && typeof ret != 'function'){
throw new ModuleError(
'Factory for module "' + id + '" returned ' + 
'an invalid value "' + ret + '". ' + 
'Returned value should be either a function or an object.');}}



module.exports = ret;}}else 

{
module.exports = factory;}




if(module.refcount-- === 1){
delete modulesMap[id];}

return module.exports;}


require.__getFactoryTime = function(){
return (_factoryStackCount?_now():0) + _factoryTime;};


require.__getTotalFactories = function(){
return _totalFactories;};

























































function define(id,dependencies,factory,
_special,_context,_refCount,_inlineRequires){
if(dependencies === undefined){
dependencies = [];
factory = id;
id = _uid();}else 
if(factory === undefined){
factory = dependencies;
if(toString.call(id) === '[object Array]'){
dependencies = id;
id = _uid();}else 
{
dependencies = [];}}





var canceler={cancel:_undefine.bind(this,id)};

var record=modulesMap[id];






if(record){
if(_refCount){
record.refcount += _refCount;}


return canceler;}else 
if(!dependencies && !factory && _refCount){


predefinedRefCounts[id] = (predefinedRefCounts[id] || 0) + _refCount;
return canceler;}else 
{

record = {id:id};
record.refcount = (predefinedRefCounts[id] || 0) + (_refCount || 0);
delete predefinedRefCounts[id];}


if(__DEV__){
if(
!factory || 
typeof factory != 'object' && typeof factory != 'function' && 
typeof factory != 'string'){
throw new ModuleError(
'Invalid factory "' + factory + '" for module "' + id + '". ' + 
'Factory should be either a function or an object.');}



if(toString.call(dependencies) !== '[object Array]'){
throw new ModuleError(
'Invalid dependencies for module "' + id + '". ' + 
'Dependencies must be passed as an array.');}}




record.factory = factory;
record.dependencies = dependencies;
record.context = _context;
record.special = _special;
record.inlineRequires = _inlineRequires || {};
record.waitingMap = {};
record.waiting = 0;
record.hasError = false;
modulesMap[id] = record;
_initDependencies(id);

return canceler;}


function _undefine(id){
if(!modulesMap[id]){
return;}


var module=modulesMap[id];
delete modulesMap[id];

for(var dep in module.waitingMap) {
if(module.waitingMap[dep]){
delete dependencyMap[dep][id];}}



for(var ii=0;ii < module.dependencies.length;ii++) {
dep = module.dependencies[ii];
if(modulesMap[dep]){
if(modulesMap[dep].refcount-- === 1){
_undefine(dep);}}else 

if(predefinedRefCounts[dep]){
predefinedRefCounts[dep]--;}}}













































function requireLazy(dependencies,factory,context){
return define(
dependencies,
factory,
undefined,
REQUIRE_WHEN_READY,
context,
1);}



function _uid(){
return '__mod__' + _counter++;}


function _addDependency(module,dep){

if(!module.waitingMap[dep] && module.id !== dep){
module.waiting++;
module.waitingMap[dep] = 1;
dependencyMap[dep] || (dependencyMap[dep] = {});
dependencyMap[dep][module.id] = 1;}}



function _initDependencies(id){
var modulesToRequire=[];
var module=modulesMap[id];
var dep,i,subdep;


for(i = 0;i < module.dependencies.length;i++) {
dep = module.dependencies[i];
if(!modulesMap[dep]){
_addDependency(module,dep);}else 
if(modulesMap[dep].waiting){
for(subdep in modulesMap[dep].waitingMap) {
if(modulesMap[dep].waitingMap[subdep]){
_addDependency(module,subdep);}}}}




if(module.waiting === 0 && module.special & REQUIRE_WHEN_READY){
modulesToRequire.push(id);}



if(dependencyMap[id]){
var deps=dependencyMap[id];
var submodule;
dependencyMap[id] = undefined;
for(dep in deps) {
submodule = modulesMap[dep];


for(subdep in module.waitingMap) {
if(module.waitingMap[subdep]){
_addDependency(submodule,subdep);}}



if(submodule.waitingMap[id]){
submodule.waitingMap[id] = undefined;
submodule.waiting--;}

if(submodule.waiting === 0 && 
submodule.special & REQUIRE_WHEN_READY){
modulesToRequire.push(dep);}}}





for(i = 0;i < modulesToRequire.length;i++) {
require.call(null,modulesToRequire[i]);}}



function _register(id,exports){
var module=modulesMap[id] = {id:id};
module.exports = exports;
module.refcount = 0;}




_register('module',0);
_register('exports',0);

_register('global',global);
_register('require',require);
_register('requireDynamic',require);
_register('requireLazy',requireLazy);

global.require = require;
global.requireDynamic = require;
global.requireLazy = requireLazy;

require.__debug = {
modules:modulesMap,
deps:dependencyMap,
printDependencyInfo:function(){
if(!global.console){
return;}

var names=Object.keys(require.__debug.deps);
global.console.log(_debugUnresolvedDependencies(names));}};









global.__d = function(id,deps,factory,_special,_inlineRequires){
var defaultDeps=['global','require','requireDynamic','requireLazy',
'module','exports'];
define(id,defaultDeps.concat(deps),factory,_special || USED_AS_TRANSPORT,
null,null,_inlineRequires);};})(


this);
Object.

















assign = function(target,sources){
if(__DEV__){
if(target == null){
throw new TypeError('Object.assign target cannot be null or undefined');}

if(typeof target !== 'object' && typeof target !== 'function'){
throw new TypeError(
'In this environment the target of assign MUST be an object.' + 
'This error is a performance optimization and not spec compliant.');}}




for(var nextIndex=1;nextIndex < arguments.length;nextIndex++) {
var nextSource=arguments[nextIndex];
if(nextSource == null){
continue;}


if(__DEV__){
if(typeof nextSource !== 'object' && 
typeof nextSource !== 'function'){
throw new TypeError(
'In this environment the target of assign MUST be an object.' + 
'This error is a performance optimization and not spec compliant.');}}








for(var key in nextSource) {
if(__DEV__){
var hasOwnProperty=Object.prototype.hasOwnProperty;
if(!hasOwnProperty.call(nextSource,key)){
throw new TypeError(
'One of the sources to assign has an enumerable key on the ' + 
'prototype chain. This is an edge case that we do not support. ' + 
'This error is a performance optimization and not spec compliant.');}}



target[key] = nextSource[key];}}



return target;};
(















function(global){
'use strict';

var inspect=(function(){























function inspect(obj,opts){
var ctx={
seen:[],
stylize:stylizeNoColor};

return formatValue(ctx,obj,opts.depth);}


function stylizeNoColor(str,styleType){
return str;}


function arrayToHash(array){
var hash={};

array.forEach(function(val,idx){
hash[val] = true;});


return hash;}



function formatValue(ctx,value,recurseTimes){

var primitive=formatPrimitive(ctx,value);
if(primitive){
return primitive;}



var keys=Object.keys(value);
var visibleKeys=arrayToHash(keys);



if(isError(value) && (
keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)){
return formatError(value);}



if(keys.length === 0){
if(isFunction(value)){
var name=value.name?': ' + value.name:'';
return ctx.stylize('[Function' + name + ']','special');}

if(isRegExp(value)){
return ctx.stylize(RegExp.prototype.toString.call(value),'regexp');}

if(isDate(value)){
return ctx.stylize(Date.prototype.toString.call(value),'date');}

if(isError(value)){
return formatError(value);}}



var base='',array=false,braces=['{','}'];


if(isArray(value)){
array = true;
braces = ['[',']'];}



if(isFunction(value)){
var n=value.name?': ' + value.name:'';
base = ' [Function' + n + ']';}



if(isRegExp(value)){
base = ' ' + RegExp.prototype.toString.call(value);}



if(isDate(value)){
base = ' ' + Date.prototype.toUTCString.call(value);}



if(isError(value)){
base = ' ' + formatError(value);}


if(keys.length === 0 && (!array || value.length == 0)){
return braces[0] + base + braces[1];}


if(recurseTimes < 0){
if(isRegExp(value)){
return ctx.stylize(RegExp.prototype.toString.call(value),'regexp');}else 
{
return ctx.stylize('[Object]','special');}}



ctx.seen.push(value);

var output;
if(array){
output = formatArray(ctx,value,recurseTimes,visibleKeys,keys);}else 
{
output = keys.map(function(key){
return formatProperty(ctx,value,recurseTimes,visibleKeys,key,array);});}



ctx.seen.pop();

return reduceToSingleString(output,base,braces);}



function formatPrimitive(ctx,value){
if(isUndefined(value))
return ctx.stylize('undefined','undefined');
if(isString(value)){
var simple='\'' + JSON.stringify(value).replace(/^"|"$/g,'').
replace(/'/g,'\\\'').
replace(/\\"/g,'"') + '\'';
return ctx.stylize(simple,'string');}

if(isNumber(value))
return ctx.stylize('' + value,'number');
if(isBoolean(value))
return ctx.stylize('' + value,'boolean');

if(isNull(value))
return ctx.stylize('null','null');}



function formatError(value){
return '[' + Error.prototype.toString.call(value) + ']';}



function formatArray(ctx,value,recurseTimes,visibleKeys,keys){
var output=[];
for(var i=0,l=value.length;i < l;++i) {
if(hasOwnProperty(value,String(i))){
output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,
String(i),true));}else 
{
output.push('');}}


keys.forEach(function(key){
if(!key.match(/^\d+$/)){
output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,
key,true));}});


return output;}



function formatProperty(ctx,value,recurseTimes,visibleKeys,key,array){
var name,str,desc;
desc = Object.getOwnPropertyDescriptor(value,key) || {value:value[key]};
if(desc.get){
if(desc.set){
str = ctx.stylize('[Getter/Setter]','special');}else 
{
str = ctx.stylize('[Getter]','special');}}else 

{
if(desc.set){
str = ctx.stylize('[Setter]','special');}}


if(!hasOwnProperty(visibleKeys,key)){
name = '[' + key + ']';}

if(!str){
if(ctx.seen.indexOf(desc.value) < 0){
if(isNull(recurseTimes)){
str = formatValue(ctx,desc.value,null);}else 
{
str = formatValue(ctx,desc.value,recurseTimes - 1);}

if(str.indexOf('\n') > -1){
if(array){
str = str.split('\n').map(function(line){
return '  ' + line;}).
join('\n').substr(2);}else 
{
str = '\n' + str.split('\n').map(function(line){
return '   ' + line;}).
join('\n');}}}else 


{
str = ctx.stylize('[Circular]','special');}}


if(isUndefined(name)){
if(array && key.match(/^\d+$/)){
return str;}

name = JSON.stringify('' + key);
if(name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)){
name = name.substr(1,name.length - 2);
name = ctx.stylize(name,'name');}else 
{
name = name.replace(/'/g,'\\\'').
replace(/\\"/g,'"').
replace(/(^"|"$)/g,'\'');
name = ctx.stylize(name,'string');}}



return name + ': ' + str;}



function reduceToSingleString(output,base,braces){
var numLinesEst=0;
var length=output.reduce(function(prev,cur){
numLinesEst++;
if(cur.indexOf('\n') >= 0)numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g,'').length + 1;},
0);

if(length > 60){
return braces[0] + (
base === ''?'':base + '\n ') + 
' ' + 
output.join(',\n  ') + 
' ' + 
braces[1];}


return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];}





function isArray(ar){
return Array.isArray(ar);}


function isBoolean(arg){
return typeof arg === 'boolean';}


function isNull(arg){
return arg === null;}


function isNullOrUndefined(arg){
return arg == null;}


function isNumber(arg){
return typeof arg === 'number';}


function isString(arg){
return typeof arg === 'string';}


function isSymbol(arg){
return typeof arg === 'symbol';}


function isUndefined(arg){
return arg === void 0;}


function isRegExp(re){
return isObject(re) && objectToString(re) === '[object RegExp]';}


function isObject(arg){
return typeof arg === 'object' && arg !== null;}


function isDate(d){
return isObject(d) && objectToString(d) === '[object Date]';}


function isError(e){
return isObject(e) && (
objectToString(e) === '[object Error]' || e instanceof Error);}


function isFunction(arg){
return typeof arg === 'function';}


function isPrimitive(arg){
return arg === null || 
typeof arg === 'boolean' || 
typeof arg === 'number' || 
typeof arg === 'string' || 
typeof arg === 'symbol' || 
typeof arg === 'undefined';}


function objectToString(o){
return Object.prototype.toString.call(o);}


function hasOwnProperty(obj,prop){
return Object.prototype.hasOwnProperty.call(obj,prop);}


return inspect;})();



var OBJECT_COLUMN_NAME='(index)';
var LOG_LEVELS={
trace:0,
log:1,
info:2,
warn:3,
error:4};


function setupConsole(global){
if(!global.nativeLoggingHook){
return;}


function getNativeLogFunction(level){
return function(){
var str=Array.prototype.map.call(arguments,function(arg){
return inspect(arg,{depth:10});}).
join(', ');
global.nativeLoggingHook(str,level);};}



var repeat=function(element,n){
return Array.apply(null,Array(n)).map(function(){return element;});};


function consoleTablePolyfill(rows){

if(!Array.isArray(rows)){
var data=rows;
rows = [];
for(var key in data) {
if(data.hasOwnProperty(key)){
var row=data[key];
row[OBJECT_COLUMN_NAME] = key;
rows.push(row);}}}



if(rows.length === 0){
global.nativeLoggingHook('',LOG_LEVELS.log);
return;}


var columns=Object.keys(rows[0]).sort();
var stringRows=[];
var columnWidths=[];



columns.forEach(function(k,i){
columnWidths[i] = k.length;
for(var j=0;j < rows.length;j++) {
var cellStr=rows[j][k].toString();
stringRows[j] = stringRows[j] || [];
stringRows[j][i] = cellStr;
columnWidths[i] = Math.max(columnWidths[i],cellStr.length);}});





var joinRow=function(row,space){
var cells=row.map(function(cell,i){
var extraSpaces=repeat(' ',columnWidths[i] - cell.length).join('');
return cell + extraSpaces;});

space = space || ' ';
return cells.join(space + '|' + space);};


var separators=columnWidths.map(function(columnWidth){
return repeat('-',columnWidth).join('');});

var separatorRow=joinRow(separators,'-');
var header=joinRow(columns);
var table=[header,separatorRow];

for(var i=0;i < rows.length;i++) {
table.push(joinRow(stringRows[i]));}






global.nativeLoggingHook('\n' + table.join('\n'),LOG_LEVELS.log);}


global.console = {
error:getNativeLogFunction(LOG_LEVELS.error),
info:getNativeLogFunction(LOG_LEVELS.info),
log:getNativeLogFunction(LOG_LEVELS.log),
warn:getNativeLogFunction(LOG_LEVELS.warn),
trace:getNativeLogFunction(LOG_LEVELS.trace),
table:consoleTablePolyfill};}




if(typeof module !== 'undefined'){
module.exports = setupConsole;}else 
{
setupConsole(global);}})(


this);
(















function(global){
var ErrorUtils={
_inGuard:0,
_globalHandler:null,
setGlobalHandler:function(fun){
ErrorUtils._globalHandler = fun;},

reportError:function(error){
ErrorUtils._globalHandler && ErrorUtils._globalHandler(error);},

reportFatalError:function(error){
ErrorUtils._globalHandler && ErrorUtils._globalHandler(error,true);},

applyWithGuard:function(fun,context,args){
try{
ErrorUtils._inGuard++;
return fun.apply(context,args);}
catch(e) {
ErrorUtils.reportError(e);}finally 
{
ErrorUtils._inGuard--;}},


applyWithGuardIfNeeded:function(fun,context,args){
if(ErrorUtils.inGuard()){
return fun.apply(context,args);}else 
{
ErrorUtils.applyWithGuard(fun,context,args);}},


inGuard:function(){
return ErrorUtils._inGuard;},

guard:function(fun,name,context){
if(typeof fun !== 'function'){
console.warn('A function must be passed to ErrorUtils.guard, got ',fun);
return null;}

name = name || fun.name || '<generated guard>';
function guarded(){
return (
ErrorUtils.applyWithGuard(
fun,
context || this,
arguments,
null,
name));}




return guarded;}};


global.ErrorUtils = ErrorUtils;





function setupErrorGuard(){
var onError=function(e){
global.console.error(
'Error: ' + 
'\n stack: ' + e.stack + 
'\n line: ' + e.line + 
'\n message: ' + e.message,
e);};


global.ErrorUtils.setGlobalHandler(onError);}


setupErrorGuard();})(
this);
if(











!String.prototype.startsWith){
String.prototype.startsWith = function(search){
'use strict';
if(this == null){
throw TypeError();}

var string=String(this);
var pos=arguments.length > 1?
Number(arguments[1]) || 0:0;
var start=Math.min(Math.max(pos,0),string.length);
return string.indexOf(String(search),pos) === start;};}



if(!String.prototype.endsWith){
String.prototype.endsWith = function(search){
'use strict';
if(this == null){
throw TypeError();}

var string=String(this);
var stringLength=string.length;
var searchString=String(search);
var pos=arguments.length > 1?
Number(arguments[1]) || 0:stringLength;
var end=Math.min(Math.max(pos,0),stringLength);
var start=end - searchString.length;
if(start < 0){
return false;}

return string.lastIndexOf(searchString,start) === start;};}



if(!String.prototype.contains){
String.prototype.contains = function(search){
'use strict';
if(this == null){
throw TypeError();}

var string=String(this);
var pos=arguments.length > 1?
Number(arguments[1]) || 0:0;
return string.indexOf(String(search),pos) !== -1;};}



if(!String.prototype.repeat){
String.prototype.repeat = function(count){
'use strict';
if(this == null){
throw TypeError();}

var string=String(this);
count = Number(count) || 0;
if(count < 0 || count === Infinity){
throw RangeError();}

if(count === 1){
return string;}

var result='';
while(count) {
if(count & 1){
result += string;}

if(count >>= 1){
string += string;}}


return result;};}
(









function(undefined){

function findIndex(predicate,context){
if(this == null){
throw new TypeError(
'Array.prototype.findIndex called on null or undefined');}


if(typeof predicate !== 'function'){
throw new TypeError('predicate must be a function');}

var list=Object(this);
var length=list.length >>> 0;
for(var i=0;i < length;i++) {
if(predicate.call(context,list[i],i,list)){
return i;}}


return -1;}


if(!Array.prototype.findIndex){
Object.defineProperty(Array.prototype,'findIndex',{
enumerable:false,
writable:true,
configurable:true,
value:findIndex});}




if(!Array.prototype.find){
Object.defineProperty(Array.prototype,'find',{
enumerable:false,
writable:true,
configurable:true,
value:function(predicate,context){
if(this == null){
throw new TypeError(
'Array.prototype.find called on null or undefined');}


var index=findIndex.call(this,predicate,context);
return index === -1?undefined:this[index];}});}})();
__d('noder/index.ios.js',["react-native/Libraries/react-native/react-native.js","noder/app/containers/App.js","noder/app/mocks/user.js","noder/app/mocks/userInfo.js","noder/app/services/userService.js","noder/app/configs/onRun.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var App=require('noder/app/containers/App.js');

var user=require('noder/app/mocks/user.js');
var userInfo=require('noder/app/mocks/userInfo.js');
var UserService=require('noder/app/services/userService.js');



require('noder/app/configs/onRun.js');

Object.assign(user,userInfo);var 



Component=

React.Component;var AppRegistry=React.AppRegistry;var 


Noder=(function(_Component){_inherits(Noder,_Component);function Noder(){_classCallCheck(this,Noder);_get(Object.getPrototypeOf(Noder.prototype),'constructor',this).apply(this,arguments);}_createClass(Noder,[{key:'componentDidMount',value:

function componentDidMount(){}},{key:'render',value:




function render(){
return (
React.createElement(App,null));}}]);return Noder;})(Component);




AppRegistry.registerComponent('noder',function(){return Noder;});
});
__d('react-native/Libraries/react-native/react-native.js',["React","ActivityIndicatorIOS","DatePickerIOS","Image","ListView","MapView","Navigator","NavigatorIOS","PickerIOS","ProgressViewIOS","ScrollView","SegmentedControlIOS","SliderIOS","SwitchIOS","TabBarIOS","Text","TextInput","TouchableHighlight","TouchableOpacity","TouchableWithoutFeedback","View","WebView","AlertIOS","AppRegistry","AppStateIOS","AsyncStorage","CameraRoll","ImagePickerIOS","InteractionManager","LayoutAnimation","LinkingIOS","NetInfo","PanResponder","PixelRatio","PushNotificationIOS","StatusBarIOS","StyleSheet","VibrationIOS","RCTDeviceEventEmitter","RCTNativeAppEventEmitter","NativeModules","Platform","requireNativeComponent","EdgeInsetsPropType","PointPropType","LinkedStateMixin","ReactComponentWithPureRenderMixin","NativeModules","ReactUpdates","cloneWithProps","ReactFragment","update","ReactDefaultPerf","ReactTestUtils"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';


















var ReactNative=Object.assign(Object.create(require('React')),{

ActivityIndicatorIOS:require('ActivityIndicatorIOS'),
DatePickerIOS:require('DatePickerIOS'),
Image:require('Image'),
ListView:require('ListView'),
MapView:require('MapView'),
Navigator:require('Navigator'),
NavigatorIOS:require('NavigatorIOS'),
PickerIOS:require('PickerIOS'),
ProgressViewIOS:require('ProgressViewIOS'),
ScrollView:require('ScrollView'),
SegmentedControlIOS:require('SegmentedControlIOS'),
SliderIOS:require('SliderIOS'),
SwitchIOS:require('SwitchIOS'),
TabBarIOS:require('TabBarIOS'),
Text:require('Text'),
TextInput:require('TextInput'),
TouchableHighlight:require('TouchableHighlight'),
TouchableOpacity:require('TouchableOpacity'),
TouchableWithoutFeedback:require('TouchableWithoutFeedback'),
View:require('View'),
WebView:require('WebView'),


AlertIOS:require('AlertIOS'),
AppRegistry:require('AppRegistry'),
AppStateIOS:require('AppStateIOS'),
AsyncStorage:require('AsyncStorage'),
CameraRoll:require('CameraRoll'),
ImagePickerIOS:require('ImagePickerIOS'),
InteractionManager:require('InteractionManager'),
LayoutAnimation:require('LayoutAnimation'),
LinkingIOS:require('LinkingIOS'),
NetInfo:require('NetInfo'),
PanResponder:require('PanResponder'),
PixelRatio:require('PixelRatio'),
PushNotificationIOS:require('PushNotificationIOS'),
StatusBarIOS:require('StatusBarIOS'),
StyleSheet:require('StyleSheet'),
VibrationIOS:require('VibrationIOS'),


DeviceEventEmitter:require('RCTDeviceEventEmitter'),
NativeAppEventEmitter:require('RCTNativeAppEventEmitter'),
NativeModules:require('NativeModules'),
Platform:require('Platform'),
requireNativeComponent:require('requireNativeComponent'),


EdgeInsetsPropType:require('EdgeInsetsPropType'),
PointPropType:require('PointPropType'),

addons:{
LinkedStateMixin:require('LinkedStateMixin'),
Perf:undefined,
PureRenderMixin:require('ReactComponentWithPureRenderMixin'),
TestModule:require('NativeModules').TestModule,
TestUtils:undefined,
batchedUpdates:require('ReactUpdates').batchedUpdates,
cloneWithProps:require('cloneWithProps'),
createFragment:require('ReactFragment').create,
update:require('update')}});



if(__DEV__){
ReactNative.addons.Perf = require('ReactDefaultPerf');
ReactNative.addons.TestUtils = require('ReactTestUtils');}


module.exports = ReactNative;
});
__d('React',["ReactNative"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












module.exports = require('ReactNative');
});
__d('ReactNative',["ReactChildren","ReactClass","ReactComponent","ReactContext","ReactCurrentOwner","ReactElement","ReactElementValidator","ReactInstanceHandles","ReactNativeDefaultInjection","ReactNativeMount","ReactPropTypes","deprecated","findNodeHandle","invariant","onlyChild","ReactReconciler","ReactNativeTextComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactChildren=require('ReactChildren');
var ReactClass=require('ReactClass');
var ReactComponent=require('ReactComponent');
var ReactContext=require('ReactContext');
var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactElement=require('ReactElement');
var ReactElementValidator=require('ReactElementValidator');
var ReactInstanceHandles=require('ReactInstanceHandles');
var ReactNativeDefaultInjection=require('ReactNativeDefaultInjection');
var ReactNativeMount=require('ReactNativeMount');
var ReactPropTypes=require('ReactPropTypes');

var deprecated=require('deprecated');
var findNodeHandle=require('findNodeHandle');
var invariant=require('invariant');
var onlyChild=require('onlyChild');

ReactNativeDefaultInjection.inject();

var createElement=ReactElement.createElement;
var createFactory=ReactElement.createFactory;
var cloneElement=ReactElement.cloneElement;

if(__DEV__){
createElement = ReactElementValidator.createElement;
createFactory = ReactElementValidator.createFactory;
cloneElement = ReactElementValidator.cloneElement;}


var resolveDefaultProps=function(element){

var defaultProps=element.type.defaultProps;
var props=element.props;
for(var propName in defaultProps) {
if(props[propName] === undefined){
props[propName] = defaultProps[propName];}}};





var augmentElement=function(element){
if(__DEV__){
invariant(
false,
'This optimized path should never be used in DEV mode because ' + 
'it does not provide validation. Check your JSX transform.');}


element._owner = ReactCurrentOwner.current;
element._context = ReactContext.current;
if(element.type.defaultProps){
resolveDefaultProps(element);}

return element;};


var render=function(
element,
mountInto,
callback)
{
return ReactNativeMount.renderComponent(element,mountInto,callback);};


var ReactNative={
hasReactNativeInitialized:false,
Children:{
map:ReactChildren.map,
forEach:ReactChildren.forEach,
count:ReactChildren.count,
only:onlyChild},

Component:ReactComponent,
PropTypes:ReactPropTypes,
createClass:ReactClass.createClass,
createElement:createElement,
createFactory:createFactory,
cloneElement:cloneElement,
_augmentElement:augmentElement,
findNodeHandle:findNodeHandle,
render:render,
unmountComponentAtNode:ReactNativeMount.unmountComponentAtNode,


__spread:Object.assign,

unmountComponentAtNodeAndRemoveContainer:ReactNativeMount.unmountComponentAtNodeAndRemoveContainer,
isValidClass:ReactElement.isValidFactory,
isValidElement:ReactElement.isValidElement,


renderComponent:deprecated(
'React',
'renderComponent',
'render',
this,
render),

isValidComponent:deprecated(
'React',
'isValidComponent',
'isValidElement',
this,
ReactElement.isValidElement)};






if(
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && 
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function'){
__REACT_DEVTOOLS_GLOBAL_HOOK__.inject({
CurrentOwner:ReactCurrentOwner,
InstanceHandles:ReactInstanceHandles,
Mount:ReactNativeMount,
Reconciler:require('ReactReconciler'),
TextComponent:require('ReactNativeTextComponent')});}



module.exports = ReactNative;
});
__d('ReactChildren',["PooledClass","ReactFragment","traverseAllChildren","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var PooledClass=require('PooledClass');
var ReactFragment=require('ReactFragment');

var traverseAllChildren=require('traverseAllChildren');
var warning=require('warning');

var twoArgumentPooler=PooledClass.twoArgumentPooler;
var threeArgumentPooler=PooledClass.threeArgumentPooler;









function ForEachBookKeeping(forEachFunction,forEachContext){
this.forEachFunction = forEachFunction;
this.forEachContext = forEachContext;}

PooledClass.addPoolingTo(ForEachBookKeeping,twoArgumentPooler);

function forEachSingleChild(traverseContext,child,name,i){
var forEachBookKeeping=traverseContext;
forEachBookKeeping.forEachFunction.call(
forEachBookKeeping.forEachContext,child,i);}












function forEachChildren(children,forEachFunc,forEachContext){
if(children == null){
return children;}


var traverseContext=
ForEachBookKeeping.getPooled(forEachFunc,forEachContext);
traverseAllChildren(children,forEachSingleChild,traverseContext);
ForEachBookKeeping.release(traverseContext);}











function MapBookKeeping(mapResult,mapFunction,mapContext){
this.mapResult = mapResult;
this.mapFunction = mapFunction;
this.mapContext = mapContext;}

PooledClass.addPoolingTo(MapBookKeeping,threeArgumentPooler);

function mapSingleChildIntoContext(traverseContext,child,name,i){
var mapBookKeeping=traverseContext;
var mapResult=mapBookKeeping.mapResult;

var keyUnique=!mapResult.hasOwnProperty(name);
if(__DEV__){
warning(
keyUnique,
'ReactChildren.map(...): Encountered two children with the same key, ' + 
'`%s`. Child keys must be unique; when two children share a key, only ' + 
'the first child will be used.',
name);}



if(keyUnique){
var mappedChild=
mapBookKeeping.mapFunction.call(mapBookKeeping.mapContext,child,i);
mapResult[name] = mappedChild;}}

















function mapChildren(children,func,context){
if(children == null){
return children;}


var mapResult={};
var traverseContext=MapBookKeeping.getPooled(mapResult,func,context);
traverseAllChildren(children,mapSingleChildIntoContext,traverseContext);
MapBookKeeping.release(traverseContext);
return ReactFragment.create(mapResult);}


function forEachSingleChildDummy(traverseContext,child,name,i){
return null;}









function countChildren(children,context){
return traverseAllChildren(children,forEachSingleChildDummy,null);}


var ReactChildren={
forEach:forEachChildren,
map:mapChildren,
count:countChildren};


module.exports = ReactChildren;
});
__d('PooledClass',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');








var oneArgumentPooler=function(copyFieldsFrom){
var Klass=this;
if(Klass.instancePool.length){
var instance=Klass.instancePool.pop();
Klass.call(instance,copyFieldsFrom);
return instance;}else 
{
return new Klass(copyFieldsFrom);}};



var twoArgumentPooler=function(a1,a2){
var Klass=this;
if(Klass.instancePool.length){
var instance=Klass.instancePool.pop();
Klass.call(instance,a1,a2);
return instance;}else 
{
return new Klass(a1,a2);}};



var threeArgumentPooler=function(a1,a2,a3){
var Klass=this;
if(Klass.instancePool.length){
var instance=Klass.instancePool.pop();
Klass.call(instance,a1,a2,a3);
return instance;}else 
{
return new Klass(a1,a2,a3);}};



var fiveArgumentPooler=function(a1,a2,a3,a4,a5){
var Klass=this;
if(Klass.instancePool.length){
var instance=Klass.instancePool.pop();
Klass.call(instance,a1,a2,a3,a4,a5);
return instance;}else 
{
return new Klass(a1,a2,a3,a4,a5);}};



var standardReleaser=function(instance){
var Klass=this;
invariant(
instance instanceof Klass,
'Trying to release an instance into a pool of a different type.');

if(instance.destructor){
instance.destructor();}

if(Klass.instancePool.length < Klass.poolSize){
Klass.instancePool.push(instance);}};



var DEFAULT_POOL_SIZE=10;
var DEFAULT_POOLER=oneArgumentPooler;










var addPoolingTo=function(CopyConstructor,pooler){
var NewKlass=CopyConstructor;
NewKlass.instancePool = [];
NewKlass.getPooled = pooler || DEFAULT_POOLER;
if(!NewKlass.poolSize){
NewKlass.poolSize = DEFAULT_POOL_SIZE;}

NewKlass.release = standardReleaser;
return NewKlass;};


var PooledClass={
addPoolingTo:addPoolingTo,
oneArgumentPooler:oneArgumentPooler,
twoArgumentPooler:twoArgumentPooler,
threeArgumentPooler:threeArgumentPooler,
fiveArgumentPooler:fiveArgumentPooler};


module.exports = PooledClass;
});
__d('invariant',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';























var invariant=function(condition,format,a,b,c,d,e,f){
if(__DEV__){
if(format === undefined){
throw new Error('invariant requires an error message argument');}}



if(!condition){
var error;
if(format === undefined){
error = new Error(
'Minified exception occurred; use the non-minified dev environment ' + 
'for the full error message and additional helpful warnings.');}else 

{
var args=[a,b,c,d,e,f];
var argIndex=0;
error = new Error(
'Invariant Violation: ' + 
format.replace(/%s/g,function(){return args[argIndex++];}));}



error.framesToPop = 1;
throw error;}};



module.exports = invariant;
});
__d('ReactFragment',["ReactElement","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactElement=require('ReactElement');

var warning=require('warning');









if(__DEV__){
var fragmentKey='_reactFragment';
var didWarnKey='_reactDidWarn';
var canWarnForReactFragment=false;

try{



var dummy=function(){
return 1;};


Object.defineProperty(
{},
fragmentKey,
{enumerable:false,value:true});


Object.defineProperty(
{},
'key',
{enumerable:true,get:dummy});


canWarnForReactFragment = true;}
catch(x) {}

var proxyPropertyAccessWithWarning=function(obj,key){
Object.defineProperty(obj,key,{
enumerable:true,
get:function(){
warning(
this[didWarnKey],
'A ReactFragment is an opaque type. Accessing any of its ' + 
'properties is deprecated. Pass it to one of the React.Children ' + 
'helpers.');

this[didWarnKey] = true;
return this[fragmentKey][key];},

set:function(value){
warning(
this[didWarnKey],
'A ReactFragment is an immutable opaque type. Mutating its ' + 
'properties is deprecated.');

this[didWarnKey] = true;
this[fragmentKey][key] = value;}});};




var issuedWarnings={};

var didWarnForFragment=function(fragment){


var fragmentCacheKey='';
for(var key in fragment) {
fragmentCacheKey += key + ':' + typeof fragment[key] + ',';}

var alreadyWarnedOnce=!!issuedWarnings[fragmentCacheKey];
issuedWarnings[fragmentCacheKey] = true;
return alreadyWarnedOnce;};}



var ReactFragment={


create:function(object){
if(__DEV__){
if(typeof object !== 'object' || !object || Array.isArray(object)){
warning(
false,
'React.addons.createFragment only accepts a single object.',
object);

return object;}

if(ReactElement.isValidElement(object)){
warning(
false,
'React.addons.createFragment does not accept a ReactElement ' + 
'without a wrapper object.');

return object;}

if(canWarnForReactFragment){
var proxy={};
Object.defineProperty(proxy,fragmentKey,{
enumerable:false,
value:object});

Object.defineProperty(proxy,didWarnKey,{
writable:true,
enumerable:false,
value:false});

for(var key in object) {
proxyPropertyAccessWithWarning(proxy,key);}

Object.preventExtensions(proxy);
return proxy;}}


return object;},



extract:function(fragment){
if(__DEV__){
if(canWarnForReactFragment){
if(!fragment[fragmentKey]){
warning(
didWarnForFragment(fragment),
'Any use of a keyed object should be wrapped in ' + 
'React.addons.createFragment(object) before being passed as a ' + 
'child.');

return fragment;}

return fragment[fragmentKey];}}


return fragment;},




extractIfFragment:function(fragment){
if(__DEV__){
if(canWarnForReactFragment){

if(fragment[fragmentKey]){
return fragment[fragmentKey];}




for(var key in fragment) {
if(fragment.hasOwnProperty(key) && 
ReactElement.isValidElement(fragment[key])){


return ReactFragment.extract(fragment);}}}}




return fragment;}};



module.exports = ReactFragment;
});
__d('ReactElement',["ReactContext","ReactCurrentOwner","Object.assign","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactContext=require('ReactContext');
var ReactCurrentOwner=require('ReactCurrentOwner');

var assign=require('Object.assign');
var warning=require('warning');

var RESERVED_PROPS={
key:true,
ref:true};









function defineWarningProperty(object,key){
Object.defineProperty(object,key,{

configurable:false,
enumerable:true,

get:function(){
if(!this._store){
return null;}

return this._store[key];},


set:function(value){
warning(
false,
'Don\'t set the %s property of the React element. Instead, ' + 
'specify the correct value when initially creating the element.',
key);

this._store[key] = value;}});}








var useMutationMembrane=false;







function defineMutationMembrane(prototype){
try{
var pseudoFrozenProperties={
props:true};

for(var key in pseudoFrozenProperties) {
defineWarningProperty(prototype,key);}

useMutationMembrane = true;}
catch(x) {}}














var ReactElement=function(type,key,ref,owner,context,props){

this.type = type;
this.key = key;
this.ref = ref;


this._owner = owner;



this._context = context;

if(__DEV__){




this._store = {props:props,originalProps:assign({},props)};





try{
Object.defineProperty(this._store,'validated',{
configurable:false,
enumerable:false,
writable:true});}

catch(x) {}

this._store.validated = false;




if(useMutationMembrane){
Object.freeze(this);
return;}}



this.props = props;};




ReactElement.prototype = {
_isReactElement:true};


if(__DEV__){
defineMutationMembrane(ReactElement.prototype);}


ReactElement.createElement = function(type,config,children){
var propName;


var props={};

var key=null;
var ref=null;

if(config != null){
ref = config.ref === undefined?null:config.ref;
key = config.key === undefined?null:'' + config.key;

for(propName in config) {
if(config.hasOwnProperty(propName) && 
!RESERVED_PROPS.hasOwnProperty(propName)){
props[propName] = config[propName];}}}






var childrenLength=arguments.length - 2;
if(childrenLength === 1){
props.children = children;}else 
if(childrenLength > 1){
var childArray=Array(childrenLength);
for(var i=0;i < childrenLength;i++) {
childArray[i] = arguments[i + 2];}

props.children = childArray;}



if(type && type.defaultProps){
var defaultProps=type.defaultProps;
for(propName in defaultProps) {
if(typeof props[propName] === 'undefined'){
props[propName] = defaultProps[propName];}}}




return new ReactElement(
type,
key,
ref,
ReactCurrentOwner.current,
ReactContext.current,
props);};



ReactElement.createFactory = function(type){
var factory=ReactElement.createElement.bind(null,type);





factory.type = type;
return factory;};


ReactElement.cloneAndReplaceProps = function(oldElement,newProps){
var newElement=new ReactElement(
oldElement.type,
oldElement.key,
oldElement.ref,
oldElement._owner,
oldElement._context,
newProps);


if(__DEV__){

newElement._store.validated = oldElement._store.validated;}

return newElement;};


ReactElement.cloneElement = function(element,config,children){
var propName;


var props=assign({},element.props);


var key=element.key;
var ref=element.ref;


var owner=element._owner;

if(config != null){
if(config.ref !== undefined){

ref = config.ref;
owner = ReactCurrentOwner.current;}

if(config.key !== undefined){
key = '' + config.key;}


for(propName in config) {
if(config.hasOwnProperty(propName) && 
!RESERVED_PROPS.hasOwnProperty(propName)){
props[propName] = config[propName];}}}






var childrenLength=arguments.length - 2;
if(childrenLength === 1){
props.children = children;}else 
if(childrenLength > 1){
var childArray=Array(childrenLength);
for(var i=0;i < childrenLength;i++) {
childArray[i] = arguments[i + 2];}

props.children = childArray;}


return new ReactElement(
element.type,
key,
ref,
owner,
element._context,
props);};








ReactElement.isValidElement = function(object){




var isElement=!!(object && object._isReactElement);





return isElement;};


module.exports = ReactElement;
});
__d('ReactContext',["Object.assign","emptyObject","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var assign=require('Object.assign');
var emptyObject=require('emptyObject');
var warning=require('warning');

var didWarn=false;







var ReactContext={





current:emptyObject,

















withContext:function(newContext,scopedCallback){
if(__DEV__){
warning(
didWarn,
'withContext is deprecated and will be removed in a future version. ' + 
'Use a wrapper component with getChildContext instead.');


didWarn = true;}


var result;
var previousContext=ReactContext.current;
ReactContext.current = assign({},previousContext,newContext);
try{
result = scopedCallback();}finally 
{
ReactContext.current = previousContext;}

return result;}};




module.exports = ReactContext;
});
__d('Object.assign',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';














function assign(target,sources){
if(target == null){
throw new TypeError('Object.assign target cannot be null or undefined');}


var to=Object(target);
var hasOwnProperty=Object.prototype.hasOwnProperty;

for(var nextIndex=1;nextIndex < arguments.length;nextIndex++) {
var nextSource=arguments[nextIndex];
if(nextSource == null){
continue;}


var from=Object(nextSource);






for(var key in from) {
if(hasOwnProperty.call(from,key)){
to[key] = from[key];}}}




return to;}


module.exports = assign;
});
__d('emptyObject',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";












var emptyObject={};

if(__DEV__){
Object.freeze(emptyObject);}


module.exports = emptyObject;
});
__d('warning',["emptyFunction"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var emptyFunction=require('emptyFunction');








var warning=emptyFunction;

if(__DEV__){
warning = function(condition,format){for(var _len=arguments.length,args=Array(_len > 2?_len - 2:0),_key=2;_key < _len;_key++) {args[_key - 2] = arguments[_key];}
if(format === undefined){
throw new Error(
'`warning(condition, format, ...args)` requires a warning ' + 
'message argument');}



if(format.length < 10 || /^[s\W]*$/.test(format)){
throw new Error(
'The warning format should be able to uniquely identify this ' + 
'warning. Please, use a more descriptive format than: ' + format);}



if(format.indexOf('Failed Composite propType: ') === 0){
return;}


if(!condition){
var argIndex=0;
var message='Warning: ' + format.replace(/%s/g,function(){return args[argIndex++];});
console.warn(message);
try{



throw new Error(message);}
catch(x) {}}};}




module.exports = warning;
});
__d('emptyFunction',[],function(global, require, requireDynamic, requireLazy, module, exports) {  function 










makeEmptyFunction(arg){
return function(){
return arg;};}








function emptyFunction(){}

emptyFunction.thatReturns = makeEmptyFunction;
emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
emptyFunction.thatReturnsNull = makeEmptyFunction(null);
emptyFunction.thatReturnsThis = function(){return this;};
emptyFunction.thatReturnsArgument = function(arg){return arg;};

module.exports = emptyFunction;
});
__d('ReactCurrentOwner',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




















var ReactCurrentOwner={





current:null};



module.exports = ReactCurrentOwner;
});
__d('traverseAllChildren',["ReactElement","ReactFragment","ReactInstanceHandles","getIteratorFn","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactElement=require('ReactElement');
var ReactFragment=require('ReactFragment');
var ReactInstanceHandles=require('ReactInstanceHandles');

var getIteratorFn=require('getIteratorFn');
var invariant=require('invariant');
var warning=require('warning');

var SEPARATOR=ReactInstanceHandles.SEPARATOR;
var SUBSEPARATOR=':';






var userProvidedKeyEscaperLookup={
'=':'=0',
'.':'=1',
':':'=2'};


var userProvidedKeyEscapeRegex=/[=.:]/g;

var didWarnAboutMaps=false;

function userProvidedKeyEscaper(match){
return userProvidedKeyEscaperLookup[match];}









function getComponentKey(component,index){
if(component && component.key != null){

return wrapUserProvidedKey(component.key);}


return index.toString(36);}








function escapeUserProvidedKey(text){
return ('' + text).replace(
userProvidedKeyEscapeRegex,
userProvidedKeyEscaper);}










function wrapUserProvidedKey(key){
return '$' + escapeUserProvidedKey(key);}











function traverseAllChildrenImpl(
children,
nameSoFar,
indexSoFar,
callback,
traverseContext)
{
var type=typeof children;

if(type === 'undefined' || type === 'boolean'){

children = null;}


if(children === null || 
type === 'string' || 
type === 'number' || 
ReactElement.isValidElement(children)){
callback(
traverseContext,
children,


nameSoFar === ''?SEPARATOR + getComponentKey(children,0):nameSoFar,
indexSoFar);

return 1;}


var child,nextName,nextIndex;
var subtreeCount=0;

if(Array.isArray(children)){
for(var i=0;i < children.length;i++) {
child = children[i];
nextName = 
(nameSoFar !== ''?nameSoFar + SUBSEPARATOR:SEPARATOR) + 
getComponentKey(child,i);

nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
callback,
traverseContext);}}else 


{
var iteratorFn=getIteratorFn(children);
if(iteratorFn){
var iterator=iteratorFn.call(children);
var step;
if(iteratorFn !== children.entries){
var ii=0;
while(!(step = iterator.next()).done) {
child = step.value;
nextName = 
(nameSoFar !== ''?nameSoFar + SUBSEPARATOR:SEPARATOR) + 
getComponentKey(child,ii++);

nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
callback,
traverseContext);}}else 


{
if(__DEV__){
warning(
didWarnAboutMaps,
'Using Maps as children is not yet fully supported. It is an ' + 
'experimental feature that might be removed. Convert it to a ' + 
'sequence / iterable of keyed ReactElements instead.');

didWarnAboutMaps = true;}


while(!(step = iterator.next()).done) {
var entry=step.value;
if(entry){
child = entry[1];
nextName = 
(nameSoFar !== ''?nameSoFar + SUBSEPARATOR:SEPARATOR) + 
wrapUserProvidedKey(entry[0]) + SUBSEPARATOR + 
getComponentKey(child,0);

nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
callback,
traverseContext);}}}}else 




if(type === 'object'){
invariant(
children.nodeType !== 1,
'traverseAllChildren(...): Encountered an invalid child; DOM ' + 
'elements are not valid children of React components.');

var fragment=ReactFragment.extract(children);
for(var key in fragment) {
if(fragment.hasOwnProperty(key)){
child = fragment[key];
nextName = 
(nameSoFar !== ''?nameSoFar + SUBSEPARATOR:SEPARATOR) + 
wrapUserProvidedKey(key) + SUBSEPARATOR + 
getComponentKey(child,0);

nextIndex = indexSoFar + subtreeCount;
subtreeCount += traverseAllChildrenImpl(
child,
nextName,
nextIndex,
callback,
traverseContext);}}}}






return subtreeCount;}


















function traverseAllChildren(children,callback,traverseContext){
if(children == null){
return 0;}


return traverseAllChildrenImpl(children,'',0,callback,traverseContext);}


module.exports = traverseAllChildren;
});
__d('ReactInstanceHandles',["ReactRootIndex","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




















var ReactRootIndex=require('ReactRootIndex');

var invariant=require('invariant');

var SEPARATOR='.';
var SEPARATOR_LENGTH=SEPARATOR.length;




var MAX_TREE_DEPTH=100;








function getReactRootIDString(index){
return SEPARATOR + index.toString(36);}










function isBoundary(id,index){
return id.charAt(index) === SEPARATOR || index === id.length;}









function isValidID(id){
return id === '' || 
id.charAt(0) === SEPARATOR && id.charAt(id.length - 1) !== SEPARATOR;}











function isAncestorIDOf(ancestorID,descendantID){
return (
descendantID.indexOf(ancestorID) === 0 && 
isBoundary(descendantID,ancestorID.length));}










function getParentID(id){
return id?id.substr(0,id.lastIndexOf(SEPARATOR)):'';}











function getNextDescendantID(ancestorID,destinationID){
invariant(
isValidID(ancestorID) && isValidID(destinationID),
'getNextDescendantID(%s, %s): Received an invalid React DOM ID.',
ancestorID,
destinationID);

invariant(
isAncestorIDOf(ancestorID,destinationID),
'getNextDescendantID(...): React has made an invalid assumption about ' + 
'the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.',
ancestorID,
destinationID);

if(ancestorID === destinationID){
return ancestorID;}



var start=ancestorID.length + SEPARATOR_LENGTH;
for(var i=start;i < destinationID.length;i++) {
if(isBoundary(destinationID,i)){
break;}}


return destinationID.substr(0,i);}













function getFirstCommonAncestorID(oneID,twoID){
var minLength=Math.min(oneID.length,twoID.length);
if(minLength === 0){
return '';}

var lastCommonMarkerIndex=0;

for(var i=0;i <= minLength;i++) {
if(isBoundary(oneID,i) && isBoundary(twoID,i)){
lastCommonMarkerIndex = i;}else 
if(oneID.charAt(i) !== twoID.charAt(i)){
break;}}


var longestCommonID=oneID.substr(0,lastCommonMarkerIndex);
invariant(
isValidID(longestCommonID),
'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s',
oneID,
twoID,
longestCommonID);

return longestCommonID;}














function traverseParentPath(start,stop,cb,arg,skipFirst,skipLast){
start = start || '';
stop = stop || '';
invariant(
start !== stop,
'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.',
start);

var traverseUp=isAncestorIDOf(stop,start);
invariant(
traverseUp || isAncestorIDOf(start,stop),
'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' + 
'not have a parent path.',
start,
stop);


var depth=0;
var traverse=traverseUp?getParentID:getNextDescendantID;
for(var id=start;;id = traverse(id,stop)) {
var ret;
if((!skipFirst || id !== start) && (!skipLast || id !== stop)){
ret = cb(id,traverseUp,arg);}

if(ret === false || id === stop){

break;}

invariant(
depth++ < MAX_TREE_DEPTH,
'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' + 
'traversing the React DOM ID tree. This may be due to malformed IDs: %s',
start,stop);}}











var ReactInstanceHandles={





createReactRootID:function(){
return getReactRootIDString(ReactRootIndex.createReactRootIndex());},










createReactID:function(rootID,name){
return rootID + name;},










getReactRootIDFromNodeID:function(id){
if(id && id.charAt(0) === SEPARATOR && id.length > 1){
var index=id.indexOf(SEPARATOR,1);
return index > -1?id.substr(0,index):id;}

return null;},
















traverseEnterLeave:function(leaveID,enterID,cb,upArg,downArg){
var ancestorID=getFirstCommonAncestorID(leaveID,enterID);
if(ancestorID !== leaveID){
traverseParentPath(leaveID,ancestorID,cb,upArg,false,true);}

if(ancestorID !== enterID){
traverseParentPath(ancestorID,enterID,cb,downArg,true,false);}},













traverseTwoPhase:function(targetID,cb,arg){
if(targetID){
traverseParentPath('',targetID,cb,arg,true,false);
traverseParentPath(targetID,'',cb,arg,false,true);}},






traverseTwoPhaseSkipTarget:function(targetID,cb,arg){
if(targetID){
traverseParentPath('',targetID,cb,arg,true,true);
traverseParentPath(targetID,'',cb,arg,true,true);}},















traverseAncestors:function(targetID,cb,arg){
traverseParentPath('',targetID,cb,arg,true,false);},






_getFirstCommonAncestorID:getFirstCommonAncestorID,





_getNextDescendantID:getNextDescendantID,

isAncestorIDOf:isAncestorIDOf,

SEPARATOR:SEPARATOR};



module.exports = ReactInstanceHandles;
});
__d('ReactRootIndex',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactRootIndexInjection={



injectCreateReactRootIndex:function(_createReactRootIndex){
ReactRootIndex.createReactRootIndex = _createReactRootIndex;}};



var ReactRootIndex={
createReactRootIndex:null,
injection:ReactRootIndexInjection};


module.exports = ReactRootIndex;
});
__d('getIteratorFn',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';














var ITERATOR_SYMBOL=typeof Symbol === 'function' && Symbol.iterator;
var FAUX_ITERATOR_SYMBOL='@@iterator';















function getIteratorFn(maybeIterable){
var iteratorFn=maybeIterable && (
ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || 
maybeIterable[FAUX_ITERATOR_SYMBOL]);

if(typeof iteratorFn === 'function'){
return iteratorFn;}}



module.exports = getIteratorFn;
});
__d('ReactClass',["ReactComponent","ReactCurrentOwner","ReactElement","ReactErrorUtils","ReactInstanceMap","ReactLifeCycle","ReactPropTypeLocations","ReactPropTypeLocationNames","ReactUpdateQueue","Object.assign","invariant","keyMirror","keyOf","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactComponent=require('ReactComponent');
var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactElement=require('ReactElement');
var ReactErrorUtils=require('ReactErrorUtils');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactLifeCycle=require('ReactLifeCycle');
var ReactPropTypeLocations=require('ReactPropTypeLocations');
var ReactPropTypeLocationNames=require('ReactPropTypeLocationNames');
var ReactUpdateQueue=require('ReactUpdateQueue');

var assign=require('Object.assign');
var invariant=require('invariant');
var keyMirror=require('keyMirror');
var keyOf=require('keyOf');
var warning=require('warning');

var MIXINS_KEY=keyOf({mixins:null});




var SpecPolicy=keyMirror({



DEFINE_ONCE:null,




DEFINE_MANY:null,



OVERRIDE_BASE:null,





DEFINE_MANY_MERGED:null});



var injectedMixins=[];























var ReactClassInterface={







mixins:SpecPolicy.DEFINE_MANY,








statics:SpecPolicy.DEFINE_MANY,







propTypes:SpecPolicy.DEFINE_MANY,







contextTypes:SpecPolicy.DEFINE_MANY,







childContextTypes:SpecPolicy.DEFINE_MANY,













getDefaultProps:SpecPolicy.DEFINE_MANY_MERGED,















getInitialState:SpecPolicy.DEFINE_MANY_MERGED,





getChildContext:SpecPolicy.DEFINE_MANY_MERGED,

















render:SpecPolicy.DEFINE_ONCE,












componentWillMount:SpecPolicy.DEFINE_MANY,











componentDidMount:SpecPolicy.DEFINE_MANY,




















componentWillReceiveProps:SpecPolicy.DEFINE_MANY,





















shouldComponentUpdate:SpecPolicy.DEFINE_ONCE,
















componentWillUpdate:SpecPolicy.DEFINE_MANY,













componentDidUpdate:SpecPolicy.DEFINE_MANY,












componentWillUnmount:SpecPolicy.DEFINE_MANY,















updateComponent:SpecPolicy.OVERRIDE_BASE};












var RESERVED_SPEC_KEYS={
displayName:function(Constructor,displayName){
Constructor.displayName = displayName;},

mixins:function(Constructor,mixins){
if(mixins){
for(var i=0;i < mixins.length;i++) {
mixSpecIntoComponent(Constructor,mixins[i]);}}},



childContextTypes:function(Constructor,childContextTypes){
if(__DEV__){
validateTypeDef(
Constructor,
childContextTypes,
ReactPropTypeLocations.childContext);}


Constructor.childContextTypes = assign(
{},
Constructor.childContextTypes,
childContextTypes);},


contextTypes:function(Constructor,contextTypes){
if(__DEV__){
validateTypeDef(
Constructor,
contextTypes,
ReactPropTypeLocations.context);}


Constructor.contextTypes = assign(
{},
Constructor.contextTypes,
contextTypes);},






getDefaultProps:function(Constructor,getDefaultProps){
if(Constructor.getDefaultProps){
Constructor.getDefaultProps = createMergedResultFunction(
Constructor.getDefaultProps,
getDefaultProps);}else 

{
Constructor.getDefaultProps = getDefaultProps;}},


propTypes:function(Constructor,propTypes){
if(__DEV__){
validateTypeDef(
Constructor,
propTypes,
ReactPropTypeLocations.prop);}


Constructor.propTypes = assign(
{},
Constructor.propTypes,
propTypes);},


statics:function(Constructor,statics){
mixStaticSpecIntoComponent(Constructor,statics);}};



function validateTypeDef(Constructor,typeDef,location){
for(var propName in typeDef) {
if(typeDef.hasOwnProperty(propName)){


warning(
typeof typeDef[propName] === 'function',
'%s: %s type `%s` is invalid; it must be a function, usually from ' + 
'React.PropTypes.',
Constructor.displayName || 'ReactClass',
ReactPropTypeLocationNames[location],
propName);}}}





function validateMethodOverride(proto,name){
var specPolicy=ReactClassInterface.hasOwnProperty(name)?
ReactClassInterface[name]:
null;


if(ReactClassMixin.hasOwnProperty(name)){
invariant(
specPolicy === SpecPolicy.OVERRIDE_BASE,
'ReactClassInterface: You are attempting to override ' + 
'`%s` from your class specification. Ensure that your method names ' + 
'do not overlap with React methods.',
name);}




if(proto.hasOwnProperty(name)){
invariant(
specPolicy === SpecPolicy.DEFINE_MANY || 
specPolicy === SpecPolicy.DEFINE_MANY_MERGED,
'ReactClassInterface: You are attempting to define ' + 
'`%s` on your component more than once. This conflict may be due ' + 
'to a mixin.',
name);}}








function mixSpecIntoComponent(Constructor,spec){
if(!spec){
return;}


invariant(
typeof spec !== 'function',
'ReactClass: You\'re attempting to ' + 
'use a component class as a mixin. Instead, just use a regular object.');

invariant(
!ReactElement.isValidElement(spec),
'ReactClass: You\'re attempting to ' + 
'use a component as a mixin. Instead, just use a regular object.');


var proto=Constructor.prototype;




if(spec.hasOwnProperty(MIXINS_KEY)){
RESERVED_SPEC_KEYS.mixins(Constructor,spec.mixins);}


for(var name in spec) {
if(!spec.hasOwnProperty(name)){
continue;}


if(name === MIXINS_KEY){

continue;}


var property=spec[name];
validateMethodOverride(proto,name);

if(RESERVED_SPEC_KEYS.hasOwnProperty(name)){
RESERVED_SPEC_KEYS[name](Constructor,property);}else 
{




var isReactClassMethod=
ReactClassInterface.hasOwnProperty(name);
var isAlreadyDefined=proto.hasOwnProperty(name);
var markedDontBind=property && property.__reactDontBind;
var isFunction=typeof property === 'function';
var shouldAutoBind=
isFunction && 
!isReactClassMethod && 
!isAlreadyDefined && 
!markedDontBind;

if(shouldAutoBind){
if(!proto.__reactAutoBindMap){
proto.__reactAutoBindMap = {};}

proto.__reactAutoBindMap[name] = property;
proto[name] = property;}else 
{
if(isAlreadyDefined){
var specPolicy=ReactClassInterface[name];


invariant(
isReactClassMethod && (
specPolicy === SpecPolicy.DEFINE_MANY_MERGED || 
specPolicy === SpecPolicy.DEFINE_MANY),

'ReactClass: Unexpected spec policy %s for key %s ' + 
'when mixing in component specs.',
specPolicy,
name);




if(specPolicy === SpecPolicy.DEFINE_MANY_MERGED){
proto[name] = createMergedResultFunction(proto[name],property);}else 
if(specPolicy === SpecPolicy.DEFINE_MANY){
proto[name] = createChainedFunction(proto[name],property);}}else 

{
proto[name] = property;
if(__DEV__){


if(typeof property === 'function' && spec.displayName){
proto[name].displayName = spec.displayName + '_' + name;}}}}}}}








function mixStaticSpecIntoComponent(Constructor,statics){
if(!statics){
return;}

for(var name in statics) {
var property=statics[name];
if(!statics.hasOwnProperty(name)){
continue;}


var isReserved=(name in RESERVED_SPEC_KEYS);
invariant(
!isReserved,
'ReactClass: You are attempting to define a reserved ' + 
'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + 
'as an instance property instead; it will still be accessible on the ' + 
'constructor.',
name);


var isInherited=(name in Constructor);
invariant(
!isInherited,
'ReactClass: You are attempting to define ' + 
'`%s` on your component more than once. This conflict may be ' + 
'due to a mixin.',
name);

Constructor[name] = property;}}










function mergeIntoWithNoDuplicateKeys(one,two){
invariant(
one && two && typeof one === 'object' && typeof two === 'object',
'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.');


for(var key in two) {
if(two.hasOwnProperty(key)){
invariant(
one[key] === undefined,
'mergeIntoWithNoDuplicateKeys(): ' + 
'Tried to merge two objects with the same key: `%s`. This conflict ' + 
'may be due to a mixin; in particular, this may be caused by two ' + 
'getInitialState() or getDefaultProps() methods returning objects ' + 
'with clashing keys.',
key);

one[key] = two[key];}}


return one;}










function createMergedResultFunction(one,two){
return function mergedResult(){
var a=one.apply(this,arguments);
var b=two.apply(this,arguments);
if(a == null){
return b;}else 
if(b == null){
return a;}

var c={};
mergeIntoWithNoDuplicateKeys(c,a);
mergeIntoWithNoDuplicateKeys(c,b);
return c;};}











function createChainedFunction(one,two){
return function chainedFunction(){
one.apply(this,arguments);
two.apply(this,arguments);};}










function bindAutoBindMethod(component,method){
var boundMethod=method.bind(component);
if(__DEV__){
boundMethod.__reactBoundContext = component;
boundMethod.__reactBoundMethod = method;
boundMethod.__reactBoundArguments = null;
var componentName=component.constructor.displayName;
var _bind=boundMethod.bind;

boundMethod.bind = function(newThis){for(var _len=arguments.length,args=Array(_len > 1?_len - 1:0),_key=1;_key < _len;_key++) {args[_key - 1] = arguments[_key];}



if(newThis !== component && newThis !== null){
warning(
false,
'bind(): React component methods may only be bound to the ' + 
'component instance. See %s',
componentName);}else 

if(!args.length){
warning(
false,
'bind(): You are binding a component method to the component. ' + 
'React does this for you automatically in a high-performance ' + 
'way, so you can safely remove this call. See %s',
componentName);

return boundMethod;}

var reboundMethod=_bind.apply(boundMethod,arguments);
reboundMethod.__reactBoundContext = component;
reboundMethod.__reactBoundMethod = method;
reboundMethod.__reactBoundArguments = args;
return reboundMethod;};}



return boundMethod;}







function bindAutoBindMethods(component){
for(var autoBindKey in component.__reactAutoBindMap) {
if(component.__reactAutoBindMap.hasOwnProperty(autoBindKey)){
var method=component.__reactAutoBindMap[autoBindKey];
component[autoBindKey] = bindAutoBindMethod(
component,
ReactErrorUtils.guard(
method,
component.constructor.displayName + '.' + autoBindKey));}}}






var typeDeprecationDescriptor={
enumerable:false,
get:function(){
var displayName=this.displayName || this.name || 'Component';
warning(
false,
'%s.type is deprecated. Use %s directly to access the class.',
displayName,
displayName);

Object.defineProperty(this,'type',{
value:this});

return this;}};







var ReactClassMixin={





replaceState:function(newState,callback){
ReactUpdateQueue.enqueueReplaceState(this,newState);
if(callback){
ReactUpdateQueue.enqueueCallback(this,callback);}},









isMounted:function(){
if(__DEV__){
var owner=ReactCurrentOwner.current;
if(owner !== null){
warning(
owner._warnedAboutRefsInRender,
'%s is accessing isMounted inside its render() function. ' + 
'render() should be a pure function of props and state. It should ' + 
'never access something that requires stale data from the previous ' + 
'render, such as refs. Move this logic to componentDidMount and ' + 
'componentDidUpdate instead.',
owner.getName() || 'A component');

owner._warnedAboutRefsInRender = true;}}


var internalInstance=ReactInstanceMap.get(this);
return (
internalInstance && 
internalInstance !== ReactLifeCycle.currentlyMountingInstance);},












setProps:function(partialProps,callback){
ReactUpdateQueue.enqueueSetProps(this,partialProps);
if(callback){
ReactUpdateQueue.enqueueCallback(this,callback);}},












replaceProps:function(newProps,callback){
ReactUpdateQueue.enqueueReplaceProps(this,newProps);
if(callback){
ReactUpdateQueue.enqueueCallback(this,callback);}}};




var ReactClassComponent=function(){};
assign(
ReactClassComponent.prototype,
ReactComponent.prototype,
ReactClassMixin);







var ReactClass={








createClass:function(spec){
var Constructor=function(props,context){



if(__DEV__){
warning(
this instanceof Constructor,
'Something is calling a React component directly. Use a factory or ' + 
'JSX instead. See: http://fb.me/react-legacyfactory');}




if(this.__reactAutoBindMap){
bindAutoBindMethods(this);}


this.props = props;
this.context = context;
this.state = null;




var initialState=this.getInitialState?this.getInitialState():null;
if(__DEV__){

if(typeof initialState === 'undefined' && 
this.getInitialState._isMockFunction){


initialState = null;}}


invariant(
typeof initialState === 'object' && !Array.isArray(initialState),
'%s.getInitialState(): must return an object or null',
Constructor.displayName || 'ReactCompositeComponent');


this.state = initialState;};

Constructor.prototype = new ReactClassComponent();
Constructor.prototype.constructor = Constructor;

injectedMixins.forEach(
mixSpecIntoComponent.bind(null,Constructor));


mixSpecIntoComponent(Constructor,spec);


if(Constructor.getDefaultProps){
Constructor.defaultProps = Constructor.getDefaultProps();}


if(__DEV__){




if(Constructor.getDefaultProps){
Constructor.getDefaultProps.isReactClassApproved = {};}

if(Constructor.prototype.getInitialState){
Constructor.prototype.getInitialState.isReactClassApproved = {};}}



invariant(
Constructor.prototype.render,
'createClass(...): Class specification must implement a `render` method.');


if(__DEV__){
warning(
!Constructor.prototype.componentShouldUpdate,
'%s has a method called ' + 
'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 
'The name is phrased as a question because the function is ' + 
'expected to return a value.',
spec.displayName || 'A component');}




for(var methodName in ReactClassInterface) {
if(!Constructor.prototype[methodName]){
Constructor.prototype[methodName] = null;}}




Constructor.type = Constructor;
if(__DEV__){
try{
Object.defineProperty(Constructor,'type',typeDeprecationDescriptor);}
catch(x) {}}




return Constructor;},


injection:{
injectMixin:function(mixin){
injectedMixins.push(mixin);}}};





module.exports = ReactClass;
});
__d('ReactComponent',["ReactUpdateQueue","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactUpdateQueue=require('ReactUpdateQueue');

var invariant=require('invariant');
var warning=require('warning');




function ReactComponent(props,context){
this.props = props;
this.context = context;}



























ReactComponent.prototype.setState = function(partialState,callback){
invariant(
typeof partialState === 'object' || 
typeof partialState === 'function' || 
partialState == null,
'setState(...): takes an object of state variables to update or a ' + 
'function which returns an object of state variables.');

if(__DEV__){
warning(
partialState != null,
'setState(...): You passed an undefined or null state object; ' + 
'instead, use forceUpdate().');}


ReactUpdateQueue.enqueueSetState(this,partialState);
if(callback){
ReactUpdateQueue.enqueueCallback(this,callback);}};

















ReactComponent.prototype.forceUpdate = function(callback){
ReactUpdateQueue.enqueueForceUpdate(this);
if(callback){
ReactUpdateQueue.enqueueCallback(this,callback);}};








if(__DEV__){
var deprecatedAPIs={
getDOMNode:'getDOMNode',
isMounted:'isMounted',
replaceProps:'replaceProps',
replaceState:'replaceState',
setProps:'setProps'};

var defineDeprecationWarning=function(methodName,displayName){
try{
Object.defineProperty(ReactComponent.prototype,methodName,{
get:function(){
warning(
false,
'%s(...) is deprecated in plain JavaScript React classes.',
displayName);

return undefined;}});}


catch(x) {}};



for(var fnName in deprecatedAPIs) {
if(deprecatedAPIs.hasOwnProperty(fnName)){
defineDeprecationWarning(fnName,deprecatedAPIs[fnName]);}}}




module.exports = ReactComponent;
});
__d('ReactUpdateQueue',["ReactLifeCycle","ReactCurrentOwner","ReactElement","ReactInstanceMap","ReactUpdates","Object.assign","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactLifeCycle=require('ReactLifeCycle');
var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactElement=require('ReactElement');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactUpdates=require('ReactUpdates');

var assign=require('Object.assign');
var invariant=require('invariant');
var warning=require('warning');

function enqueueUpdate(internalInstance){
if(internalInstance !== ReactLifeCycle.currentlyMountingInstance){




ReactUpdates.enqueueUpdate(internalInstance);}}



function getInternalInstanceReadyForUpdate(publicInstance,callerName){
invariant(
ReactCurrentOwner.current == null,
'%s(...): Cannot update during an existing state transition ' + 
'(such as within `render`). Render methods should be a pure function ' + 
'of props and state.',
callerName);


var internalInstance=ReactInstanceMap.get(publicInstance);
if(!internalInstance){
if(__DEV__){



warning(
!callerName,
'%s(...): Can only update a mounted or mounting component. ' + 
'This usually means you called %s() on an unmounted ' + 
'component. This is a no-op.',
callerName,
callerName);}


return null;}


if(internalInstance === ReactLifeCycle.currentlyUnmountingInstance){
return null;}


return internalInstance;}






var ReactUpdateQueue={









enqueueCallback:function(publicInstance,callback){
invariant(
typeof callback === 'function',
'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + 
'`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 
'isn\'t callable.');

var internalInstance=getInternalInstanceReadyForUpdate(publicInstance);






if(!internalInstance || 
internalInstance === ReactLifeCycle.currentlyMountingInstance){
return null;}


if(internalInstance._pendingCallbacks){
internalInstance._pendingCallbacks.push(callback);}else 
{
internalInstance._pendingCallbacks = [callback];}





enqueueUpdate(internalInstance);},


enqueueCallbackInternal:function(internalInstance,callback){
invariant(
typeof callback === 'function',
'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + 
'`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 
'isn\'t callable.');

if(internalInstance._pendingCallbacks){
internalInstance._pendingCallbacks.push(callback);}else 
{
internalInstance._pendingCallbacks = [callback];}

enqueueUpdate(internalInstance);},















enqueueForceUpdate:function(publicInstance){
var internalInstance=getInternalInstanceReadyForUpdate(
publicInstance,
'forceUpdate');


if(!internalInstance){
return;}


internalInstance._pendingForceUpdate = true;

enqueueUpdate(internalInstance);},













enqueueReplaceState:function(publicInstance,completeState){
var internalInstance=getInternalInstanceReadyForUpdate(
publicInstance,
'replaceState');


if(!internalInstance){
return;}


internalInstance._pendingStateQueue = [completeState];
internalInstance._pendingReplaceState = true;

enqueueUpdate(internalInstance);},












enqueueSetState:function(publicInstance,partialState){
var internalInstance=getInternalInstanceReadyForUpdate(
publicInstance,
'setState');


if(!internalInstance){
return;}


var queue=
internalInstance._pendingStateQueue || (
internalInstance._pendingStateQueue = []);
queue.push(partialState);

enqueueUpdate(internalInstance);},









enqueueSetProps:function(publicInstance,partialProps){
var internalInstance=getInternalInstanceReadyForUpdate(
publicInstance,
'setProps');


if(!internalInstance){
return;}


invariant(
internalInstance._isTopLevel,
'setProps(...): You called `setProps` on a ' + 
'component with a parent. This is an anti-pattern since props will ' + 
'get reactively updated when rendered. Instead, change the owner\'s ' + 
'`render` method to pass the correct value as props to the component ' + 
'where it is created.');




var element=internalInstance._pendingElement || 
internalInstance._currentElement;
var props=assign({},element.props,partialProps);
internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(
element,
props);


enqueueUpdate(internalInstance);},









enqueueReplaceProps:function(publicInstance,props){
var internalInstance=getInternalInstanceReadyForUpdate(
publicInstance,
'replaceProps');


if(!internalInstance){
return;}


invariant(
internalInstance._isTopLevel,
'replaceProps(...): You called `replaceProps` on a ' + 
'component with a parent. This is an anti-pattern since props will ' + 
'get reactively updated when rendered. Instead, change the owner\'s ' + 
'`render` method to pass the correct value as props to the component ' + 
'where it is created.');




var element=internalInstance._pendingElement || 
internalInstance._currentElement;
internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(
element,
props);


enqueueUpdate(internalInstance);},


enqueueElementInternal:function(internalInstance,newElement){
internalInstance._pendingElement = newElement;
enqueueUpdate(internalInstance);}};




module.exports = ReactUpdateQueue;
});
__d('ReactLifeCycle',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




























var ReactLifeCycle={
currentlyMountingInstance:null,
currentlyUnmountingInstance:null};


module.exports = ReactLifeCycle;
});
__d('ReactInstanceMap',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




















var ReactInstanceMap={






remove:function(key){
key._reactInternalInstance = undefined;},


get:function(key){
return key._reactInternalInstance;},


has:function(key){
return key._reactInternalInstance !== undefined;},


set:function(key,value){
key._reactInternalInstance = value;}};




module.exports = ReactInstanceMap;
});
__d('ReactUpdates',["CallbackQueue","PooledClass","ReactCurrentOwner","ReactPerf","ReactReconciler","Transaction","Object.assign","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var CallbackQueue=require('CallbackQueue');
var PooledClass=require('PooledClass');
var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactPerf=require('ReactPerf');
var ReactReconciler=require('ReactReconciler');
var Transaction=require('Transaction');

var assign=require('Object.assign');
var invariant=require('invariant');
var warning=require('warning');

var dirtyComponents=[];
var asapCallbackQueue=CallbackQueue.getPooled();
var asapEnqueued=false;

var batchingStrategy=null;

function ensureInjected(){
invariant(
ReactUpdates.ReactReconcileTransaction && batchingStrategy,
'ReactUpdates: must inject a reconcile transaction class and batching ' + 
'strategy');}



var NESTED_UPDATES={
initialize:function(){
this.dirtyComponentsLength = dirtyComponents.length;},

close:function(){
if(this.dirtyComponentsLength !== dirtyComponents.length){





dirtyComponents.splice(0,this.dirtyComponentsLength);
flushBatchedUpdates();}else 
{
dirtyComponents.length = 0;}}};




var UPDATE_QUEUEING={
initialize:function(){
this.callbackQueue.reset();},

close:function(){
this.callbackQueue.notifyAll();}};



var TRANSACTION_WRAPPERS=[NESTED_UPDATES,UPDATE_QUEUEING];

function ReactUpdatesFlushTransaction(){
this.reinitializeTransaction();
this.dirtyComponentsLength = null;
this.callbackQueue = CallbackQueue.getPooled();
this.reconcileTransaction = 
ReactUpdates.ReactReconcileTransaction.getPooled();}


assign(
ReactUpdatesFlushTransaction.prototype,
Transaction.Mixin,{
getTransactionWrappers:function(){
return TRANSACTION_WRAPPERS;},


destructor:function(){
this.dirtyComponentsLength = null;
CallbackQueue.release(this.callbackQueue);
this.callbackQueue = null;
ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);
this.reconcileTransaction = null;},


perform:function(method,scope,a){


return Transaction.Mixin.perform.call(
this,
this.reconcileTransaction.perform,
this.reconcileTransaction,
method,
scope,
a);}});




PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);

function batchedUpdates(callback,a,b,c,d){
ensureInjected();
batchingStrategy.batchedUpdates(callback,a,b,c,d);}









function mountOrderComparator(c1,c2){
return c1._mountOrder - c2._mountOrder;}


function runBatchedUpdates(transaction){
var len=transaction.dirtyComponentsLength;
invariant(
len === dirtyComponents.length,
'Expected flush transaction\'s stored dirty-components length (%s) to ' + 
'match dirty-components array length (%s).',
len,
dirtyComponents.length);





dirtyComponents.sort(mountOrderComparator);

for(var i=0;i < len;i++) {



var component=dirtyComponents[i];




var callbacks=component._pendingCallbacks;
component._pendingCallbacks = null;

ReactReconciler.performUpdateIfNecessary(
component,
transaction.reconcileTransaction);


if(callbacks){
for(var j=0;j < callbacks.length;j++) {
transaction.callbackQueue.enqueue(
callbacks[j],
component.getPublicInstance());}}}}






var flushBatchedUpdates=function(){




while(dirtyComponents.length || asapEnqueued) {
if(dirtyComponents.length){
var transaction=ReactUpdatesFlushTransaction.getPooled();
transaction.perform(runBatchedUpdates,null,transaction);
ReactUpdatesFlushTransaction.release(transaction);}


if(asapEnqueued){
asapEnqueued = false;
var queue=asapCallbackQueue;
asapCallbackQueue = CallbackQueue.getPooled();
queue.notifyAll();
CallbackQueue.release(queue);}}};



flushBatchedUpdates = ReactPerf.measure(
'ReactUpdates',
'flushBatchedUpdates',
flushBatchedUpdates);






function enqueueUpdate(component){
ensureInjected();






warning(
ReactCurrentOwner.current == null,
'enqueueUpdate(): Render methods should be a pure function of props ' + 
'and state; triggering nested component updates from render is not ' + 
'allowed. If necessary, trigger nested updates in ' + 
'componentDidUpdate.');


if(!batchingStrategy.isBatchingUpdates){
batchingStrategy.batchedUpdates(enqueueUpdate,component);
return;}


dirtyComponents.push(component);}






function asap(callback,context){
invariant(
batchingStrategy.isBatchingUpdates,
'ReactUpdates.asap: Can\'t enqueue an asap callback in a context where' + 
'updates are not being batched.');

asapCallbackQueue.enqueue(callback,context);
asapEnqueued = true;}


var ReactUpdatesInjection={
injectReconcileTransaction:function(ReconcileTransaction){
invariant(
ReconcileTransaction,
'ReactUpdates: must provide a reconcile transaction class');

ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;},


injectBatchingStrategy:function(_batchingStrategy){
invariant(
_batchingStrategy,
'ReactUpdates: must provide a batching strategy');

invariant(
typeof _batchingStrategy.batchedUpdates === 'function',
'ReactUpdates: must provide a batchedUpdates() function');

invariant(
typeof _batchingStrategy.isBatchingUpdates === 'boolean',
'ReactUpdates: must provide an isBatchingUpdates boolean attribute');

batchingStrategy = _batchingStrategy;}};



var ReactUpdates={






ReactReconcileTransaction:null,

batchedUpdates:batchedUpdates,
enqueueUpdate:enqueueUpdate,
flushBatchedUpdates:flushBatchedUpdates,
injection:ReactUpdatesInjection,
asap:asap};


module.exports = ReactUpdates;
});
__d('CallbackQueue',["PooledClass","Object.assign","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var PooledClass=require('PooledClass');

var assign=require('Object.assign');
var invariant=require('invariant');












function CallbackQueue(){
this._callbacks = null;
this._contexts = null;}


assign(CallbackQueue.prototype,{








enqueue:function(callback,context){
this._callbacks = this._callbacks || [];
this._contexts = this._contexts || [];
this._callbacks.push(callback);
this._contexts.push(context);},








notifyAll:function(){
var callbacks=this._callbacks;
var contexts=this._contexts;
if(callbacks){
invariant(
callbacks.length === contexts.length,
'Mismatched list of contexts in callback queue');

this._callbacks = null;
this._contexts = null;
for(var i=0,l=callbacks.length;i < l;i++) {
callbacks[i].call(contexts[i]);}

callbacks.length = 0;
contexts.length = 0;}},








reset:function(){
this._callbacks = null;
this._contexts = null;},





destructor:function(){
this.reset();}});




PooledClass.addPoolingTo(CallbackQueue);

module.exports = CallbackQueue;
});
__d('ReactPerf',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

















var ReactPerf={




enableMeasure:false,





storedMeasure:_noMeasure,






measureMethods:function(object,objectName,methodNames){
if(__DEV__){
for(var key in methodNames) {
if(!methodNames.hasOwnProperty(key)){
continue;}

object[key] = ReactPerf.measure(
objectName,
methodNames[key],
object[key]);}}},













measure:function(objName,fnName,func){
if(__DEV__){
var measuredFunc=null;
var wrapper=function(){
if(ReactPerf.enableMeasure){
if(!measuredFunc){
measuredFunc = ReactPerf.storedMeasure(objName,fnName,func);}

return measuredFunc.apply(this,arguments);}

return func.apply(this,arguments);};

wrapper.displayName = objName + '_' + fnName;
return wrapper;}

return func;},


injection:{



injectMeasure:function(measure){
ReactPerf.storedMeasure = measure;}}};












function _noMeasure(objName,fnName,func){
return func;}


module.exports = ReactPerf;
});
__d('ReactReconciler',["ReactRef","ReactElementValidator"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactRef=require('ReactRef');
var ReactElementValidator=require('ReactElementValidator');





function attachRefs(){
ReactRef.attachRefs(this,this._currentElement);}


var ReactReconciler={











mountComponent:function(internalInstance,rootID,transaction,context){
var markup=internalInstance.mountComponent(rootID,transaction,context);
if(__DEV__){
ReactElementValidator.checkAndWarnForMutatedProps(
internalInstance._currentElement);}


transaction.getReactMountReady().enqueue(attachRefs,internalInstance);
return markup;},








unmountComponent:function(internalInstance){
ReactRef.detachRefs(internalInstance,internalInstance._currentElement);
internalInstance.unmountComponent();},











receiveComponent:function(
internalInstance,nextElement,transaction,context)
{
var prevElement=internalInstance._currentElement;

if(nextElement === prevElement && nextElement._owner != null){







return;}


if(__DEV__){
ReactElementValidator.checkAndWarnForMutatedProps(nextElement);}


var refsChanged=ReactRef.shouldUpdateRefs(
prevElement,
nextElement);


if(refsChanged){
ReactRef.detachRefs(internalInstance,prevElement);}


internalInstance.receiveComponent(nextElement,transaction,context);

if(refsChanged){
transaction.getReactMountReady().enqueue(attachRefs,internalInstance);}},










performUpdateIfNecessary:function(
internalInstance,
transaction)
{
internalInstance.performUpdateIfNecessary(transaction);}};




module.exports = ReactReconciler;
});
__d('ReactRef',["ReactOwner"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactOwner=require('ReactOwner');

var ReactRef={};

function attachRef(ref,component,owner){
if(typeof ref === 'function'){
ref(component.getPublicInstance());}else 
{

ReactOwner.addComponentAsRefTo(component,ref,owner);}}



function detachRef(ref,component,owner){
if(typeof ref === 'function'){
ref(null);}else 
{

ReactOwner.removeComponentAsRefFrom(component,ref,owner);}}



ReactRef.attachRefs = function(instance,element){
var ref=element.ref;
if(ref != null){
attachRef(ref,instance,element._owner);}};



ReactRef.shouldUpdateRefs = function(prevElement,nextElement){












return (
nextElement._owner !== prevElement._owner || 
nextElement.ref !== prevElement.ref);};



ReactRef.detachRefs = function(instance,element){
var ref=element.ref;
if(ref != null){
detachRef(ref,instance,element._owner);}};



module.exports = ReactRef;
});
__d('ReactOwner',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');































var ReactOwner={






isValidOwner:function(object){
return !!(
object && 
typeof object.attachRef === 'function' && 
typeof object.detachRef === 'function');},












addComponentAsRefTo:function(component,ref,owner){
invariant(
ReactOwner.isValidOwner(owner),
'addComponentAsRefTo(...): Only a ReactOwner can have refs. This ' + 
'usually means that you\'re trying to add a ref to a component that ' + 
'doesn\'t have an owner (that is, was not created inside of another ' + 
'component\'s `render` method). Try rendering this component inside of ' + 
'a new top-level component which will hold the ref.');

owner.attachRef(ref,component);},











removeComponentAsRefFrom:function(component,ref,owner){
invariant(
ReactOwner.isValidOwner(owner),
'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. This ' + 
'usually means that you\'re trying to remove a ref to a component that ' + 
'doesn\'t have an owner (that is, was not created inside of another ' + 
'component\'s `render` method). Try rendering this component inside of ' + 
'a new top-level component which will hold the ref.');



if(owner.getPublicInstance().refs[ref] === component.getPublicInstance()){
owner.detachRef(ref);}}};





module.exports = ReactOwner;
});
__d('ReactElementValidator',["ReactElement","ReactFragment","ReactPropTypeLocations","ReactPropTypeLocationNames","ReactCurrentOwner","ReactNativeComponent","getIteratorFn","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



















var ReactElement=require('ReactElement');
var ReactFragment=require('ReactFragment');
var ReactPropTypeLocations=require('ReactPropTypeLocations');
var ReactPropTypeLocationNames=require('ReactPropTypeLocationNames');
var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactNativeComponent=require('ReactNativeComponent');

var getIteratorFn=require('getIteratorFn');
var invariant=require('invariant');
var warning=require('warning');

function getDeclarationErrorAddendum(){
if(ReactCurrentOwner.current){
var name=ReactCurrentOwner.current.getName();
if(name){
return ' Check the render method of `' + name + '`.';}}


return '';}







var ownerHasKeyUseWarning={};

var loggedTypeFailures={};

var NUMERIC_PROPERTY_REGEX=/^\d+$/;







function getName(instance){
var publicInstance=instance && instance.getPublicInstance();
if(!publicInstance){
return undefined;}

var constructor=publicInstance.constructor;
if(!constructor){
return undefined;}

return constructor.displayName || constructor.name || undefined;}








function getCurrentOwnerDisplayName(){
var current=ReactCurrentOwner.current;
return (
current && getName(current) || undefined);}













function validateExplicitKey(element,parentType){
if(element._store.validated || element.key != null){
return;}

element._store.validated = true;

warnAndMonitorForKeyUse(
'Each child in an array or iterator should have a unique "key" prop.',
element,
parentType);}












function validatePropertyKey(name,element,parentType){
if(!NUMERIC_PROPERTY_REGEX.test(name)){
return;}

warnAndMonitorForKeyUse(
'Child objects should have non-numeric keys so ordering is preserved.',
element,
parentType);}











function warnAndMonitorForKeyUse(message,element,parentType){
var ownerName=getCurrentOwnerDisplayName();
var parentName=typeof parentType === 'string'?
parentType:parentType.displayName || parentType.name;

var useName=ownerName || parentName;
var memoizer=ownerHasKeyUseWarning[message] || (
ownerHasKeyUseWarning[message] = {});

if(memoizer.hasOwnProperty(useName)){
return;}

memoizer[useName] = true;

var parentOrOwnerAddendum=
ownerName?' Check the render method of ' + ownerName + '.':
parentName?' Check the React.render call using <' + parentName + '>.':
'';




var childOwnerAddendum='';
if(element && 
element._owner && 
element._owner !== ReactCurrentOwner.current){

var childOwnerName=getName(element._owner);

childOwnerAddendum = ' It was passed a child from ' + childOwnerName + '.';}


warning(
false,
message + '%s%s See http://fb.me/react-warning-keys for more information.',
parentOrOwnerAddendum,
childOwnerAddendum);}












function validateChildKeys(node,parentType){
if(Array.isArray(node)){
for(var i=0;i < node.length;i++) {
var child=node[i];
if(ReactElement.isValidElement(child)){
validateExplicitKey(child,parentType);}}}else 


if(ReactElement.isValidElement(node)){

node._store.validated = true;}else 
if(node){
var iteratorFn=getIteratorFn(node);

if(iteratorFn){
if(iteratorFn !== node.entries){
var iterator=iteratorFn.call(node);
var step;
while(!(step = iterator.next()).done) {
if(ReactElement.isValidElement(step.value)){
validateExplicitKey(step.value,parentType);}}}}else 



if(typeof node === 'object'){
var fragment=ReactFragment.extractIfFragment(node);
for(var key in fragment) {
if(fragment.hasOwnProperty(key)){
validatePropertyKey(key,fragment[key],parentType);}}}}}















function checkPropTypes(componentName,propTypes,props,location){
for(var propName in propTypes) {
if(propTypes.hasOwnProperty(propName)){
var error;



try{


invariant(
typeof propTypes[propName] === 'function',
'%s: %s type `%s` is invalid; it must be a function, usually from ' + 
'React.PropTypes.',
componentName || 'React class',
ReactPropTypeLocationNames[location],
propName);

error = propTypes[propName](props,propName,componentName,location);}
catch(ex) {
error = ex;}

if(error instanceof Error && !(error.message in loggedTypeFailures)){


loggedTypeFailures[error.message] = true;

var addendum=getDeclarationErrorAddendum(this);
warning(false,'Failed propType: %s%s',error.message,addendum);}}}}





var warnedPropsMutations={};







function warnForPropsMutation(propName,element){
var type=element.type;
var elementName=typeof type === 'string'?type:type.displayName;
var ownerName=element._owner?
element._owner.getPublicInstance().constructor.displayName:null;

var warningKey=propName + '|' + elementName + '|' + ownerName;
if(warnedPropsMutations.hasOwnProperty(warningKey)){
return;}

warnedPropsMutations[warningKey] = true;

var elementInfo='';
if(elementName){
elementInfo = ' <' + elementName + ' />';}

var ownerInfo='';
if(ownerName){
ownerInfo = ' The element was created by ' + ownerName + '.';}


warning(
false,
'Don\'t set .props.%s of the React component%s. Instead, specify the ' + 
'correct value when initially creating the element or use ' + 
'React.cloneElement to make a new element with updated props.%s',
propName,
elementInfo,
ownerInfo);}




function is(a,b){
if(a !== a){

return b !== b;}

if(a === 0 && b === 0){

return 1 / a === 1 / b;}

return a === b;}










function checkAndWarnForMutatedProps(element){
if(!element._store){


return;}


var originalProps=element._store.originalProps;
var props=element.props;

for(var propName in props) {
if(props.hasOwnProperty(propName)){
if(!originalProps.hasOwnProperty(propName) || 
!is(originalProps[propName],props[propName])){
warnForPropsMutation(propName,element);


originalProps[propName] = props[propName];}}}}











function validatePropTypes(element){
if(element.type == null){

return;}





var componentClass=ReactNativeComponent.getComponentClassForElement(
element);

var name=componentClass.displayName || componentClass.name;
if(componentClass.propTypes){
checkPropTypes(
name,
componentClass.propTypes,
element.props,
ReactPropTypeLocations.prop);}


if(typeof componentClass.getDefaultProps === 'function'){
warning(
componentClass.getDefaultProps.isReactClassApproved,
'getDefaultProps is only used on classic React.createClass ' + 
'definitions. Use a static property named `defaultProps` instead.');}}




var ReactElementValidator={

checkAndWarnForMutatedProps:checkAndWarnForMutatedProps,

createElement:function(type,props,children){


warning(
type != null,
'React.createElement: type should not be null or undefined. It should ' + 
'be a string (for DOM elements) or a ReactClass (for composite ' + 
'components).');


var element=ReactElement.createElement.apply(this,arguments);



if(element == null){
return element;}


for(var i=2;i < arguments.length;i++) {
validateChildKeys(arguments[i],type);}


validatePropTypes(element);

return element;},


createFactory:function(type){
var validatedFactory=ReactElementValidator.createElement.bind(
null,
type);


validatedFactory.type = type;

if(__DEV__){
try{
Object.defineProperty(
validatedFactory,
'type',
{
enumerable:false,
get:function(){
warning(
false,
'Factory.type is deprecated. Access the class directly ' + 
'before passing it to createFactory.');

Object.defineProperty(this,'type',{
value:type});

return type;}});}



catch(x) {}}





return validatedFactory;},


cloneElement:function(element,props,children){
var newElement=ReactElement.cloneElement.apply(this,arguments);
for(var i=2;i < arguments.length;i++) {
validateChildKeys(arguments[i],newElement.type);}

validatePropTypes(newElement);
return newElement;}};




module.exports = ReactElementValidator;
});
__d('ReactPropTypeLocations',["keyMirror"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var keyMirror=require('keyMirror');

var ReactPropTypeLocations=keyMirror({
prop:null,
context:null,
childContext:null});


module.exports = ReactPropTypeLocations;
});
__d('keyMirror',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var invariant=require('invariant');



















var keyMirror=function(obj){
var ret={};
var key;
invariant(
obj instanceof Object && !Array.isArray(obj),
'keyMirror(...): Argument must be an object.');

for(key in obj) {
if(!obj.hasOwnProperty(key)){
continue;}

ret[key] = key;}

return ret;};


module.exports = keyMirror;
});
__d('ReactPropTypeLocationNames',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactPropTypeLocationNames={};

if(__DEV__){
ReactPropTypeLocationNames = {
prop:'prop',
context:'context',
childContext:'child context'};}



module.exports = ReactPropTypeLocationNames;
});
__d('ReactNativeComponent',["Object.assign","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var assign=require('Object.assign');
var invariant=require('invariant');

var autoGenerateWrapperClass=null;
var genericComponentClass=null;

var tagToComponentClass={};
var textComponentClass=null;

var ReactNativeComponentInjection={


injectGenericComponentClass:function(componentClass){
genericComponentClass = componentClass;},



injectTextComponentClass:function(componentClass){
textComponentClass = componentClass;},



injectComponentClasses:function(componentClasses){
assign(tagToComponentClass,componentClasses);},



injectAutoWrapper:function(wrapperFactory){
autoGenerateWrapperClass = wrapperFactory;}};









function getComponentClassForElement(element){
if(typeof element.type === 'function'){
return element.type;}

var tag=element.type;
var componentClass=tagToComponentClass[tag];
if(componentClass == null){
tagToComponentClass[tag] = componentClass = autoGenerateWrapperClass(tag);}

return componentClass;}








function createInternalComponent(element){
invariant(
genericComponentClass,
'There is no registered component for the tag %s',
element.type);

return new genericComponentClass(element.type,element.props);}






function createInstanceForText(text){
return new textComponentClass(text);}






function isTextComponent(component){
return component instanceof textComponentClass;}


var ReactNativeComponent={
getComponentClassForElement:getComponentClassForElement,
createInternalComponent:createInternalComponent,
createInstanceForText:createInstanceForText,
isTextComponent:isTextComponent,
injection:ReactNativeComponentInjection};


module.exports = ReactNativeComponent;
});
__d('Transaction',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');






























































var Mixin={







reinitializeTransaction:function(){
this.transactionWrappers = this.getTransactionWrappers();
if(!this.wrapperInitData){
this.wrapperInitData = [];}else 
{
this.wrapperInitData.length = 0;}

this._isInTransaction = false;},


_isInTransaction:false,





getTransactionWrappers:null,

isInTransaction:function(){
return !!this._isInTransaction;},













perform:function(method,scope,a,b,c,d,e,f){
invariant(
!this.isInTransaction(),
'Transaction.perform(...): Cannot initialize a transaction when there ' + 
'is already an outstanding transaction.');

var errorThrown;
var ret;
try{
this._isInTransaction = true;




errorThrown = true;
this.initializeAll(0);
ret = method.call(scope,a,b,c,d,e,f);
errorThrown = false;}finally 
{
try{
if(errorThrown){


try{
this.closeAll(0);}
catch(err) {}}else 

{


this.closeAll(0);}}finally 

{
this._isInTransaction = false;}}


return ret;},


initializeAll:function(startIndex){
var transactionWrappers=this.transactionWrappers;
for(var i=startIndex;i < transactionWrappers.length;i++) {
var wrapper=transactionWrappers[i];
try{




this.wrapperInitData[i] = Transaction.OBSERVED_ERROR;
this.wrapperInitData[i] = wrapper.initialize?
wrapper.initialize.call(this):
null;}finally 
{
if(this.wrapperInitData[i] === Transaction.OBSERVED_ERROR){



try{
this.initializeAll(i + 1);}
catch(err) {}}}}},












closeAll:function(startIndex){
invariant(
this.isInTransaction(),
'Transaction.closeAll(): Cannot close transaction when none are open.');

var transactionWrappers=this.transactionWrappers;
for(var i=startIndex;i < transactionWrappers.length;i++) {
var wrapper=transactionWrappers[i];
var initData=this.wrapperInitData[i];
var errorThrown;
try{




errorThrown = true;
if(initData !== Transaction.OBSERVED_ERROR && wrapper.close){
wrapper.close.call(this,initData);}

errorThrown = false;}finally 
{
if(errorThrown){



try{
this.closeAll(i + 1);}
catch(e) {}}}}




this.wrapperInitData.length = 0;}};



var Transaction={

Mixin:Mixin,




OBSERVED_ERROR:{}};



module.exports = Transaction;
});
__d('ReactErrorUtils',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";













var ReactErrorUtils={









guard:function(func,name){
return func;}};



module.exports = ReactErrorUtils;
});
__d('keyOf',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var 




















keyOf=function(oneKeyObj){
var key;
for(key in oneKeyObj) {
if(!oneKeyObj.hasOwnProperty(key)){
continue;}

return key;}

return null;};



module.exports = keyOf;
});
__d('ReactNativeDefaultInjection',["InitializeJavaScriptAppEngine","EventPluginHub","EventPluginUtils","IOSDefaultEventPluginOrder","IOSNativeBridgeEventPlugin","NodeHandle","ReactComponentEnvironment","ReactDefaultBatchingStrategy","ReactEmptyComponent","ReactInstanceHandles","ReactNativeComponentEnvironment","ReactNativeGlobalInteractionHandler","ReactNativeGlobalResponderHandler","ReactNativeMount","ReactNativeTextComponent","ReactNativeComponent","ReactUpdates","ResponderEventPlugin","UniversalWorkerNodeHandle","createReactNativeComponentClass","invariant","RCTEventEmitter","RCTLog","JSTimersExecution"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';















require('InitializeJavaScriptAppEngine');
var EventPluginHub=require('EventPluginHub');
var EventPluginUtils=require('EventPluginUtils');
var IOSDefaultEventPluginOrder=require('IOSDefaultEventPluginOrder');
var IOSNativeBridgeEventPlugin=require('IOSNativeBridgeEventPlugin');
var NodeHandle=require('NodeHandle');
var ReactComponentEnvironment=require('ReactComponentEnvironment');
var ReactDefaultBatchingStrategy=require('ReactDefaultBatchingStrategy');
var ReactEmptyComponent=require('ReactEmptyComponent');
var ReactInstanceHandles=require('ReactInstanceHandles');
var ReactNativeComponentEnvironment=require('ReactNativeComponentEnvironment');
var ReactNativeGlobalInteractionHandler=require('ReactNativeGlobalInteractionHandler');
var ReactNativeGlobalResponderHandler=require('ReactNativeGlobalResponderHandler');
var ReactNativeMount=require('ReactNativeMount');
var ReactNativeTextComponent=require('ReactNativeTextComponent');
var ReactNativeComponent=require('ReactNativeComponent');
var ReactUpdates=require('ReactUpdates');
var ResponderEventPlugin=require('ResponderEventPlugin');
var UniversalWorkerNodeHandle=require('UniversalWorkerNodeHandle');

var createReactNativeComponentClass=require('createReactNativeComponentClass');
var invariant=require('invariant');


require('RCTEventEmitter');
require('RCTLog');
require('JSTimersExecution');

function inject(){



EventPluginHub.injection.injectEventPluginOrder(IOSDefaultEventPluginOrder);
EventPluginHub.injection.injectInstanceHandle(ReactInstanceHandles);

ResponderEventPlugin.injection.injectGlobalResponderHandler(
ReactNativeGlobalResponderHandler);


ResponderEventPlugin.injection.injectGlobalInteractionHandler(
ReactNativeGlobalInteractionHandler);






EventPluginHub.injection.injectEventPluginsByName({
'ResponderEventPlugin':ResponderEventPlugin,
'IOSNativeBridgeEventPlugin':IOSNativeBridgeEventPlugin});


ReactUpdates.injection.injectReconcileTransaction(
ReactNativeComponentEnvironment.ReactReconcileTransaction);


ReactUpdates.injection.injectBatchingStrategy(
ReactDefaultBatchingStrategy);


ReactComponentEnvironment.injection.injectEnvironment(
ReactNativeComponentEnvironment);



var RCTView=createReactNativeComponentClass({
validAttributes:{},
uiViewClassName:'RCTView'});

ReactEmptyComponent.injection.injectEmptyComponent(RCTView);

EventPluginUtils.injection.injectMount(ReactNativeMount);

ReactNativeComponent.injection.injectTextComponentClass(
ReactNativeTextComponent);

ReactNativeComponent.injection.injectAutoWrapper(function(tag){

var info='';
if(typeof tag === 'string' && /^[a-z]/.test(tag)){
info += ' Each component name should start with an uppercase letter.';}

invariant(false,'Expected a component class, got %s.%s',tag,info);});


NodeHandle.injection.injectImplementation(UniversalWorkerNodeHandle);}


module.exports = {
inject:inject};
});
__d('InitializeJavaScriptAppEngine',["RCTDebugComponentOwnership","RCTDeviceEventEmitter","PerformanceLogger","ExceptionsManager","ErrorUtils","ExceptionsManager","Platform","JSTimers","NativeModules","Promise","XMLHttpRequest","FormData","fetch","Geolocation","WebSocket","BridgeProfiling"],function(global, require, requireDynamic, requireLazy, module, exports) {  require(
























'RCTDebugComponentOwnership');
require('RCTDeviceEventEmitter');
require('PerformanceLogger');

if(typeof GLOBAL === 'undefined'){
GLOBAL = this;}


if(typeof window === 'undefined'){
window = GLOBAL;}


function handleError(e,isFatal){
try{
require('ExceptionsManager').handleException(e,isFatal);}
catch(ee) {
console.log('Failed to print error: ',ee.message);}}



function setUpRedBoxErrorHandler(){
var ErrorUtils=require('ErrorUtils');
ErrorUtils.setGlobalHandler(handleError);}


function setUpRedBoxConsoleErrorHandler(){

var ExceptionsManager=require('ExceptionsManager');
var Platform=require('Platform');

if(__DEV__ && Platform.OS === 'ios'){
ExceptionsManager.installConsoleErrorReporter();}}










function setUpTimers(){
var JSTimers=require('JSTimers');
GLOBAL.setTimeout = JSTimers.setTimeout;
GLOBAL.setInterval = JSTimers.setInterval;
GLOBAL.setImmediate = JSTimers.setImmediate;
GLOBAL.clearTimeout = JSTimers.clearTimeout;
GLOBAL.clearInterval = JSTimers.clearInterval;
GLOBAL.clearImmediate = JSTimers.clearImmediate;
GLOBAL.cancelAnimationFrame = JSTimers.clearInterval;
GLOBAL.requestAnimationFrame = function(cb){

return JSTimers.requestAnimationFrame(cb);};}



function setUpAlert(){
var RCTAlertManager=require('NativeModules').AlertManager;
if(!GLOBAL.alert){
GLOBAL.alert = function(text){
var alertOpts={
title:'Alert',
message:'' + text,
buttons:[{'cancel':'OK'}]};

RCTAlertManager.alertWithArgs(alertOpts,null);};}}




function setUpPromise(){


GLOBAL.Promise = require('Promise');}


function setUpXHR(){


GLOBAL.XMLHttpRequest = require('XMLHttpRequest');
GLOBAL.FormData = require('FormData');

var fetchPolyfill=require('fetch');
GLOBAL.fetch = fetchPolyfill.fetch;
GLOBAL.Headers = fetchPolyfill.Headers;
GLOBAL.Request = fetchPolyfill.Request;
GLOBAL.Response = fetchPolyfill.Response;}


function setUpGeolocation(){
GLOBAL.navigator = GLOBAL.navigator || {};
GLOBAL.navigator.geolocation = require('Geolocation');}


function setUpWebSockets(){
GLOBAL.WebSocket = require('WebSocket');}


function setupProfile(){
console.profile = console.profile || GLOBAL.consoleProfile || function(){};
console.profileEnd = console.profileEnd || GLOBAL.consoleProfileEnd || function(){};
require('BridgeProfiling').swizzleReactPerf();}


setUpRedBoxErrorHandler();
setUpTimers();
setUpAlert();
setUpPromise();
setUpXHR();
setUpRedBoxConsoleErrorHandler();
setUpGeolocation();
setUpWebSockets();
setupProfile();
});
__d('RCTDebugComponentOwnership',["NativeModules","InspectorUtils","ReactNativeTagHandles"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';
















var DebugComponentOwnershipModule=require('NativeModules').DebugComponentOwnershipModule;
var InspectorUtils=require('InspectorUtils');
var ReactNativeTagHandles=require('ReactNativeTagHandles');

function componentToString(component){
return component.getName?component.getName():'Unknown';}


function getRootTagForTag(tag){
var rootNodeID=ReactNativeTagHandles.tagToRootNodeID[tag];
if(!rootNodeID){
return null;}

var rootID=ReactNativeTagHandles.getNativeTopRootIDFromNodeID(rootNodeID);
if(!rootID){
return null;}

return ReactNativeTagHandles.rootNodeIDToTag[rootID];}


module.exports = {








getOwnerHierarchy:function(requestID,tag){
var rootTag=getRootTagForTag(tag);
var instance=InspectorUtils.findInstanceByNativeTag(rootTag,tag);
var ownerHierarchy=instance?
InspectorUtils.getOwnerHierarchy(instance).map(componentToString):
null;
DebugComponentOwnershipModule.receiveOwnershipHierarchy(requestID,tag,ownerHierarchy);}};
});
__d('NativeModules',["BatchedBridge","nativeModulePrefixNormalizer"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeModules=require('BatchedBridge').RemoteModules;

var nativeModulePrefixNormalizer=require('nativeModulePrefixNormalizer');

nativeModulePrefixNormalizer(NativeModules);

module.exports = NativeModules;
});
__d('BatchedBridge',["MessageQueue"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';











var MessageQueue=require('MessageQueue');

var BatchedBridge=new MessageQueue(
__fbBatchedBridgeConfig.remoteModuleConfig,
__fbBatchedBridgeConfig.localModulesConfig);


module.exports = BatchedBridge;
});
__d('MessageQueue',["BridgeProfiling","ErrorUtils","JSTimersExecution","ReactUpdates","invariant","keyMirror","stringifySafe"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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 _objectWithoutProperties(obj,keys){var target={};for(var i in obj) {if(keys.indexOf(i) >= 0)continue;if(!Object.prototype.hasOwnProperty.call(obj,i))continue;target[i] = obj[i];}return target;}function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}














var BridgeProfiling=require('BridgeProfiling');
var ErrorUtils=require('ErrorUtils');
var JSTimersExecution=require('JSTimersExecution');
var ReactUpdates=require('ReactUpdates');

var invariant=require('invariant');
var keyMirror=require('keyMirror');
var stringifySafe=require('stringifySafe');

var MODULE_IDS=0;
var METHOD_IDS=1;
var PARAMS=2;

var MethodTypes=keyMirror({
local:null,
remote:null,
remoteAsync:null});


var guard=function(fn){
try{
fn();}
catch(error) {
ErrorUtils.reportFatalError(error);}};var 



MessageQueue=(function(){

function MessageQueue(remoteModules,localModules,customRequire){var _this=this;_classCallCheck(this,MessageQueue);
this.RemoteModules = {};

this._require = customRequire || require;
this._queue = [[],[],[]];
this._moduleTable = {};
this._methodTable = {};
this._callbacks = [];
this._callbackID = 0;

[
'processBatch',
'invokeCallbackAndReturnFlushedQueue',
'callFunctionReturnFlushedQueue',
'flushedQueue'].
forEach(function(fn){return _this[fn] = _this[fn].bind(_this);});

this._genModules(remoteModules);
localModules && this._genLookupTables(
localModules,this._moduleTable,this._methodTable);

if(__DEV__){
this._debugInfo = {};
this._remoteModuleTable = {};
this._remoteMethodTable = {};
this._genLookupTables(
remoteModules,this._remoteModuleTable,this._remoteMethodTable);}}_createClass(MessageQueue,[{key:'processBatch',value:






function processBatch(batch){var _this2=this;
ReactUpdates.batchedUpdates(function(){
batch.forEach(function(call){
var method=call.method === 'callFunctionReturnFlushedQueue'?
'__callFunction':'__invokeCallback';
guard(function(){return _this2[method].apply(_this2,call.args);});});

BridgeProfiling.profile('ReactUpdates.batchedUpdates()');});

BridgeProfiling.profileEnd();
return this.flushedQueue();}},{key:'callFunctionReturnFlushedQueue',value:


function callFunctionReturnFlushedQueue(module,method,args){var _this3=this;
guard(function(){return _this3.__callFunction(module,method,args);});
return this.flushedQueue();}},{key:'invokeCallbackAndReturnFlushedQueue',value:


function invokeCallbackAndReturnFlushedQueue(cbID,args){var _this4=this;
guard(function(){return _this4.__invokeCallback(cbID,args);});
return this.flushedQueue();}},{key:'flushedQueue',value:


function flushedQueue(){
BridgeProfiling.profile('JSTimersExecution.callImmediates()');
guard(function(){return JSTimersExecution.callImmediates();});
BridgeProfiling.profileEnd();
var queue=this._queue;
this._queue = [[],[],[]];
return queue[0].length?queue:null;}},{key:'__nativeCall',value:





function __nativeCall(module,method,params,onFail,onSucc){
if(onFail || onSucc){
if(__DEV__){

this._callbackID > 1 << 5 && (
this._debugInfo[this._callbackID >> 5] = null);

this._debugInfo[this._callbackID >> 1] = [module,method];}

onFail && params.push(this._callbackID);
this._callbacks[this._callbackID++] = onFail;
onSucc && params.push(this._callbackID);
this._callbacks[this._callbackID++] = onSucc;}

this._queue[MODULE_IDS].push(module);
this._queue[METHOD_IDS].push(method);
this._queue[PARAMS].push(params);}},{key:'__callFunction',value:


function __callFunction(module,method,args){
BridgeProfiling.profile(function(){return module + '.' + method + '(' + stringifySafe(args) + ')';});
if(isFinite(module)){
method = this._methodTable[module][method];
module = this._moduleTable[module];}

module = this._require(module);
module[method].apply(module,args);
BridgeProfiling.profileEnd();}},{key:'__invokeCallback',value:


function __invokeCallback(cbID,args){
BridgeProfiling.profile(
function(){return 'MessageQueue.invokeCallback(' + cbID + ', ' + stringifySafe(args) + ')';});
var callback=this._callbacks[cbID];
if(__DEV__ && !callback){
var debug=this._debugInfo[cbID >> 1];
var _module=this._remoteModuleTable[debug[0]];
var method=this._remoteMethodTable[debug[0]][debug[1]];
console.error('Callback with id ' + cbID + ': ' + _module + '.' + method + '() not found');}

this._callbacks[cbID & ~1] = null;
this._callbacks[cbID | 1] = null;
callback.apply(null,args);
BridgeProfiling.profileEnd();}},{key:'_genLookupTables',value:





function _genLookupTables(localModules,moduleTable,methodTable){
var moduleNames=Object.keys(localModules);
for(var i=0,l=moduleNames.length;i < l;i++) {
var moduleName=moduleNames[i];
var methods=localModules[moduleName].methods;
var moduleID=localModules[moduleName].moduleID;
moduleTable[moduleID] = moduleName;
methodTable[moduleID] = {};

var methodNames=Object.keys(methods);
for(var j=0,k=methodNames.length;j < k;j++) {
var methodName=methodNames[j];
var methodConfig=methods[methodName];
methodTable[moduleID][methodConfig.methodID] = methodName;}}}},{key:'_genModules',value:




function _genModules(remoteModules){
var moduleNames=Object.keys(remoteModules);
for(var i=0,l=moduleNames.length;i < l;i++) {
var moduleName=moduleNames[i];
var moduleConfig=remoteModules[moduleName];
this.RemoteModules[moduleName] = this._genModule({},moduleConfig);}}},{key:'_genModule',value:



function _genModule(module,moduleConfig){
var methodNames=Object.keys(moduleConfig.methods);
for(var i=0,l=methodNames.length;i < l;i++) {
var methodName=methodNames[i];
var methodConfig=moduleConfig.methods[methodName];
module[methodName] = this._genMethod(
moduleConfig.moduleID,methodConfig.methodID,methodConfig.type);}

Object.assign(module,moduleConfig.constants);
return module;}},{key:'_genMethod',value:


function _genMethod(module,method,type){
if(type === MethodTypes.local){
return null;}


var self=this;
if(type === MethodTypes.remoteAsync){
return function(){for(var _len=arguments.length,args=Array(_len),_key=0;_key < _len;_key++) {args[_key] = arguments[_key];}
return new Promise(function(resolve,reject){
self.__nativeCall(module,method,args,resolve,function(errorData){
var error=createErrorFromErrorData(errorData);
reject(error);});});};}else 



{
return function(){for(var _len2=arguments.length,args=Array(_len2),_key2=0;_key2 < _len2;_key2++) {args[_key2] = arguments[_key2];}
var lastArg=args.length > 0?args[args.length - 1]:null;
var secondLastArg=args.length > 1?args[args.length - 2]:null;
var hasSuccCB=typeof lastArg === 'function';
var hasErrorCB=typeof secondLastArg === 'function';
hasErrorCB && invariant(
hasSuccCB,
'Cannot have a non-function arg after a function arg.');

var numCBs=hasSuccCB + hasErrorCB;
var onSucc=hasSuccCB?lastArg:null;
var onFail=hasErrorCB?secondLastArg:null;
args = args.slice(0,args.length - numCBs);
return self.__nativeCall(module,method,args,onFail,onSucc);};}}}]);return MessageQueue;})();






function createErrorFromErrorData(errorData){var 

message=

errorData.message;var extraErrorInfo=_objectWithoutProperties(errorData,['message']);
var error=new Error(message);
error.framesToPop = 1;
return Object.assign(error,extraErrorInfo);}


module.exports = MessageQueue;
});
__d('BridgeProfiling',["ReactPerf"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var GLOBAL=GLOBAL || this;

var BridgeProfiling={
profile:function(profileName,args){
if(GLOBAL.__BridgeProfilingIsProfiling){
if(args){
try{
args = JSON.stringify(args);}
catch(err) {
args = err.message;}}


profileName = typeof profileName === 'function'?
profileName():profileName;
console.profile(profileName,args);}},



profileEnd:function(profileName){
if(GLOBAL.__BridgeProfilingIsProfiling){
console.profileEnd(profileName);}},



swizzleReactPerf:function(){
var ReactPerf=require('ReactPerf');
var originalMeasure=ReactPerf.measure;
ReactPerf.measure = function(objName,fnName,func){
func = originalMeasure.call(ReactPerf,objName,fnName,func);
return function(component){
BridgeProfiling.profile();
var ret=func.apply(this,arguments);
if(GLOBAL.__BridgeProfilingIsProfiling){
var name=this._instance && this._instance.constructor && (
this._instance.constructor.displayName || 
this._instance.constructor.name);
BridgeProfiling.profileEnd(objName + '.' + fnName + '(' + name + ')');}

return ret;};};}};





module.exports = BridgeProfiling;
});
__d('ErrorUtils',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var 











GLOBAL=this;













module.exports = GLOBAL.ErrorUtils;
});
__d('JSTimersExecution',["invariant","keyMirror","performanceNow","warning","JSTimers","JSTimers"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';











var invariant=require('invariant');
var keyMirror=require('keyMirror');
var performanceNow=require('performanceNow');
var warning=require('warning');






var JSTimersExecution={
GUID:1,
Type:keyMirror({
setTimeout:null,
setInterval:null,
requestAnimationFrame:null,
setImmediate:null}),



callbacks:[],
types:[],
timerIDs:[],
immediates:[],






callTimer:function(timerID){
warning(timerID <= JSTimersExecution.GUID,'Tried to call timer with ID ' + timerID + ' but no such timer exists');
var timerIndex=JSTimersExecution.timerIDs.indexOf(timerID);





if(timerIndex === -1){
return;}

var type=JSTimersExecution.types[timerIndex];
var callback=JSTimersExecution.callbacks[timerIndex];


if(type === JSTimersExecution.Type.setTimeout || 
type === JSTimersExecution.Type.setImmediate || 
type === JSTimersExecution.Type.requestAnimationFrame){
JSTimersExecution._clearIndex(timerIndex);}


try{
if(type === JSTimersExecution.Type.setTimeout || 
type === JSTimersExecution.Type.setInterval || 
type === JSTimersExecution.Type.setImmediate){
callback();}else 
if(type === JSTimersExecution.Type.requestAnimationFrame){
var currentTime=performanceNow();
callback(currentTime);}else 
{
console.error('Tried to call a callback with invalid type: ' + type);
return;}}

catch(e) {

JSTimersExecution.errors = JSTimersExecution.errors || [];
JSTimersExecution.errors.push(e);}},







callTimers:function(timerIDs){
invariant(timerIDs.length !== 0,'Probably shouldn\'t call "callTimers" with no timerIDs');

JSTimersExecution.errors = null;
timerIDs.forEach(JSTimersExecution.callTimer);

var errors=JSTimersExecution.errors;
if(errors){
var errorCount=errors.length;
if(errorCount > 1){


for(var ii=1;ii < errorCount;ii++) {
require('JSTimers').setTimeout(
(function(error){throw error;}).bind(null,errors[ii]),
0);}}



throw errors[0];}},







callImmediates:function(){
JSTimersExecution.errors = null;
while(JSTimersExecution.immediates.length !== 0) {
JSTimersExecution.callTimer(JSTimersExecution.immediates.shift());}

if(JSTimersExecution.errors){
JSTimersExecution.errors.forEach(function(error){return (
require('JSTimers').setTimeout(function(){throw error;},0));});}},




_clearIndex:function(i){
JSTimersExecution.timerIDs[i] = null;
JSTimersExecution.callbacks[i] = null;
JSTimersExecution.types[i] = null;}};



module.exports = JSTimersExecution;
});
__d('performanceNow',["performance"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 











performance=require('performance');






if(!performance || !performance.now){
performance = Date;}


var performanceNow=performance.now.bind(performance);

module.exports = performanceNow;
});
__d('performance',["ExecutionEnvironment"],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";













var ExecutionEnvironment=require("ExecutionEnvironment");

var performance;

if(ExecutionEnvironment.canUseDOM){
performance = 
window.performance || 
window.msPerformance || 
window.webkitPerformance;}


module.exports = performance || {};
});
__d('ExecutionEnvironment',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';














var canUseDOM=!!(
typeof window !== 'undefined' && 
window.document && 
window.document.createElement);








var ExecutionEnvironment={

canUseDOM:canUseDOM,

canUseWorkers:typeof Worker !== 'undefined',

canUseEventListeners:
canUseDOM && !!(window.addEventListener || window.attachEvent),

canUseViewport:canUseDOM && !!window.screen,

isInWorker:!canUseDOM};



module.exports = ExecutionEnvironment;
});
__d('JSTimers',["NativeModules","JSTimersExecution"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var RCTTiming=require('NativeModules').Timing;
var JSTimersExecution=require('JSTimersExecution');






var JSTimers={
Types:JSTimersExecution.Types,





_getFreeIndex:function(){
var freeIndex=JSTimersExecution.timerIDs.indexOf(null);
if(freeIndex === -1){
freeIndex = JSTimersExecution.timerIDs.length;}

return freeIndex;},






setTimeout:function(func,duration){for(var _len=arguments.length,args=Array(_len > 2?_len - 2:0),_key=2;_key < _len;_key++) {args[_key - 2] = arguments[_key];}
var newID=JSTimersExecution.GUID++;
var freeIndex=JSTimers._getFreeIndex();
JSTimersExecution.timerIDs[freeIndex] = newID;
JSTimersExecution.callbacks[freeIndex] = function(){
return func.apply(undefined,args);};

JSTimersExecution.types[freeIndex] = JSTimersExecution.Type.setTimeout;
RCTTiming.createTimer(newID,duration,Date.now(),false);
return newID;},






setInterval:function(func,duration){for(var _len2=arguments.length,args=Array(_len2 > 2?_len2 - 2:0),_key2=2;_key2 < _len2;_key2++) {args[_key2 - 2] = arguments[_key2];}
var newID=JSTimersExecution.GUID++;
var freeIndex=JSTimers._getFreeIndex();
JSTimersExecution.timerIDs[freeIndex] = newID;
JSTimersExecution.callbacks[freeIndex] = function(){
return func.apply(undefined,args);};

JSTimersExecution.types[freeIndex] = JSTimersExecution.Type.setInterval;
RCTTiming.createTimer(newID,duration,Date.now(),true);
return newID;},






setImmediate:function(func){for(var _len3=arguments.length,args=Array(_len3 > 1?_len3 - 1:0),_key3=1;_key3 < _len3;_key3++) {args[_key3 - 1] = arguments[_key3];}
var newID=JSTimersExecution.GUID++;
var freeIndex=JSTimers._getFreeIndex();
JSTimersExecution.timerIDs[freeIndex] = newID;
JSTimersExecution.callbacks[freeIndex] = function(){
return func.apply(undefined,args);};

JSTimersExecution.types[freeIndex] = JSTimersExecution.Type.setImmediate;
JSTimersExecution.immediates.push(newID);
return newID;},





requestAnimationFrame:function(func){
var newID=JSTimersExecution.GUID++;
var freeIndex=JSTimers._getFreeIndex();
JSTimersExecution.timerIDs[freeIndex] = newID;
JSTimersExecution.callbacks[freeIndex] = func;
JSTimersExecution.types[freeIndex] = JSTimersExecution.Type.requestAnimationFrame;
RCTTiming.createTimer(newID,1,Date.now(),false);
return newID;},


clearTimeout:function(timerID){
JSTimers._clearTimerID(timerID);},


clearInterval:function(timerID){
JSTimers._clearTimerID(timerID);},


clearImmediate:function(timerID){
JSTimers._clearTimerID(timerID);
JSTimersExecution.immediates.splice(
JSTimersExecution.immediates.indexOf(timerID),
1);},



cancelAnimationFrame:function(timerID){
JSTimers._clearTimerID(timerID);},


_clearTimerID:function(timerID){


if(timerID == null){
return;}


var index=JSTimersExecution.timerIDs.indexOf(timerID);

if(index !== -1){
JSTimersExecution._clearIndex(index);
if(JSTimersExecution.types[index] !== JSTimersExecution.Type.setImmediate){
RCTTiming.deleteTimer(timerID);}}}};





module.exports = JSTimers;
});
__d('stringifySafe',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';
















function stringifySafe(arg){
var ret;
var type=typeof arg;
if(arg === undefined){
ret = 'undefined';}else 
if(arg === null){
ret = 'null';}else 
if(type === 'string'){
ret = '"' + arg + '"';}else 
if(type === 'function'){
try{
ret = arg.toString();}
catch(e) {
ret = '[function unknown]';}}else 

{


try{
ret = JSON.stringify(arg);}
catch(e) {
if(typeof arg.toString === 'function'){
try{
ret = arg.toString();}
catch(E) {}}}}



return ret || '["' + type + '" failed to stringify]';}


module.exports = stringifySafe;
});
__d('nativeModulePrefixNormalizer',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













function nativeModulePrefixNormalizer(
modules)
{
Object.keys(modules).forEach(function(moduleName){
var strippedName=moduleName.replace(/^(RCT|RK)/,'');
if(modules['RCT' + strippedName] && modules['RK' + strippedName]){
throw new Error(
'Module cannot be registered as both RCT and RK: ' + moduleName);}


if(strippedName !== moduleName){
modules[strippedName] = modules[moduleName];
delete modules[moduleName];}});}




module.exports = nativeModulePrefixNormalizer;
});
__d('InspectorUtils',["ReactInstanceHandles","ReactInstanceMap","ReactNativeMount","ReactNativeTagHandles"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';











var ReactInstanceHandles=require('ReactInstanceHandles');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactNativeMount=require('ReactNativeMount');
var ReactNativeTagHandles=require('ReactNativeTagHandles');

function traverseOwnerTreeUp(hierarchy,instance){
if(instance){
hierarchy.unshift(instance);
traverseOwnerTreeUp(hierarchy,instance._currentElement._owner);}}



function findInstance(component,targetID){
if(targetID === findRootNodeID(component)){
return component;}

if(component._renderedComponent){
return findInstance(component._renderedComponent,targetID);}else 
{
for(var key in component._renderedChildren) {
var child=component._renderedChildren[key];
if(ReactInstanceHandles.isAncestorIDOf(findRootNodeID(child),targetID)){
var instance=findInstance(child,targetID);
if(instance){
return instance;}}}}}






function findRootNodeID(component){
var internalInstance=ReactInstanceMap.get(component);
return internalInstance?internalInstance._rootNodeID:component._rootNodeID;}


function findInstanceByNativeTag(rootTag,nativeTag){
var containerID=ReactNativeTagHandles.tagToRootNodeID[rootTag];
var rootInstance=ReactNativeMount._instancesByContainerID[containerID];
var targetID=ReactNativeTagHandles.tagToRootNodeID[nativeTag];
if(!targetID){
return undefined;}

return findInstance(rootInstance,targetID);}


function getOwnerHierarchy(instance){
var hierarchy=[];
traverseOwnerTreeUp(hierarchy,instance);
return hierarchy;}


module.exports = {findInstanceByNativeTag:findInstanceByNativeTag,getOwnerHierarchy:getOwnerHierarchy};
});
__d('ReactNativeMount',["NativeModules","ReactNativeTagHandles","ReactPerf","ReactReconciler","ReactUpdateQueue","ReactUpdates","emptyObject","instantiateReactComponent","shouldUpdateReactComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var RCTUIManager=require('NativeModules').UIManager;

var ReactNativeTagHandles=require('ReactNativeTagHandles');
var ReactPerf=require('ReactPerf');
var ReactReconciler=require('ReactReconciler');
var ReactUpdateQueue=require('ReactUpdateQueue');
var ReactUpdates=require('ReactUpdates');

var emptyObject=require('emptyObject');
var instantiateReactComponent=require('instantiateReactComponent');
var shouldUpdateReactComponent=require('shouldUpdateReactComponent');

function instanceNumberToChildRootID(rootNodeID,instanceNumber){
return rootNodeID + '[' + instanceNumber + ']';}










function mountComponentIntoNode(
componentInstance,
rootID,
container,
transaction){
var markup=ReactReconciler.mountComponent(
componentInstance,rootID,transaction,emptyObject);

componentInstance._isTopLevel = true;
ReactNativeMount._mountImageIntoNode(markup,container);}









function batchedMountComponentIntoNode(
componentInstance,
rootID,
container){
var transaction=ReactUpdates.ReactReconcileTransaction.getPooled();
transaction.perform(
mountComponentIntoNode,
null,
componentInstance,
rootID,
container,
transaction);

ReactUpdates.ReactReconcileTransaction.release(transaction);}






var ReactNativeMount={
instanceCount:0,

_instancesByContainerID:{},





renderComponent:function(
nextElement,
containerTag,
callback)
{
var topRootNodeID=ReactNativeTagHandles.tagToRootNodeID[containerTag];
if(topRootNodeID){
var prevComponent=ReactNativeMount._instancesByContainerID[topRootNodeID];
if(prevComponent){
var prevElement=prevComponent._currentElement;
if(shouldUpdateReactComponent(prevElement,nextElement)){
ReactUpdateQueue.enqueueElementInternal(prevComponent,nextElement);
if(callback){
ReactUpdateQueue.enqueueCallbackInternal(prevComponent,callback);}

return prevComponent;}else 
{
ReactNativeMount.unmountComponentAtNode(containerTag);}}}




if(!ReactNativeTagHandles.reactTagIsNativeTopRootID(containerTag)){
console.error('You cannot render into anything but a top root');
return;}


var topRootNodeID=ReactNativeTagHandles.allocateRootNodeIDForTag(containerTag);
ReactNativeTagHandles.associateRootNodeIDWithMountedNodeHandle(
topRootNodeID,
containerTag);


var instance=instantiateReactComponent(nextElement);
ReactNativeMount._instancesByContainerID[topRootNodeID] = instance;

var childRootNodeID=instanceNumberToChildRootID(
topRootNodeID,
ReactNativeMount.instanceCount++);






ReactUpdates.batchedUpdates(
batchedMountComponentIntoNode,
instance,
childRootNodeID,
topRootNodeID);

var component=instance.getPublicInstance();
if(callback){
callback.call(component);}

return component;},






_mountImageIntoNode:ReactPerf.measure(

'ReactComponentBrowserEnvironment',
'mountImageIntoNode',
function(mountImage,containerID){


ReactNativeTagHandles.associateRootNodeIDWithMountedNodeHandle(
mountImage.rootNodeID,
mountImage.tag);

var addChildTags=[mountImage.tag];
var addAtIndices=[0];
RCTUIManager.manageChildren(
ReactNativeTagHandles.mostRecentMountedNodeHandleForRootNodeID(containerID),
null,
null,
addChildTags,
addAtIndices,
null);}),












unmountComponentAtNodeAndRemoveContainer:function(
containerTag)
{
ReactNativeMount.unmountComponentAtNode(containerTag);

RCTUIManager.removeRootView(containerTag);},







unmountComponentAtNode:function(containerTag){
if(!ReactNativeTagHandles.reactTagIsNativeTopRootID(containerTag)){
console.error('You cannot render into anything but a top root');
return false;}


var containerID=ReactNativeTagHandles.tagToRootNodeID[containerTag];
var instance=ReactNativeMount._instancesByContainerID[containerID];
if(!instance){
return false;}

ReactNativeMount.unmountComponentFromNode(instance,containerID);
delete ReactNativeMount._instancesByContainerID[containerID];
return true;},











unmountComponentFromNode:function(
instance,
containerID)
{

ReactReconciler.unmountComponent(instance);
var containerTag=
ReactNativeTagHandles.mostRecentMountedNodeHandleForRootNodeID(containerID);
RCTUIManager.removeSubviewsFromContainerWithID(containerTag);},


getNode:function(id){
return id;}};



ReactNativeMount.renderComponent = ReactPerf.measure(
'ReactMount',
'_renderNewRootComponent',
ReactNativeMount.renderComponent);


module.exports = ReactNativeMount;
});
__d('ReactNativeTagHandles',["invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');
var warning=require('warning');














var INITIAL_TAG_COUNT=1;
var NATIVE_TOP_ROOT_ID_SEPARATOR='{TOP_LEVEL}';
var ReactNativeTagHandles={
tagsStartAt:INITIAL_TAG_COUNT,
tagCount:INITIAL_TAG_COUNT,

allocateTag:function(){

while(this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount)) {
ReactNativeTagHandles.tagCount++;}

var tag=ReactNativeTagHandles.tagCount;
ReactNativeTagHandles.tagCount++;
return tag;},











associateRootNodeIDWithMountedNodeHandle:function(
rootNodeID,
tag)
{
warning(rootNodeID && tag,'Root node or tag is null when associating');
if(rootNodeID && tag){
ReactNativeTagHandles.tagToRootNodeID[tag] = rootNodeID;
ReactNativeTagHandles.rootNodeIDToTag[rootNodeID] = tag;}},



allocateRootNodeIDForTag:function(tag){
invariant(
this.reactTagIsNativeTopRootID(tag),
'Expect a native root tag, instead got ',tag);

return '.r[' + tag + ']' + NATIVE_TOP_ROOT_ID_SEPARATOR;},


reactTagIsNativeTopRootID:function(reactTag){

return reactTag % 10 === 1;},


getNativeTopRootIDFromNodeID:function(nodeID){
if(!nodeID){
return null;}

var index=nodeID.indexOf(NATIVE_TOP_ROOT_ID_SEPARATOR);
if(index === -1){
return null;}

return nodeID.substr(0,index + NATIVE_TOP_ROOT_ID_SEPARATOR.length);},














mostRecentMountedNodeHandleForRootNodeID:function(
rootNodeID)
{
return ReactNativeTagHandles.rootNodeIDToTag[rootNodeID];},


tagToRootNodeID:[],

rootNodeIDToTag:{}};


module.exports = ReactNativeTagHandles;
});
__d('instantiateReactComponent',["ReactCompositeComponent","ReactEmptyComponent","ReactNativeComponent","Object.assign","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactCompositeComponent=require('ReactCompositeComponent');
var ReactEmptyComponent=require('ReactEmptyComponent');
var ReactNativeComponent=require('ReactNativeComponent');

var assign=require('Object.assign');
var invariant=require('invariant');
var warning=require('warning');


var ReactCompositeComponentWrapper=function(){};
assign(
ReactCompositeComponentWrapper.prototype,
ReactCompositeComponent.Mixin,
{
_instantiateReactComponent:instantiateReactComponent});










function isInternalComponentType(type){
return (
typeof type === 'function' && 
typeof type.prototype !== 'undefined' && 
typeof type.prototype.mountComponent === 'function' && 
typeof type.prototype.receiveComponent === 'function');}











function instantiateReactComponent(node,parentCompositeType){
var instance;

if(node === null || node === false){
node = ReactEmptyComponent.emptyElement;}


if(typeof node === 'object'){
var element=node;
if(__DEV__){
warning(
element && (typeof element.type === 'function' || 
typeof element.type === 'string'),
'Only functions or strings can be mounted as React components.');}




if(parentCompositeType === element.type && 
typeof element.type === 'string'){

instance = ReactNativeComponent.createInternalComponent(element);}else 


if(isInternalComponentType(element.type)){



instance = new element.type(element);}else 
{
instance = new ReactCompositeComponentWrapper();}}else 

if(typeof node === 'string' || typeof node === 'number'){
instance = ReactNativeComponent.createInstanceForText(node);}else 
{
invariant(
false,
'Encountered invalid React node of type %s',
typeof node);}



if(__DEV__){
warning(
typeof instance.construct === 'function' && 
typeof instance.mountComponent === 'function' && 
typeof instance.receiveComponent === 'function' && 
typeof instance.unmountComponent === 'function',
'Only React Components can be mounted.');}




instance.construct(node);




instance._mountIndex = 0;
instance._mountImage = null;

if(__DEV__){
instance._isOwnerNecessary = false;
instance._warnedAboutRefsInRender = false;}




if(__DEV__){
if(Object.preventExtensions){
Object.preventExtensions(instance);}}



return instance;}


module.exports = instantiateReactComponent;
});
__d('ReactCompositeComponent',["ReactComponentEnvironment","ReactContext","ReactCurrentOwner","ReactElement","ReactElementValidator","ReactInstanceMap","ReactLifeCycle","ReactNativeComponent","ReactPerf","ReactPropTypeLocations","ReactPropTypeLocationNames","ReactReconciler","ReactUpdates","Object.assign","emptyObject","invariant","shouldUpdateReactComponent","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactComponentEnvironment=require('ReactComponentEnvironment');
var ReactContext=require('ReactContext');
var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactElement=require('ReactElement');
var ReactElementValidator=require('ReactElementValidator');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactLifeCycle=require('ReactLifeCycle');
var ReactNativeComponent=require('ReactNativeComponent');
var ReactPerf=require('ReactPerf');
var ReactPropTypeLocations=require('ReactPropTypeLocations');
var ReactPropTypeLocationNames=require('ReactPropTypeLocationNames');
var ReactReconciler=require('ReactReconciler');
var ReactUpdates=require('ReactUpdates');

var assign=require('Object.assign');
var emptyObject=require('emptyObject');
var invariant=require('invariant');
var shouldUpdateReactComponent=require('shouldUpdateReactComponent');
var warning=require('warning');

function getDeclarationErrorAddendum(component){
var owner=component._currentElement._owner || null;
if(owner){
var name=owner.getName();
if(name){
return ' Check the render method of `' + name + '`.';}}


return '';}



































var nextMountID=1;




var ReactCompositeComponentMixin={








construct:function(element){
this._currentElement = element;
this._rootNodeID = null;
this._instance = null;


this._pendingElement = null;
this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;

this._renderedComponent = null;

this._context = null;
this._mountOrder = 0;
this._isTopLevel = false;


this._pendingCallbacks = null;},











mountComponent:function(rootID,transaction,context){
this._context = context;
this._mountOrder = nextMountID++;
this._rootNodeID = rootID;

var publicProps=this._processProps(this._currentElement.props);
var publicContext=this._processContext(this._currentElement._context);

var Component=ReactNativeComponent.getComponentClassForElement(
this._currentElement);



var inst=new Component(publicProps,publicContext);

if(__DEV__){


warning(
inst.render != null,
'%s(...): No `render` method found on the returned component ' + 
'instance: you may have forgotten to define `render` in your ' + 
'component or you may have accidentally tried to render an element ' + 
'whose type is a function that isn\'t a React component.',
Component.displayName || Component.name || 'Component');}





inst.props = publicProps;
inst.context = publicContext;
inst.refs = emptyObject;

this._instance = inst;


ReactInstanceMap.set(inst,this);

if(__DEV__){
this._warnIfContextsDiffer(this._currentElement._context,context);}


if(__DEV__){



warning(
!inst.getInitialState || 
inst.getInitialState.isReactClassApproved,
'getInitialState was defined on %s, a plain JavaScript class. ' + 
'This is only supported for classes created using React.createClass. ' + 
'Did you mean to define a state property instead?',
this.getName() || 'a component');

warning(
!inst.getDefaultProps || 
inst.getDefaultProps.isReactClassApproved,
'getDefaultProps was defined on %s, a plain JavaScript class. ' + 
'This is only supported for classes created using React.createClass. ' + 
'Use a static property to define defaultProps instead.',
this.getName() || 'a component');

warning(
!inst.propTypes,
'propTypes was defined as an instance property on %s. Use a static ' + 
'property to define propTypes instead.',
this.getName() || 'a component');

warning(
!inst.contextTypes,
'contextTypes was defined as an instance property on %s. Use a ' + 
'static property to define contextTypes instead.',
this.getName() || 'a component');

warning(
typeof inst.componentShouldUpdate !== 'function',
'%s has a method called ' + 
'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 
'The name is phrased as a question because the function is ' + 
'expected to return a value.',
this.getName() || 'A component');}



var initialState=inst.state;
if(initialState === undefined){
inst.state = initialState = null;}

invariant(
typeof initialState === 'object' && !Array.isArray(initialState),
'%s.state: must be set to an object or null',
this.getName() || 'ReactCompositeComponent');


this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;

var renderedElement;

var previouslyMounting=ReactLifeCycle.currentlyMountingInstance;
ReactLifeCycle.currentlyMountingInstance = this;
try{
if(inst.componentWillMount){
inst.componentWillMount();


if(this._pendingStateQueue){
inst.state = this._processPendingState(inst.props,inst.context);}}



renderedElement = this._renderValidatedComponent();}finally 
{
ReactLifeCycle.currentlyMountingInstance = previouslyMounting;}


this._renderedComponent = this._instantiateReactComponent(
renderedElement,
this._currentElement.type);


var markup=ReactReconciler.mountComponent(
this._renderedComponent,
rootID,
transaction,
this._processChildContext(context));

if(inst.componentDidMount){
transaction.getReactMountReady().enqueue(inst.componentDidMount,inst);}


return markup;},








unmountComponent:function(){
var inst=this._instance;

if(inst.componentWillUnmount){
var previouslyUnmounting=ReactLifeCycle.currentlyUnmountingInstance;
ReactLifeCycle.currentlyUnmountingInstance = this;
try{
inst.componentWillUnmount();}finally 
{
ReactLifeCycle.currentlyUnmountingInstance = previouslyUnmounting;}}



ReactReconciler.unmountComponent(this._renderedComponent);
this._renderedComponent = null;


this._pendingStateQueue = null;
this._pendingReplaceState = false;
this._pendingForceUpdate = false;
this._pendingCallbacks = null;
this._pendingElement = null;



this._context = null;
this._rootNodeID = null;




ReactInstanceMap.remove(inst);},
















_setPropsInternal:function(partialProps,callback){


var element=this._pendingElement || this._currentElement;
this._pendingElement = ReactElement.cloneAndReplaceProps(
element,
assign({},element.props,partialProps));

ReactUpdates.enqueueUpdate(this,callback);},










_maskContext:function(context){
var maskedContext=null;


if(typeof this._currentElement.type === 'string'){
return emptyObject;}

var contextTypes=this._currentElement.type.contextTypes;
if(!contextTypes){
return emptyObject;}

maskedContext = {};
for(var contextName in contextTypes) {
maskedContext[contextName] = context[contextName];}

return maskedContext;},










_processContext:function(context){
var maskedContext=this._maskContext(context);
if(__DEV__){
var Component=ReactNativeComponent.getComponentClassForElement(
this._currentElement);

if(Component.contextTypes){
this._checkPropTypes(
Component.contextTypes,
maskedContext,
ReactPropTypeLocations.context);}}



return maskedContext;},







_processChildContext:function(currentContext){
var inst=this._instance;
var childContext=inst.getChildContext && inst.getChildContext();
if(childContext){
invariant(
typeof inst.constructor.childContextTypes === 'object',
'%s.getChildContext(): childContextTypes must be defined in order to ' + 
'use getChildContext().',
this.getName() || 'ReactCompositeComponent');

if(__DEV__){
this._checkPropTypes(
inst.constructor.childContextTypes,
childContext,
ReactPropTypeLocations.childContext);}


for(var name in childContext) {
invariant(
name in inst.constructor.childContextTypes,
'%s.getChildContext(): key "%s" is not defined in childContextTypes.',
this.getName() || 'ReactCompositeComponent',
name);}


return assign({},currentContext,childContext);}

return currentContext;},











_processProps:function(newProps){
if(__DEV__){
var Component=ReactNativeComponent.getComponentClassForElement(
this._currentElement);

if(Component.propTypes){
this._checkPropTypes(
Component.propTypes,
newProps,
ReactPropTypeLocations.prop);}}



return newProps;},










_checkPropTypes:function(propTypes,props,location){


var componentName=this.getName();
for(var propName in propTypes) {
if(propTypes.hasOwnProperty(propName)){
var error;
try{


invariant(
typeof propTypes[propName] === 'function',
'%s: %s type `%s` is invalid; it must be a function, usually ' + 
'from React.PropTypes.',
componentName || 'React class',
ReactPropTypeLocationNames[location],
propName);

error = propTypes[propName](props,propName,componentName,location);}
catch(ex) {
error = ex;}

if(error instanceof Error){



var addendum=getDeclarationErrorAddendum(this);

if(location === ReactPropTypeLocations.prop){

warning(
false,
'Failed Composite propType: %s%s',
error.message,
addendum);}else 

{
warning(
false,
'Failed Context Types: %s%s',
error.message,
addendum);}}}}},







receiveComponent:function(nextElement,transaction,nextContext){
var prevElement=this._currentElement;
var prevContext=this._context;

this._pendingElement = null;

this.updateComponent(
transaction,
prevElement,
nextElement,
prevContext,
nextContext);},










performUpdateIfNecessary:function(transaction){
if(this._pendingElement != null){
ReactReconciler.receiveComponent(
this,
this._pendingElement || this._currentElement,
transaction,
this._context);}



if(this._pendingStateQueue !== null || this._pendingForceUpdate){
if(__DEV__){
ReactElementValidator.checkAndWarnForMutatedProps(
this._currentElement);}



this.updateComponent(
transaction,
this._currentElement,
this._currentElement,
this._context,
this._context);}},








_warnIfContextsDiffer:function(ownerBasedContext,parentBasedContext){
ownerBasedContext = this._maskContext(ownerBasedContext);
parentBasedContext = this._maskContext(parentBasedContext);
var parentKeys=Object.keys(parentBasedContext).sort();
var displayName=this.getName() || 'ReactCompositeComponent';
for(var i=0;i < parentKeys.length;i++) {
var key=parentKeys[i];
warning(
ownerBasedContext[key] === parentBasedContext[key],
'owner-based and parent-based contexts differ ' + 
'(values: `%s` vs `%s`) for key (%s) while mounting %s ' + 
'(see: http://fb.me/react-context-by-parent)',
ownerBasedContext[key],
parentBasedContext[key],
key,
displayName);}},



















updateComponent:function(
transaction,
prevParentElement,
nextParentElement,
prevUnmaskedContext,
nextUnmaskedContext)
{
var inst=this._instance;

var nextContext=inst.context;
var nextProps=inst.props;


if(prevParentElement !== nextParentElement){
nextContext = this._processContext(nextParentElement._context);
nextProps = this._processProps(nextParentElement.props);

if(__DEV__){
if(nextUnmaskedContext != null){
this._warnIfContextsDiffer(
nextParentElement._context,
nextUnmaskedContext);}}








if(inst.componentWillReceiveProps){
inst.componentWillReceiveProps(nextProps,nextContext);}}



var nextState=this._processPendingState(nextProps,nextContext);

var shouldUpdate=
this._pendingForceUpdate || 
!inst.shouldComponentUpdate || 
inst.shouldComponentUpdate(nextProps,nextState,nextContext);

if(__DEV__){
warning(
typeof shouldUpdate !== 'undefined',
'%s.shouldComponentUpdate(): Returned undefined instead of a ' + 
'boolean value. Make sure to return true or false.',
this.getName() || 'ReactCompositeComponent');}



if(shouldUpdate){
this._pendingForceUpdate = false;

this._performComponentUpdate(
nextParentElement,
nextProps,
nextState,
nextContext,
transaction,
nextUnmaskedContext);}else 

{


this._currentElement = nextParentElement;
this._context = nextUnmaskedContext;
inst.props = nextProps;
inst.state = nextState;
inst.context = nextContext;}},



_processPendingState:function(props,context){
var inst=this._instance;
var queue=this._pendingStateQueue;
var replace=this._pendingReplaceState;
this._pendingReplaceState = false;
this._pendingStateQueue = null;

if(!queue){
return inst.state;}


var nextState=assign({},replace?queue[0]:inst.state);
for(var i=replace?1:0;i < queue.length;i++) {
var partial=queue[i];
assign(
nextState,
typeof partial === 'function'?
partial.call(inst,nextState,props,context):
partial);}



return nextState;},














_performComponentUpdate:function(
nextElement,
nextProps,
nextState,
nextContext,
transaction,
unmaskedContext)
{
var inst=this._instance;

var prevProps=inst.props;
var prevState=inst.state;
var prevContext=inst.context;

if(inst.componentWillUpdate){
inst.componentWillUpdate(nextProps,nextState,nextContext);}


this._currentElement = nextElement;
this._context = unmaskedContext;
inst.props = nextProps;
inst.state = nextState;
inst.context = nextContext;

this._updateRenderedComponent(transaction,unmaskedContext);

if(inst.componentDidUpdate){
transaction.getReactMountReady().enqueue(
inst.componentDidUpdate.bind(inst,prevProps,prevState,prevContext),
inst);}},










_updateRenderedComponent:function(transaction,context){
var prevComponentInstance=this._renderedComponent;
var prevRenderedElement=prevComponentInstance._currentElement;
var nextRenderedElement=this._renderValidatedComponent();
if(shouldUpdateReactComponent(prevRenderedElement,nextRenderedElement)){
ReactReconciler.receiveComponent(
prevComponentInstance,
nextRenderedElement,
transaction,
this._processChildContext(context));}else 

{

var thisID=this._rootNodeID;
var prevComponentID=prevComponentInstance._rootNodeID;
ReactReconciler.unmountComponent(prevComponentInstance);

this._renderedComponent = this._instantiateReactComponent(
nextRenderedElement,
this._currentElement.type);

var nextMarkup=ReactReconciler.mountComponent(
this._renderedComponent,
thisID,
transaction,
this._processChildContext(context));

this._replaceNodeWithMarkupByID(prevComponentID,nextMarkup);}},






_replaceNodeWithMarkupByID:function(prevComponentID,nextMarkup){
ReactComponentEnvironment.replaceNodeWithMarkupByID(
prevComponentID,
nextMarkup);},






_renderValidatedComponentWithoutOwnerOrContext:function(){
var inst=this._instance;
var renderedComponent=inst.render();
if(__DEV__){

if(typeof renderedComponent === 'undefined' && 
inst.render._isMockFunction){


renderedComponent = null;}}



return renderedComponent;},





_renderValidatedComponent:function(){
var renderedComponent;
var previousContext=ReactContext.current;
ReactContext.current = this._processChildContext(
this._currentElement._context);

ReactCurrentOwner.current = this;
try{
renderedComponent = 
this._renderValidatedComponentWithoutOwnerOrContext();}finally 
{
ReactContext.current = previousContext;
ReactCurrentOwner.current = null;}

invariant(

renderedComponent === null || renderedComponent === false || 
ReactElement.isValidElement(renderedComponent),
'%s.render(): A valid ReactComponent must be returned. You may have ' + 
'returned undefined, an array or some other invalid object.',
this.getName() || 'ReactCompositeComponent');

return renderedComponent;},










attachRef:function(ref,component){
var inst=this.getPublicInstance();
var refs=inst.refs === emptyObject?inst.refs = {}:inst.refs;
refs[ref] = component.getPublicInstance();},









detachRef:function(ref){
var refs=this.getPublicInstance().refs;
delete refs[ref];},








getName:function(){
var type=this._currentElement.type;
var constructor=this._instance && this._instance.constructor;
return (
type.displayName || constructor && constructor.displayName || 
type.name || constructor && constructor.name || 
null);},











getPublicInstance:function(){
return this._instance;},



_instantiateReactComponent:null};



ReactPerf.measureMethods(
ReactCompositeComponentMixin,
'ReactCompositeComponent',
{
mountComponent:'mountComponent',
updateComponent:'updateComponent',
_renderValidatedComponent:'_renderValidatedComponent'});



var ReactCompositeComponent={

Mixin:ReactCompositeComponentMixin};



module.exports = ReactCompositeComponent;
});
__d('ReactComponentEnvironment',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');

var injected=false;

var ReactComponentEnvironment={






unmountIDFromEnvironment:null,





replaceNodeWithMarkupByID:null,





processChildrenUpdates:null,

injection:{
injectEnvironment:function(environment){
invariant(
!injected,
'ReactCompositeComponent: injectEnvironment() can only be called once.');

ReactComponentEnvironment.unmountIDFromEnvironment = 
environment.unmountIDFromEnvironment;
ReactComponentEnvironment.replaceNodeWithMarkupByID = 
environment.replaceNodeWithMarkupByID;
ReactComponentEnvironment.processChildrenUpdates = 
environment.processChildrenUpdates;
injected = true;}}};





module.exports = ReactComponentEnvironment;
});
__d('shouldUpdateReactComponent',["warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var warning=require('warning');












function shouldUpdateReactComponent(prevElement,nextElement){
if(prevElement != null && nextElement != null){
var prevType=typeof prevElement;
var nextType=typeof nextElement;
if(prevType === 'string' || prevType === 'number'){
return nextType === 'string' || nextType === 'number';}else 
{
if(nextType === 'object' && 
prevElement.type === nextElement.type && 
prevElement.key === nextElement.key){
var ownersMatch=prevElement._owner === nextElement._owner;
var prevName=null;
var nextName=null;
var nextDisplayName=null;
if(__DEV__){
if(!ownersMatch){
if(prevElement._owner != null && 
prevElement._owner.getPublicInstance() != null && 
prevElement._owner.getPublicInstance().constructor != null){
prevName = 
prevElement._owner.getPublicInstance().constructor.displayName;}

if(nextElement._owner != null && 
nextElement._owner.getPublicInstance() != null && 
nextElement._owner.getPublicInstance().constructor != null){
nextName = 
nextElement._owner.getPublicInstance().constructor.displayName;}

if(nextElement.type != null && 
nextElement.type.displayName != null){
nextDisplayName = nextElement.type.displayName;}

if(nextElement.type != null && typeof nextElement.type === 'string'){
nextDisplayName = nextElement.type;}

if(typeof nextElement.type !== 'string' || 
nextElement.type === 'input' || 
nextElement.type === 'textarea'){
if(prevElement._owner != null && 
prevElement._owner._isOwnerNecessary === false || 
nextElement._owner != null && 
nextElement._owner._isOwnerNecessary === false){
if(prevElement._owner != null){
prevElement._owner._isOwnerNecessary = true;}

if(nextElement._owner != null){
nextElement._owner._isOwnerNecessary = true;}

warning(
false,
'<%s /> is being rendered by both %s and %s using the same ' + 
'key (%s) in the same place. Currently, this means that ' + 
'they don\'t preserve state. This behavior should be very ' + 
'rare so we\'re considering deprecating it. Please contact ' + 
'the React team and explain your use case so that we can ' + 
'take that into consideration.',
nextDisplayName || 'Unknown Component',
prevName || '[Unknown]',
nextName || '[Unknown]',
prevElement.key);}}}}





return ownersMatch;}}}



return false;}


module.exports = shouldUpdateReactComponent;
});
__d('ReactEmptyComponent',["ReactElement","ReactInstanceMap","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactElement=require('ReactElement');
var ReactInstanceMap=require('ReactInstanceMap');

var invariant=require('invariant');

var component;


var nullComponentIDsRegistry={};

var ReactEmptyComponentInjection={
injectEmptyComponent:function(emptyComponent){
component = ReactElement.createFactory(emptyComponent);}};



var ReactEmptyComponentType=function(){};
ReactEmptyComponentType.prototype.componentDidMount = function(){
var internalInstance=ReactInstanceMap.get(this);




if(!internalInstance){
return;}

registerNullComponentID(internalInstance._rootNodeID);};

ReactEmptyComponentType.prototype.componentWillUnmount = function(){
var internalInstance=ReactInstanceMap.get(this);

if(!internalInstance){
return;}

deregisterNullComponentID(internalInstance._rootNodeID);};

ReactEmptyComponentType.prototype.render = function(){
invariant(
component,
'Trying to return null from a render, but no null placeholder component ' + 
'was injected.');

return component();};


var emptyElement=ReactElement.createElement(ReactEmptyComponentType);





function registerNullComponentID(id){
nullComponentIDsRegistry[id] = true;}






function deregisterNullComponentID(id){
delete nullComponentIDsRegistry[id];}






function isNullComponentID(id){
return !!nullComponentIDsRegistry[id];}


var ReactEmptyComponent={
emptyElement:emptyElement,
injection:ReactEmptyComponentInjection,
isNullComponentID:isNullComponentID};


module.exports = ReactEmptyComponent;
});
__d('RCTDeviceEventEmitter',["EventEmitter"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventEmitter=require('EventEmitter');

var RCTDeviceEventEmitter=new EventEmitter();

module.exports = RCTDeviceEventEmitter;
});
__d('EventEmitter',["EmitterSubscription","ErrorUtils","EventSubscriptionVendor","emptyFunction","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  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');}}

















var EmitterSubscription=require('EmitterSubscription');
var ErrorUtils=require('ErrorUtils');
var EventSubscriptionVendor=require('EventSubscriptionVendor');
var emptyFunction=require('emptyFunction');
var invariant=require('invariant');var 














EventEmitter=(function(){



function EventEmitter(){_classCallCheck(this,EventEmitter);
this._subscriber = new EventSubscriptionVendor();}_createClass(EventEmitter,[{key:'addListener',value:
















function addListener(
eventType,listener,context){
return this._subscriber.addSubscription(
eventType,
new EmitterSubscription(this._subscriber,listener,context));}},{key:'once',value:












function once(eventType,listener,context){
var emitter=this;
return this.addListener(eventType,function(){
emitter.removeCurrentListener();
listener.apply(context,arguments);});}},{key:'removeAllListeners',value:










function removeAllListeners(eventType){
this._subscriber.removeAllSubscriptions(eventType);}},{key:'removeCurrentListener',value:























function removeCurrentListener(){
invariant(
!!this._currentSubscription,
'Not in an emitting cycle; there is no current subscription');

this._subscriber.removeSubscription(this._currentSubscription);}},{key:'listeners',value:









function listeners(eventType){
var subscriptions=this._subscriber.getSubscriptionsForType(eventType);
return subscriptions?
subscriptions.filter(emptyFunction.thatReturnsTrue).map(
function(subscription){
return subscription.listener;}):

[];}},{key:'emit',value:
















function emit(eventType){
var subscriptions=this._subscriber.getSubscriptionsForType(eventType);
if(subscriptions){
var keys=Object.keys(subscriptions);
for(var ii=0;ii < keys.length;ii++) {
var key=keys[ii];
var subscription=subscriptions[key];


if(subscription){
this._currentSubscription = subscription;

ErrorUtils.applyWithGuard(
subscription.listener,
subscription.context,
Array.prototype.slice.call(arguments,1),
null,
'EventEmitter:' + eventType);}}



this._currentSubscription = null;}}}]);return EventEmitter;})();




module.exports = EventEmitter;
});
__d('EmitterSubscription',["EventSubscription"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}


















var EventSubscription=require('EventSubscription');var 




EmitterSubscription=(function(_EventSubscription){_inherits(EmitterSubscription,_EventSubscription);









function EmitterSubscription(subscriber,listener,context){_classCallCheck(this,EmitterSubscription);
_get(Object.getPrototypeOf(EmitterSubscription.prototype),'constructor',this).call(this,subscriber);
this.listener = listener;
this.context = context;}return EmitterSubscription;})(EventSubscription);



module.exports = EmitterSubscription;
});
__d('EventSubscription',[],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}var 






















EventSubscription=(function(){





function EventSubscription(subscriber){_classCallCheck(this,EventSubscription);
this.subscriber = subscriber;}_createClass(EventSubscription,[{key:'remove',value:





function remove(){
this.subscriber.removeSubscription(this);}}]);return EventSubscription;})();



module.exports = EventSubscription;
});
__d('EventSubscriptionVendor',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}


















var invariant=require('invariant');var 





EventSubscriptionVendor=(function(){

function EventSubscriptionVendor(){_classCallCheck(this,EventSubscriptionVendor);
this._subscriptionsForType = {};
this._currentSubscription = null;}_createClass(EventSubscriptionVendor,[{key:'addSubscription',value:








function addSubscription(
eventType,subscription){
invariant(
subscription.subscriber === this,
'The subscriber of the subscription is incorrectly set.');
if(!this._subscriptionsForType[eventType]){
this._subscriptionsForType[eventType] = [];}

var key=this._subscriptionsForType[eventType].length;
this._subscriptionsForType[eventType].push(subscription);
subscription.eventType = eventType;
subscription.key = key;
return subscription;}},{key:'removeAllSubscriptions',value:








function removeAllSubscriptions(eventType){
if(eventType === undefined){
this._subscriptionsForType = {};}else 
{
delete this._subscriptionsForType[eventType];}}},{key:'removeSubscription',value:









function removeSubscription(subscription){
var eventType=subscription.eventType;
var key=subscription.key;

var subscriptionsForType=this._subscriptionsForType[eventType];
if(subscriptionsForType){
delete subscriptionsForType[key];}}},{key:'getSubscriptionsForType',value:















function getSubscriptionsForType(eventType){
return this._subscriptionsForType[eventType];}}]);return EventSubscriptionVendor;})();



module.exports = EventSubscriptionVendor;
});
__d('PerformanceLogger',["performanceNow"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var performanceNow=require('performanceNow');

var timespans={};





var PerformanceLogger={
addTimespan:function(key,lengthInMs,description){
if(timespans[key]){
if(__DEV__){
console.log(
'PerformanceLogger: Attempting to add a timespan that already exists');}


return;}


timespans[key] = {
description:description,
totalTime:lengthInMs};},



startTimespan:function(key,description){
if(timespans[key]){
if(__DEV__){
console.log(
'PerformanceLogger: Attempting to start a timespan that already exists');}


return;}


timespans[key] = {
description:description,
startTime:performanceNow()};},



stopTimespan:function(key){
if(!timespans[key] || !timespans[key].startTime){
if(__DEV__){
console.log(
'PerformanceLogger: Attempting to end a timespan that has not started');}


return;}


timespans[key].endTime = performanceNow();
timespans[key].totalTime = 
timespans[key].endTime - timespans[key].startTime;},


clearTimespans:function(){
timespans = {};},


getTimespans:function(){
return timespans;},


logTimespans:function(){
for(var key in timespans) {
console.log(key + ': ' + timespans[key].totalTime + 'ms');}},



addTimespans:function(newTimespans,labels){
for(var i=0,l=newTimespans.length;i < l;i += 2) {
var label=labels[i / 2];
PerformanceLogger.addTimespan(
label,
newTimespans[i + 1] - newTimespans[i],
label);}}};





module.exports = PerformanceLogger;
});
__d('ExceptionsManager',["NativeModules","loadSourceMap","parseErrorStack","stringifySafe"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var RCTExceptionsManager=require('NativeModules').ExceptionsManager;

var loadSourceMap=require('loadSourceMap');
var parseErrorStack=require('parseErrorStack');
var stringifySafe=require('stringifySafe');

var sourceMapPromise;







function reportException(e,isFatal,stack){
if(RCTExceptionsManager){
if(!stack){
stack = parseErrorStack(e);}

if(isFatal){
RCTExceptionsManager.reportFatalException(e.message,stack);}else 
{
RCTExceptionsManager.reportSoftException(e.message,stack);}

if(__DEV__){
(sourceMapPromise = sourceMapPromise || loadSourceMap()).
then(function(map){
var prettyStack=parseErrorStack(e,map);
RCTExceptionsManager.updateExceptionMessage(e.message,prettyStack);}).

catch(function(error){


console.warn('Unable to load source map: ' + error.message);});}}}





function handleException(e,isFatal){
var stack=parseErrorStack(e);
var msg=
'Error: ' + e.message + 
'\n stack: \n' + stackToString(stack) + 
'\n URL: ' + e.sourceURL + 
'\n line: ' + e.line + 
'\n message: ' + e.message;
if(console.errorOriginal){
console.errorOriginal(msg);}else 
{
console.error(msg);}

reportException(e,isFatal,stack);}






function installConsoleErrorReporter(){
if(console.reportException){
return;}

console.reportException = reportException;
console.errorOriginal = console.error.bind(console);
console.error = function reactConsoleError(){
console.errorOriginal.apply(null,arguments);
if(!console.reportErrorsAsExceptions){
return;}

var str=Array.prototype.map.call(arguments,stringifySafe).join(', ');
var error=new Error('console.error: ' + str);
error.framesToPop = 1;
reportException(error,false);};

if(console.reportErrorsAsExceptions === undefined){
console.reportErrorsAsExceptions = true;}}



function stackToString(stack){
var maxLength=Math.max.apply(null,stack.map(function(frame){return frame.methodName.length;}));
return stack.map(function(frame){return stackFrameToString(frame,maxLength);}).join('\n');}


function stackFrameToString(stackFrame,maxLength){
var fileNameParts=stackFrame.file.split('/');
var fileName=fileNameParts[fileNameParts.length - 1];

if(fileName.length > 18){
fileName = fileName.substr(0,17) + '…';}


var spaces=fillSpaces(maxLength - stackFrame.methodName.length);
return '  ' + stackFrame.methodName + spaces + '  ' + fileName + ':' + stackFrame.lineNumber;}


function fillSpaces(n){
return new Array(n + 1).join(' ');}


module.exports = {handleException:handleException,installConsoleErrorReporter:installConsoleErrorReporter};
});
__d('loadSourceMap',["Promise","NativeModules","SourceMap","react-native/Libraries/JavaScriptAppEngine/Initialization/source-map-url.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var Promise=require('Promise');
var NativeModules=require('NativeModules');
var SourceMapConsumer=require('SourceMap').SourceMapConsumer;
var SourceMapURL=require('react-native/Libraries/JavaScriptAppEngine/Initialization/source-map-url.js');

var RCTSourceCode=NativeModules.SourceCode;
var RCTNetworking=NativeModules.Networking;

function loadSourceMap(){
return fetchSourceMap().
then(function(map){return new SourceMapConsumer(map);});}


function fetchSourceMap(){
if(global.RAW_SOURCE_MAP){
return Promise.resolve(global.RAW_SOURCE_MAP);}


if(!RCTSourceCode){
return Promise.reject(new Error('RCTSourceCode module is not available'));}


if(!RCTNetworking){

return Promise.reject(new Error('RCTNetworking module is not available'));}


return new Promise(RCTSourceCode.getScriptText).
then(extractSourceMapURL).
then(function(url){
if(url === null){
return Promise.reject(new Error('No source map URL found. May be running from bundled file.'));}

return Promise.resolve(url);}).

then(fetch).
then(function(response){return response.text();});}


function extractSourceMapURL(_ref){var url=_ref.url;var text=_ref.text;var fullSourceMappingURL=_ref.fullSourceMappingURL;
if(fullSourceMappingURL){
return fullSourceMappingURL;}

var mapURL=SourceMapURL.getFrom(text);
if(!mapURL){
return null;}

var baseURL=url.match(/(.+:\/\/.*?)\//)[1];
return baseURL + mapURL;}


module.exports = loadSourceMap;
});
__d('Promise',["setImmediate","promise/setimmediate/es6-extensions.js","promise/setimmediate/done.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';























global.setImmediate = require('setImmediate');
var Promise=require('promise/setimmediate/es6-extensions.js');
require('promise/setimmediate/done.js');




Promise.prototype.finally = function(onSettled){
return this.then(onSettled,onSettled);};



module.exports = Promise;
});
__d('setImmediate',["ImmediateImplementation"],function(global, require, requireDynamic, requireLazy, module, exports) {  module.
















exports = global.setImmediate || 
require('ImmediateImplementation').setImmediate;
});
__d('ImmediateImplementation',[],function(global, require, requireDynamic, requireLazy, module, exports) {  (







































function(global,undefined){
"use strict";

var nextHandle=1;
var tasksByHandle={};
var queueHead={};
var queueTail=queueHead;
var currentlyRunningATask=false;
var doc=global.document;
var setImmediate;

function addFromSetImmediateArguments(args){
var handler=args[0];
args = Array.prototype.slice.call(args,1);
tasksByHandle[nextHandle] = function(){
handler.apply(undefined,args);};

queueTail = queueTail.next = {handle:nextHandle++};
return queueTail.handle;}


function flushQueue(){
var next,task;
while(!currentlyRunningATask && (next = queueHead.next)) {
queueHead = next;
if(task = tasksByHandle[next.handle]){
currentlyRunningATask = true;
try{
task();
currentlyRunningATask = false;}finally 
{
clearImmediate(next.handle);
if(currentlyRunningATask){
currentlyRunningATask = false;






if(queueHead.next){
setImmediate(flushQueue);}}}}}}







function clearImmediate(handle){
delete tasksByHandle[handle];}


function canUsePostMessage(){


if(global.postMessage && !global.importScripts){
var postMessageIsAsynchronous=true;

var onMessage=function(){
postMessageIsAsynchronous = false;
if(global.removeEventListener){
global.removeEventListener("message",onMessage,false);}else 
{
global.detachEvent("onmessage",onMessage);}};



if(global.addEventListener){
global.addEventListener("message",onMessage,false);}else 
if(global.attachEvent){
global.attachEvent("onmessage",onMessage);}else 
{
return false;}


global.postMessage("","*");
return postMessageIsAsynchronous;}}



function installPostMessageImplementation(){


var messagePrefix="setImmediate$" + Math.random() + "$";
var onGlobalMessage=function(event){
if(event.source === global && 
typeof event.data === "string" && 
event.data.indexOf(messagePrefix) === 0){
flushQueue();}};



if(global.addEventListener){
global.addEventListener("message",onGlobalMessage,false);}else 
{
global.attachEvent("onmessage",onGlobalMessage);}


setImmediate = function(){
var handle=addFromSetImmediateArguments(arguments);
global.postMessage(messagePrefix + handle,"*");
return handle;};}



function installMessageChannelImplementation(){
var channel=new MessageChannel();
channel.port1.onmessage = flushQueue;
setImmediate = function(){
var handle=addFromSetImmediateArguments(arguments);
channel.port2.postMessage(handle);
return handle;};}



function installReadyStateChangeImplementation(){
var html=doc.documentElement;
setImmediate = function(){
var handle=addFromSetImmediateArguments(arguments);


var script=doc.createElement("script");
script.onreadystatechange = function(){
script.onreadystatechange = null;
html.removeChild(script);
script = null;
flushQueue();};

html.appendChild(script);
return handle;};}



function installSetTimeoutImplementation(){
setImmediate = function(){
setTimeout(flushQueue,0);
return addFromSetImmediateArguments(arguments);};}



if(canUsePostMessage()){

installPostMessageImplementation();}else 

if(global.MessageChannel){

installMessageChannelImplementation();}else 

if(doc && "onreadystatechange" in doc.createElement("script")){

installReadyStateChangeImplementation();}else 

{

installSetTimeoutImplementation();}


exports.setImmediate = setImmediate;
exports.clearImmediate = clearImmediate;})(
Function("return this")());
});
__d('promise/setimmediate/es6-extensions.js',["promise/setimmediate/core.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



var Promise=require('promise/setimmediate/core.js');


module.exports = Promise;



var TRUE=valuePromise(true);
var FALSE=valuePromise(false);
var NULL=valuePromise(null);
var UNDEFINED=valuePromise(undefined);
var ZERO=valuePromise(0);
var EMPTYSTRING=valuePromise('');

function valuePromise(value){
var p=new Promise(Promise._1);
p._41 = 1;
p._86 = value;
return p;}

Promise.resolve = function(value){
if(value instanceof Promise)return value;

if(value === null)return NULL;
if(value === undefined)return UNDEFINED;
if(value === true)return TRUE;
if(value === false)return FALSE;
if(value === 0)return ZERO;
if(value === '')return EMPTYSTRING;

if(typeof value === 'object' || typeof value === 'function'){
try{
var then=value.then;
if(typeof then === 'function'){
return new Promise(then.bind(value));}}

catch(ex) {
return new Promise(function(resolve,reject){
reject(ex);});}}



return valuePromise(value);};


Promise.all = function(arr){
var args=Array.prototype.slice.call(arr);

return new Promise(function(resolve,reject){
if(args.length === 0)return resolve([]);
var remaining=args.length;
function res(i,val){
if(val && (typeof val === 'object' || typeof val === 'function')){
if(val instanceof Promise && val.then === Promise.prototype.then){
while(val._41 === 3) {
val = val._86;}

if(val._41 === 1)return res(i,val._86);
if(val._41 === 2)reject(val._86);
val.then(function(val){
res(i,val);},
reject);
return;}else 
{
var then=val.then;
if(typeof then === 'function'){
var p=new Promise(then.bind(val));
p.then(function(val){
res(i,val);},
reject);
return;}}}



args[i] = val;
if(--remaining === 0){
resolve(args);}}


for(var i=0;i < args.length;i++) {
res(i,args[i]);}});};




Promise.reject = function(value){
return new Promise(function(resolve,reject){
reject(value);});};



Promise.race = function(values){
return new Promise(function(resolve,reject){
values.forEach(function(value){
Promise.resolve(value).then(resolve,reject);});});};






Promise.prototype['catch'] = function(onRejected){
return this.then(null,onRejected);};
});
__d('promise/setimmediate/core.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



function noop(){}


















var LAST_ERROR=null;
var IS_ERROR={};
function getThen(obj){
try{
return obj.then;}
catch(ex) {
LAST_ERROR = ex;
return IS_ERROR;}}



function tryCallOne(fn,a){
try{
return fn(a);}
catch(ex) {
LAST_ERROR = ex;
return IS_ERROR;}}


function tryCallTwo(fn,a,b){
try{
fn(a,b);}
catch(ex) {
LAST_ERROR = ex;
return IS_ERROR;}}



module.exports = Promise;

function Promise(fn){
if(typeof this !== 'object'){
throw new TypeError('Promises must be constructed via new');}

if(typeof fn !== 'function'){
throw new TypeError('not a function');}

this._41 = 0;
this._86 = null;
this._17 = [];
if(fn === noop)return;
doResolve(fn,this);}

Promise._1 = noop;

Promise.prototype.then = function(onFulfilled,onRejected){
if(this.constructor !== Promise){
return safeThen(this,onFulfilled,onRejected);}

var res=new Promise(noop);
handle(this,new Handler(onFulfilled,onRejected,res));
return res;};


function safeThen(self,onFulfilled,onRejected){
return new self.constructor(function(resolve,reject){
var res=new Promise(noop);
res.then(resolve,reject);
handle(self,new Handler(onFulfilled,onRejected,res));});}

;
function handle(self,deferred){
while(self._41 === 3) {
self = self._86;}

if(self._41 === 0){
self._17.push(deferred);
return;}

setImmediate(function(){
var cb=self._41 === 1?deferred.onFulfilled:deferred.onRejected;
if(cb === null){
if(self._41 === 1){
resolve(deferred.promise,self._86);}else 
{
reject(deferred.promise,self._86);}

return;}

var ret=tryCallOne(cb,self._86);
if(ret === IS_ERROR){
reject(deferred.promise,LAST_ERROR);}else 
{
resolve(deferred.promise,ret);}});}



function resolve(self,newValue){

if(newValue === self){
return reject(
self,
new TypeError('A promise cannot be resolved with itself.'));}


if(
newValue && (
typeof newValue === 'object' || typeof newValue === 'function'))
{
var then=getThen(newValue);
if(then === IS_ERROR){
return reject(self,LAST_ERROR);}

if(
then === self.then && 
newValue instanceof Promise)
{
self._41 = 3;
self._86 = newValue;
finale(self);
return;}else 
if(typeof then === 'function'){
doResolve(then.bind(newValue),self);
return;}}


self._41 = 1;
self._86 = newValue;
finale(self);}


function reject(self,newValue){
self._41 = 2;
self._86 = newValue;
finale(self);}

function finale(self){
for(var i=0;i < self._17.length;i++) {
handle(self,self._17[i]);}

self._17 = null;}


function Handler(onFulfilled,onRejected,promise){
this.onFulfilled = typeof onFulfilled === 'function'?onFulfilled:null;
this.onRejected = typeof onRejected === 'function'?onRejected:null;
this.promise = promise;}








function doResolve(fn,promise){
var done=false;
var res=tryCallTwo(fn,function(value){
if(done)return;
done = true;
resolve(promise,value);},
function(reason){
if(done)return;
done = true;
reject(promise,reason);});

if(!done && res === IS_ERROR){
done = true;
reject(promise,LAST_ERROR);}}
});
__d('promise/setimmediate/done.js',["promise/setimmediate/core.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

var Promise=require('promise/setimmediate/core.js');

module.exports = Promise;
Promise.prototype.done = function(onFulfilled,onRejected){
var self=arguments.length?this.then.apply(this,arguments):this;
self.then(null,function(err){
setTimeout(function(){
throw err;},
0);});};
});
__d('SourceMap',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var 























scope={};
wrapper.call(scope);

module.exports = scope.sourceMap;

function wrapper(){














function define(moduleName,deps,payload){
if(typeof moduleName != "string"){
throw new TypeError("Expected string, got: " + moduleName);}


if(arguments.length == 2){
payload = deps;}


if(moduleName in define.modules){
throw new Error("Module already defined: " + moduleName);}

define.modules[moduleName] = payload;}
;




define.modules = {};










function Domain(){
this.modules = {};
this._currentModule = null;}


(function(){
















Domain.prototype.require = function(deps,callback){
if(Array.isArray(deps)){
var params=deps.map(function(dep){
return this.lookup(dep);},
this);
if(callback){
callback.apply(null,params);}

return undefined;}else 

{
return this.lookup(deps);}};



function normalize(path){
var bits=path.split("/");
var i=1;
while(i < bits.length) {
if(bits[i] === ".."){
bits.splice(i - 1,1);}else 
if(bits[i] === "."){
bits.splice(i,1);}else 
{
i++;}}


return bits.join("/");}


function join(a,b){
a = a.trim();
b = b.trim();
if(/^\//.test(b)){
return b;}else 
{
return a.replace(/\/*$/,"/") + b;}}



function dirname(path){
var bits=path.split("/");
bits.pop();
return bits.join("/");}








Domain.prototype.lookup = function(moduleName){
if(/^\./.test(moduleName)){
moduleName = normalize(join(dirname(this._currentModule),moduleName));}


if(moduleName in this.modules){
var module=this.modules[moduleName];
return module;}


if(!(moduleName in define.modules)){
throw new Error("Module not defined: " + moduleName);}


var module=define.modules[moduleName];

if(typeof module == "function"){
var exports={};
var previousModule=this._currentModule;
this._currentModule = moduleName;
module(this.require.bind(this),exports,{id:moduleName,uri:""});
this._currentModule = previousModule;
module = exports;}



this.modules[moduleName] = module;

return module;};})();




define.Domain = Domain;
define.globalDomain = new Domain();
var require=define.globalDomain.require.bind(define.globalDomain);






define("source-map/source-map-generator",["require","exports","module","source-map/base64-vlq","source-map/util","source-map/array-set"],function(require,exports,module){

var base64VLQ=require("./base64-vlq");
var util=require("./util");
var ArraySet=require("./array-set").ArraySet;









function SourceMapGenerator(aArgs){
this._file = util.getArg(aArgs,"file");
this._sourceRoot = util.getArg(aArgs,"sourceRoot",null);
this._sources = new ArraySet();
this._names = new ArraySet();
this._mappings = [];
this._sourcesContents = null;}


SourceMapGenerator.prototype._version = 3;






SourceMapGenerator.fromSourceMap = 
function SourceMapGenerator_fromSourceMap(aSourceMapConsumer){
var sourceRoot=aSourceMapConsumer.sourceRoot;
var generator=new SourceMapGenerator({
file:aSourceMapConsumer.file,
sourceRoot:sourceRoot});

aSourceMapConsumer.eachMapping(function(mapping){
var newMapping={
generated:{
line:mapping.generatedLine,
column:mapping.generatedColumn}};



if(mapping.source){
newMapping.source = mapping.source;
if(sourceRoot){
newMapping.source = util.relative(sourceRoot,newMapping.source);}


newMapping.original = {
line:mapping.originalLine,
column:mapping.originalColumn};


if(mapping.name){
newMapping.name = mapping.name;}}



generator.addMapping(newMapping);});

aSourceMapConsumer.sources.forEach(function(sourceFile){
var content=aSourceMapConsumer.sourceContentFor(sourceFile);
if(content){
generator.setSourceContent(sourceFile,content);}});


return generator;};












SourceMapGenerator.prototype.addMapping = 
function SourceMapGenerator_addMapping(aArgs){
var generated=util.getArg(aArgs,"generated");
var original=util.getArg(aArgs,"original",null);
var source=util.getArg(aArgs,"source",null);
var name=util.getArg(aArgs,"name",null);

this._validateMapping(generated,original,source,name);

if(source && !this._sources.has(source)){
this._sources.add(source);}


if(name && !this._names.has(name)){
this._names.add(name);}


this._mappings.push({
generatedLine:generated.line,
generatedColumn:generated.column,
originalLine:original != null && original.line,
originalColumn:original != null && original.column,
source:source,
name:name});};






SourceMapGenerator.prototype.setSourceContent = 
function SourceMapGenerator_setSourceContent(aSourceFile,aSourceContent){
var source=aSourceFile;
if(this._sourceRoot){
source = util.relative(this._sourceRoot,source);}


if(aSourceContent !== null){


if(!this._sourcesContents){
this._sourcesContents = {};}

this._sourcesContents[util.toSetString(source)] = aSourceContent;}else 
{


delete this._sourcesContents[util.toSetString(source)];
if(Object.keys(this._sourcesContents).length === 0){
this._sourcesContents = null;}}};














SourceMapGenerator.prototype.applySourceMap = 
function SourceMapGenerator_applySourceMap(aSourceMapConsumer,aSourceFile){

if(!aSourceFile){
aSourceFile = aSourceMapConsumer.file;}

var sourceRoot=this._sourceRoot;

if(sourceRoot){
aSourceFile = util.relative(sourceRoot,aSourceFile);}



var newSources=new ArraySet();
var newNames=new ArraySet();


this._mappings.forEach(function(mapping){
if(mapping.source === aSourceFile && mapping.originalLine){

var original=aSourceMapConsumer.originalPositionFor({
line:mapping.originalLine,
column:mapping.originalColumn});

if(original.source !== null){

if(sourceRoot){
mapping.source = util.relative(sourceRoot,original.source);}else 
{
mapping.source = original.source;}

mapping.originalLine = original.line;
mapping.originalColumn = original.column;
if(original.name !== null && mapping.name !== null){


mapping.name = original.name;}}}




var source=mapping.source;
if(source && !newSources.has(source)){
newSources.add(source);}


var name=mapping.name;
if(name && !newNames.has(name)){
newNames.add(name);}},


this);
this._sources = newSources;
this._names = newNames;


aSourceMapConsumer.sources.forEach(function(sourceFile){
var content=aSourceMapConsumer.sourceContentFor(sourceFile);
if(content){
if(sourceRoot){
sourceFile = util.relative(sourceRoot,sourceFile);}

this.setSourceContent(sourceFile,content);}},

this);};













SourceMapGenerator.prototype._validateMapping = 
function SourceMapGenerator_validateMapping(aGenerated,aOriginal,aSource,
aName){
if(aGenerated && "line" in aGenerated && "column" in aGenerated && 
aGenerated.line > 0 && aGenerated.column >= 0 && 
!aOriginal && !aSource && !aName){

return;}else 

if(aGenerated && "line" in aGenerated && "column" in aGenerated && 
aOriginal && "line" in aOriginal && "column" in aOriginal && 
aGenerated.line > 0 && aGenerated.column >= 0 && 
aOriginal.line > 0 && aOriginal.column >= 0 && 
aSource){

return;}else 

{
throw new Error("Invalid mapping: " + JSON.stringify({
generated:aGenerated,
source:aSource,
orginal:aOriginal,
name:aName}));}};








SourceMapGenerator.prototype._serializeMappings = 
function SourceMapGenerator_serializeMappings(){
var previousGeneratedColumn=0;
var previousGeneratedLine=1;
var previousOriginalColumn=0;
var previousOriginalLine=0;
var previousName=0;
var previousSource=0;
var result="";
var mapping;






this._mappings.sort(util.compareByGeneratedPositions);

for(var i=0,len=this._mappings.length;i < len;i++) {
mapping = this._mappings[i];

if(mapping.generatedLine !== previousGeneratedLine){
previousGeneratedColumn = 0;
while(mapping.generatedLine !== previousGeneratedLine) {
result += ";";
previousGeneratedLine++;}}else 


{
if(i > 0){
if(!util.compareByGeneratedPositions(mapping,this._mappings[i - 1])){
continue;}

result += ",";}}



result += base64VLQ.encode(mapping.generatedColumn - 
previousGeneratedColumn);
previousGeneratedColumn = mapping.generatedColumn;

if(mapping.source){
result += base64VLQ.encode(this._sources.indexOf(mapping.source) - 
previousSource);
previousSource = this._sources.indexOf(mapping.source);


result += base64VLQ.encode(mapping.originalLine - 1 - 
previousOriginalLine);
previousOriginalLine = mapping.originalLine - 1;

result += base64VLQ.encode(mapping.originalColumn - 
previousOriginalColumn);
previousOriginalColumn = mapping.originalColumn;

if(mapping.name){
result += base64VLQ.encode(this._names.indexOf(mapping.name) - 
previousName);
previousName = this._names.indexOf(mapping.name);}}}




return result;};


SourceMapGenerator.prototype._generateSourcesContent = 
function SourceMapGenerator_generateSourcesContent(aSources,aSourceRoot){
return aSources.map(function(source){
if(!this._sourcesContents){
return null;}

if(aSourceRoot){
source = util.relative(aSourceRoot,source);}

var key=util.toSetString(source);
return Object.prototype.hasOwnProperty.call(this._sourcesContents,
key)?
this._sourcesContents[key]:
null;},
this);};





SourceMapGenerator.prototype.toJSON = 
function SourceMapGenerator_toJSON(){
var map={
version:this._version,
file:this._file,
sources:this._sources.toArray(),
names:this._names.toArray(),
mappings:this._serializeMappings()};

if(this._sourceRoot){
map.sourceRoot = this._sourceRoot;}

if(this._sourcesContents){
map.sourcesContent = this._generateSourcesContent(map.sources,map.sourceRoot);}


return map;};





SourceMapGenerator.prototype.toString = 
function SourceMapGenerator_toString(){
return JSON.stringify(this);};


exports.SourceMapGenerator = SourceMapGenerator;});






































define("source-map/base64-vlq",["require","exports","module","source-map/base64"],function(require,exports,module){

var base64=require("./base64");













var VLQ_BASE_SHIFT=5;


var VLQ_BASE=1 << VLQ_BASE_SHIFT;


var VLQ_BASE_MASK=VLQ_BASE - 1;


var VLQ_CONTINUATION_BIT=VLQ_BASE;







function toVLQSigned(aValue){
return aValue < 0?
(-aValue << 1) + 1:
(aValue << 1) + 0;}








function fromVLQSigned(aValue){
var isNegative=(aValue & 1) === 1;
var shifted=aValue >> 1;
return isNegative?
-shifted:
shifted;}





exports.encode = function base64VLQ_encode(aValue){
var encoded="";
var digit;

var vlq=toVLQSigned(aValue);

do {
digit = vlq & VLQ_BASE_MASK;
vlq >>>= VLQ_BASE_SHIFT;
if(vlq > 0){


digit |= VLQ_CONTINUATION_BIT;}

encoded += base64.encode(digit);}while(
vlq > 0);

return encoded;};






exports.decode = function base64VLQ_decode(aStr){
var i=0;
var strLen=aStr.length;
var result=0;
var shift=0;
var continuation,digit;

do {
if(i >= strLen){
throw new Error("Expected more digits in base 64 VLQ value.");}

digit = base64.decode(aStr.charAt(i++));
continuation = !!(digit & VLQ_CONTINUATION_BIT);
digit &= VLQ_BASE_MASK;
result = result + (digit << shift);
shift += VLQ_BASE_SHIFT;}while(
continuation);

return {
value:fromVLQSigned(result),
rest:aStr.slice(i)};};});










define("source-map/base64",["require","exports","module"],function(require,exports,module){

var charToIntMap={};
var intToCharMap={};

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".
split("").
forEach(function(ch,index){
charToIntMap[ch] = index;
intToCharMap[index] = ch;});





exports.encode = function base64_encode(aNumber){
if(aNumber in intToCharMap){
return intToCharMap[aNumber];}

throw new TypeError("Must be between 0 and 63: " + aNumber);};





exports.decode = function base64_decode(aChar){
if(aChar in charToIntMap){
return charToIntMap[aChar];}

throw new TypeError("Not a valid base 64 digit: " + aChar);};});









define("source-map/util",["require","exports","module"],function(require,exports,module){











function getArg(aArgs,aName,aDefaultValue){
if(aName in aArgs){
return aArgs[aName];}else 
if(arguments.length === 3){
return aDefaultValue;}else 
{
throw new Error("\"" + aName + "\" is a required argument.");}}


exports.getArg = getArg;

var urlRegexp=/([\w+\-.]+):\/\/((\w+:\w+)@)?([\w.]+)?(:(\d+))?(\S+)?/;
var dataUrlRegexp=/^data:.+\,.+/;

function urlParse(aUrl){
var match=aUrl.match(urlRegexp);
if(!match){
return null;}

return {
scheme:match[1],
auth:match[3],
host:match[4],
port:match[6],
path:match[7]};}


exports.urlParse = urlParse;

function urlGenerate(aParsedUrl){
var url=aParsedUrl.scheme + "://";
if(aParsedUrl.auth){
url += aParsedUrl.auth + "@";}

if(aParsedUrl.host){
url += aParsedUrl.host;}

if(aParsedUrl.port){
url += ":" + aParsedUrl.port;}

if(aParsedUrl.path){
url += aParsedUrl.path;}

return url;}

exports.urlGenerate = urlGenerate;

function join(aRoot,aPath){
var url;

if(aPath.match(urlRegexp) || aPath.match(dataUrlRegexp)){
return aPath;}


if(aPath.charAt(0) === "/" && (url = urlParse(aRoot))){
url.path = aPath;
return urlGenerate(url);}


return aRoot.replace(/\/$/,"") + "/" + aPath;}

exports.join = join;










function toSetString(aStr){
return "$" + aStr;}

exports.toSetString = toSetString;

function fromSetString(aStr){
return aStr.substr(1);}

exports.fromSetString = fromSetString;

function relative(aRoot,aPath){
aRoot = aRoot.replace(/\/$/,"");

var url=urlParse(aRoot);
if(aPath.charAt(0) == "/" && url && url.path == "/"){
return aPath.slice(1);}


return aPath.indexOf(aRoot + "/") === 0?
aPath.substr(aRoot.length + 1):
aPath;}

exports.relative = relative;

function strcmp(aStr1,aStr2){
var s1=aStr1 || "";
var s2=aStr2 || "";
return (s1 > s2) - (s1 < s2);}










function compareByOriginalPositions(mappingA,mappingB,onlyCompareOriginal){
var cmp;

cmp = strcmp(mappingA.source,mappingB.source);
if(cmp){
return cmp;}


cmp = mappingA.originalLine - mappingB.originalLine;
if(cmp){
return cmp;}


cmp = mappingA.originalColumn - mappingB.originalColumn;
if(cmp || onlyCompareOriginal){
return cmp;}


cmp = strcmp(mappingA.name,mappingB.name);
if(cmp){
return cmp;}


cmp = mappingA.generatedLine - mappingB.generatedLine;
if(cmp){
return cmp;}


return mappingA.generatedColumn - mappingB.generatedColumn;}
;
exports.compareByOriginalPositions = compareByOriginalPositions;










function compareByGeneratedPositions(mappingA,mappingB,onlyCompareGenerated){
var cmp;

cmp = mappingA.generatedLine - mappingB.generatedLine;
if(cmp){
return cmp;}


cmp = mappingA.generatedColumn - mappingB.generatedColumn;
if(cmp || onlyCompareGenerated){
return cmp;}


cmp = strcmp(mappingA.source,mappingB.source);
if(cmp){
return cmp;}


cmp = mappingA.originalLine - mappingB.originalLine;
if(cmp){
return cmp;}


cmp = mappingA.originalColumn - mappingB.originalColumn;
if(cmp){
return cmp;}


return strcmp(mappingA.name,mappingB.name);}
;
exports.compareByGeneratedPositions = compareByGeneratedPositions;});








define("source-map/array-set",["require","exports","module","source-map/util"],function(require,exports,module){

var util=require("./util");







function ArraySet(){
this._array = [];
this._set = {};}





ArraySet.fromArray = function ArraySet_fromArray(aArray,aAllowDuplicates){
var set=new ArraySet();
for(var i=0,len=aArray.length;i < len;i++) {
set.add(aArray[i],aAllowDuplicates);}

return set;};







ArraySet.prototype.add = function ArraySet_add(aStr,aAllowDuplicates){
var isDuplicate=this.has(aStr);
var idx=this._array.length;
if(!isDuplicate || aAllowDuplicates){
this._array.push(aStr);}

if(!isDuplicate){
this._set[util.toSetString(aStr)] = idx;}};








ArraySet.prototype.has = function ArraySet_has(aStr){
return Object.prototype.hasOwnProperty.call(this._set,
util.toSetString(aStr));};







ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr){
if(this.has(aStr)){
return this._set[util.toSetString(aStr)];}

throw new Error("\"" + aStr + "\" is not in the set.");};







ArraySet.prototype.at = function ArraySet_at(aIdx){
if(aIdx >= 0 && aIdx < this._array.length){
return this._array[aIdx];}

throw new Error("No element indexed by " + aIdx);};







ArraySet.prototype.toArray = function ArraySet_toArray(){
return this._array.slice();};


exports.ArraySet = ArraySet;});








define("source-map/source-map-consumer",["require","exports","module","source-map/util","source-map/binary-search","source-map/array-set","source-map/base64-vlq"],function(require,exports,module){

var util=require("./util");
var binarySearch=require("./binary-search");
var ArraySet=require("./array-set").ArraySet;
var base64VLQ=require("./base64-vlq");































function SourceMapConsumer(aSourceMap){
var sourceMap=aSourceMap;
if(typeof aSourceMap === "string"){
sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/,""));}


var version=util.getArg(sourceMap,"version");
var sources=util.getArg(sourceMap,"sources");


var names=util.getArg(sourceMap,"names",[]);
var sourceRoot=util.getArg(sourceMap,"sourceRoot",null);
var sourcesContent=util.getArg(sourceMap,"sourcesContent",null);
var mappings=util.getArg(sourceMap,"mappings");
var file=util.getArg(sourceMap,"file",null);



if(version != this._version){
throw new Error("Unsupported version: " + version);}






this._names = ArraySet.fromArray(names,true);
this._sources = ArraySet.fromArray(sources,true);

this.sourceRoot = sourceRoot;
this.sourcesContent = sourcesContent;
this._mappings = mappings;
this.file = file;}









SourceMapConsumer.fromSourceMap = 
function SourceMapConsumer_fromSourceMap(aSourceMap){
var smc=Object.create(SourceMapConsumer.prototype);

smc._names = ArraySet.fromArray(aSourceMap._names.toArray(),true);
smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(),true);
smc.sourceRoot = aSourceMap._sourceRoot;
smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
smc.sourceRoot);
smc.file = aSourceMap._file;

smc.__generatedMappings = aSourceMap._mappings.slice().
sort(util.compareByGeneratedPositions);
smc.__originalMappings = aSourceMap._mappings.slice().
sort(util.compareByOriginalPositions);

return smc;};





SourceMapConsumer.prototype._version = 3;




Object.defineProperty(SourceMapConsumer.prototype,"sources",{
get:function(){
return this._sources.toArray().map(function(s){
return this.sourceRoot?util.join(this.sourceRoot,s):s;},
this);}});

































SourceMapConsumer.prototype.__generatedMappings = null;
Object.defineProperty(SourceMapConsumer.prototype,"_generatedMappings",{
get:function(){
if(!this.__generatedMappings){
this.__generatedMappings = [];
this.__originalMappings = [];
this._parseMappings(this._mappings,this.sourceRoot);}


return this.__generatedMappings;}});



SourceMapConsumer.prototype.__originalMappings = null;
Object.defineProperty(SourceMapConsumer.prototype,"_originalMappings",{
get:function(){
if(!this.__originalMappings){
this.__generatedMappings = [];
this.__originalMappings = [];
this._parseMappings(this._mappings,this.sourceRoot);}


return this.__originalMappings;}});








SourceMapConsumer.prototype._parseMappings = 
function SourceMapConsumer_parseMappings(aStr,aSourceRoot){
var generatedLine=1;
var previousGeneratedColumn=0;
var previousOriginalLine=0;
var previousOriginalColumn=0;
var previousSource=0;
var previousName=0;
var mappingSeparator=/^[,;]/;
var str=aStr;
var mapping;
var temp;

while(str.length > 0) {
if(str.charAt(0) === ";"){
generatedLine++;
str = str.slice(1);
previousGeneratedColumn = 0;}else 

if(str.charAt(0) === ","){
str = str.slice(1);}else 

{
mapping = {};
mapping.generatedLine = generatedLine;


temp = base64VLQ.decode(str);
mapping.generatedColumn = previousGeneratedColumn + temp.value;
previousGeneratedColumn = mapping.generatedColumn;
str = temp.rest;

if(str.length > 0 && !mappingSeparator.test(str.charAt(0))){

temp = base64VLQ.decode(str);
mapping.source = this._sources.at(previousSource + temp.value);
previousSource += temp.value;
str = temp.rest;
if(str.length === 0 || mappingSeparator.test(str.charAt(0))){
throw new Error("Found a source, but no line and column");}



temp = base64VLQ.decode(str);
mapping.originalLine = previousOriginalLine + temp.value;
previousOriginalLine = mapping.originalLine;

mapping.originalLine += 1;
str = temp.rest;
if(str.length === 0 || mappingSeparator.test(str.charAt(0))){
throw new Error("Found a source and line, but no column");}



temp = base64VLQ.decode(str);
mapping.originalColumn = previousOriginalColumn + temp.value;
previousOriginalColumn = mapping.originalColumn;
str = temp.rest;

if(str.length > 0 && !mappingSeparator.test(str.charAt(0))){

temp = base64VLQ.decode(str);
mapping.name = this._names.at(previousName + temp.value);
previousName += temp.value;
str = temp.rest;}}



this.__generatedMappings.push(mapping);
if(typeof mapping.originalLine === "number"){
this.__originalMappings.push(mapping);}}}




this.__originalMappings.sort(util.compareByOriginalPositions);};






SourceMapConsumer.prototype._findMapping = 
function SourceMapConsumer_findMapping(aNeedle,aMappings,aLineName,
aColumnName,aComparator){





if(aNeedle[aLineName] <= 0){
throw new TypeError("Line must be greater than or equal to 1, got " + 
aNeedle[aLineName]);}

if(aNeedle[aColumnName] < 0){
throw new TypeError("Column must be greater than or equal to 0, got " + 
aNeedle[aColumnName]);}


return binarySearch.search(aNeedle,aMappings,aComparator);};

















SourceMapConsumer.prototype.originalPositionFor = 
function SourceMapConsumer_originalPositionFor(aArgs){
var needle={
generatedLine:util.getArg(aArgs,"line"),
generatedColumn:util.getArg(aArgs,"column")};


var mapping=this._findMapping(needle,
this._generatedMappings,
"generatedLine",
"generatedColumn",
util.compareByGeneratedPositions);

if(mapping){
var source=util.getArg(mapping,"source",null);
if(source && this.sourceRoot){
source = util.join(this.sourceRoot,source);}

return {
source:source,
line:util.getArg(mapping,"originalLine",null),
column:util.getArg(mapping,"originalColumn",null),
name:util.getArg(mapping,"name",null)};}



return {
source:null,
line:null,
column:null,
name:null};};








SourceMapConsumer.prototype.sourceContentFor = 
function SourceMapConsumer_sourceContentFor(aSource){
if(!this.sourcesContent){
return null;}


if(this.sourceRoot){
aSource = util.relative(this.sourceRoot,aSource);}


if(this._sources.has(aSource)){
return this.sourcesContent[this._sources.indexOf(aSource)];}


var url;
if(this.sourceRoot && (
url = util.urlParse(this.sourceRoot))){




var fileUriAbsPath=aSource.replace(/^file:\/\//,"");
if(url.scheme == "file" && 
this._sources.has(fileUriAbsPath)){
return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];}


if((!url.path || url.path == "/") && 
this._sources.has("/" + aSource)){
return this.sourcesContent[this._sources.indexOf("/" + aSource)];}}



throw new Error("\"" + aSource + "\" is not in the SourceMap.");};
















SourceMapConsumer.prototype.generatedPositionFor = 
function SourceMapConsumer_generatedPositionFor(aArgs){
var needle={
source:util.getArg(aArgs,"source"),
originalLine:util.getArg(aArgs,"line"),
originalColumn:util.getArg(aArgs,"column")};


if(this.sourceRoot){
needle.source = util.relative(this.sourceRoot,needle.source);}


var mapping=this._findMapping(needle,
this._originalMappings,
"originalLine",
"originalColumn",
util.compareByOriginalPositions);

if(mapping){
return {
line:util.getArg(mapping,"generatedLine",null),
column:util.getArg(mapping,"generatedColumn",null)};}



return {
line:null,
column:null};};



SourceMapConsumer.GENERATED_ORDER = 1;
SourceMapConsumer.ORIGINAL_ORDER = 2;

















SourceMapConsumer.prototype.eachMapping = 
function SourceMapConsumer_eachMapping(aCallback,aContext,aOrder){
var context=aContext || null;
var order=aOrder || SourceMapConsumer.GENERATED_ORDER;

var mappings;
switch(order){
case SourceMapConsumer.GENERATED_ORDER:
mappings = this._generatedMappings;
break;
case SourceMapConsumer.ORIGINAL_ORDER:
mappings = this._originalMappings;
break;
default:
throw new Error("Unknown order of iteration.");}


var sourceRoot=this.sourceRoot;
mappings.map(function(mapping){
var source=mapping.source;
if(source && sourceRoot){
source = util.join(sourceRoot,source);}

return {
source:source,
generatedLine:mapping.generatedLine,
generatedColumn:mapping.generatedColumn,
originalLine:mapping.originalLine,
originalColumn:mapping.originalColumn,
name:mapping.name};}).

forEach(aCallback,context);};


exports.SourceMapConsumer = SourceMapConsumer;});








define("source-map/binary-search",["require","exports","module"],function(require,exports,module){










function recursiveSearch(aLow,aHigh,aNeedle,aHaystack,aCompare){










var mid=Math.floor((aHigh - aLow) / 2) + aLow;
var cmp=aCompare(aNeedle,aHaystack[mid],true);
if(cmp === 0){

return aHaystack[mid];}else 

if(cmp > 0){

if(aHigh - mid > 1){

return recursiveSearch(mid,aHigh,aNeedle,aHaystack,aCompare);}



return aHaystack[mid];}else 

{

if(mid - aLow > 1){

return recursiveSearch(aLow,mid,aNeedle,aHaystack,aCompare);}



return aLow < 0?
null:
aHaystack[aLow];}}
















exports.search = function search(aNeedle,aHaystack,aCompare){
return aHaystack.length > 0?
recursiveSearch(-1,aHaystack.length,aNeedle,aHaystack,aCompare):
null;};});









define("source-map/source-node",["require","exports","module","source-map/source-map-generator","source-map/util"],function(require,exports,module){

var SourceMapGenerator=require("./source-map-generator").SourceMapGenerator;
var util=require("./util");













function SourceNode(aLine,aColumn,aSource,aChunks,aName){
this.children = [];
this.sourceContents = {};
this.line = aLine === undefined?null:aLine;
this.column = aColumn === undefined?null:aColumn;
this.source = aSource === undefined?null:aSource;
this.name = aName === undefined?null:aName;
if(aChunks != null)this.add(aChunks);}








SourceNode.fromStringWithSourceMap = 
function SourceNode_fromStringWithSourceMap(aGeneratedCode,aSourceMapConsumer){


var node=new SourceNode();



var remainingLines=aGeneratedCode.split("\n");


var lastGeneratedLine=1,lastGeneratedColumn=0;




var lastMapping=null;

aSourceMapConsumer.eachMapping(function(mapping){
if(lastMapping === null){



while(lastGeneratedLine < mapping.generatedLine) {
node.add(remainingLines.shift() + "\n");
lastGeneratedLine++;}

if(lastGeneratedColumn < mapping.generatedColumn){
var nextLine=remainingLines[0];
node.add(nextLine.substr(0,mapping.generatedColumn));
remainingLines[0] = nextLine.substr(mapping.generatedColumn);
lastGeneratedColumn = mapping.generatedColumn;}}else 

{


if(lastGeneratedLine < mapping.generatedLine){
var code="";

do {
code += remainingLines.shift() + "\n";
lastGeneratedLine++;
lastGeneratedColumn = 0;}while(
lastGeneratedLine < mapping.generatedLine);


if(lastGeneratedColumn < mapping.generatedColumn){
var nextLine=remainingLines[0];
code += nextLine.substr(0,mapping.generatedColumn);
remainingLines[0] = nextLine.substr(mapping.generatedColumn);
lastGeneratedColumn = mapping.generatedColumn;}


addMappingWithCode(lastMapping,code);}else 
{



var nextLine=remainingLines[0];
var code=nextLine.substr(0,mapping.generatedColumn - 
lastGeneratedColumn);
remainingLines[0] = nextLine.substr(mapping.generatedColumn - 
lastGeneratedColumn);
lastGeneratedColumn = mapping.generatedColumn;
addMappingWithCode(lastMapping,code);}}


lastMapping = mapping;},
this);



addMappingWithCode(lastMapping,remainingLines.join("\n"));


aSourceMapConsumer.sources.forEach(function(sourceFile){
var content=aSourceMapConsumer.sourceContentFor(sourceFile);
if(content){
node.setSourceContent(sourceFile,content);}});



return node;

function addMappingWithCode(mapping,code){
if(mapping === null || mapping.source === undefined){
node.add(code);}else 
{
node.add(new SourceNode(mapping.originalLine,
mapping.originalColumn,
mapping.source,
code,
mapping.name));}}};










SourceNode.prototype.add = function SourceNode_add(aChunk){
if(Array.isArray(aChunk)){
aChunk.forEach(function(chunk){
this.add(chunk);},
this);}else 

if(aChunk instanceof SourceNode || typeof aChunk === "string"){
if(aChunk){
this.children.push(aChunk);}}else 


{
throw new TypeError(
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);}


return this;};








SourceNode.prototype.prepend = function SourceNode_prepend(aChunk){
if(Array.isArray(aChunk)){
for(var i=aChunk.length - 1;i >= 0;i--) {
this.prepend(aChunk[i]);}}else 


if(aChunk instanceof SourceNode || typeof aChunk === "string"){
this.children.unshift(aChunk);}else 

{
throw new TypeError(
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);}


return this;};









SourceNode.prototype.walk = function SourceNode_walk(aFn){
var chunk;
for(var i=0,len=this.children.length;i < len;i++) {
chunk = this.children[i];
if(chunk instanceof SourceNode){
chunk.walk(aFn);}else 

{
if(chunk !== ""){
aFn(chunk,{source:this.source,
line:this.line,
column:this.column,
name:this.name});}}}};











SourceNode.prototype.join = function SourceNode_join(aSep){
var newChildren;
var i;
var len=this.children.length;
if(len > 0){
newChildren = [];
for(i = 0;i < len - 1;i++) {
newChildren.push(this.children[i]);
newChildren.push(aSep);}

newChildren.push(this.children[i]);
this.children = newChildren;}

return this;};









SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern,aReplacement){
var lastChild=this.children[this.children.length - 1];
if(lastChild instanceof SourceNode){
lastChild.replaceRight(aPattern,aReplacement);}else 

if(typeof lastChild === "string"){
this.children[this.children.length - 1] = lastChild.replace(aPattern,aReplacement);}else 

{
this.children.push("".replace(aPattern,aReplacement));}

return this;};









SourceNode.prototype.setSourceContent = 
function SourceNode_setSourceContent(aSourceFile,aSourceContent){
this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;};








SourceNode.prototype.walkSourceContents = 
function SourceNode_walkSourceContents(aFn){
for(var i=0,len=this.children.length;i < len;i++) {
if(this.children[i] instanceof SourceNode){
this.children[i].walkSourceContents(aFn);}}



var sources=Object.keys(this.sourceContents);
for(var i=0,len=sources.length;i < len;i++) {
aFn(util.fromSetString(sources[i]),this.sourceContents[sources[i]]);}};







SourceNode.prototype.toString = function SourceNode_toString(){
var str="";
this.walk(function(chunk){
str += chunk;});

return str;};






SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs){
var generated={
code:"",
line:1,
column:0};

var map=new SourceMapGenerator(aArgs);
var sourceMappingActive=false;
var lastOriginalSource=null;
var lastOriginalLine=null;
var lastOriginalColumn=null;
var lastOriginalName=null;
this.walk(function(chunk,original){
generated.code += chunk;
if(original.source !== null && 
original.line !== null && 
original.column !== null){
if(lastOriginalSource !== original.source || 
lastOriginalLine !== original.line || 
lastOriginalColumn !== original.column || 
lastOriginalName !== original.name){
map.addMapping({
source:original.source,
original:{
line:original.line,
column:original.column},

generated:{
line:generated.line,
column:generated.column},

name:original.name});}


lastOriginalSource = original.source;
lastOriginalLine = original.line;
lastOriginalColumn = original.column;
lastOriginalName = original.name;
sourceMappingActive = true;}else 
if(sourceMappingActive){
map.addMapping({
generated:{
line:generated.line,
column:generated.column}});


lastOriginalSource = null;
sourceMappingActive = false;}

chunk.split("").forEach(function(ch){
if(ch === "\n"){
generated.line++;
generated.column = 0;}else 
{
generated.column++;}});});



this.walkSourceContents(function(sourceFile,sourceContent){
map.setSourceContent(sourceFile,sourceContent);});


return {code:generated.code,map:map};};


exports.SourceNode = SourceNode;});





this.sourceMap = {
SourceMapConsumer:require("source-map/source-map-consumer").SourceMapConsumer,
SourceMapGenerator:require("source-map/source-map-generator").SourceMapGenerator,
SourceNode:require("source-map/source-node").SourceNode};}
});
__d('react-native/Libraries/JavaScriptAppEngine/Initialization/source-map-url.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  (














function(){
var define=null;




void (function(root,factory){
if(typeof define === "function" && define.amd){
define(factory);}else 
if(typeof exports === "object"){
module.exports = factory();}else 
{
root.sourceMappingURL = factory();}})(

this,function(){

var innerRegex=/[#@] sourceMappingURL=([^\s'"]*)/;

var regex=RegExp(
"(?:" + 
"/\\*" + 
"(?:\\s*\r?\n(?://)?)?" + 
"(?:" + innerRegex.source + ")" + 
"\\s*" + 
"\\*/" + 
"|" + 
"//(?:" + innerRegex.source + ")" + 
")" + 
"\\s*$");


return {

regex:regex,
_innerRegex:innerRegex,

getFrom:function(code){
var match=code.match(regex);
return match?match[1] || match[2] || "":null;},


existsIn:function(code){
return regex.test(code);},


removeFrom:function(code){
return code.replace(regex,"");},


insertBefore:function(code,string){
var match=code.match(regex);
if(match){
return code.slice(0,match.index) + string + code.slice(match.index);}else 
{
return code + string;}}};});})();
});
__d('parseErrorStack',["stacktrace-parser/index.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';











var stacktraceParser=require('stacktrace-parser/index.js');

function resolveSourceMaps(sourceMapInstance,stackFrame){
try{
var orig=sourceMapInstance.originalPositionFor({
line:stackFrame.lineNumber,
column:stackFrame.column});

if(orig){
stackFrame.file = orig.source;
stackFrame.lineNumber = orig.line;
stackFrame.column = orig.column;}}

catch(innerEx) {}}



function parseErrorStack(e,sourceMapInstance){
if(!e || !e.stack){
return [];}


var stack=stacktraceParser.parse(e.stack);

var framesToPop=e.framesToPop || 0;
while(framesToPop--) {
stack.shift();}


if(sourceMapInstance){
stack.forEach(resolveSourceMaps.bind(null,sourceMapInstance));}


return stack;}


module.exports = parseErrorStack;
});
__d('stacktrace-parser/index.js',["stacktrace-parser/lib/stacktrace-parser.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  module.exports = require('stacktrace-parser/lib/stacktrace-parser.js');
});
__d('stacktrace-parser/lib/stacktrace-parser.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var 

UNKNOWN_FUNCTION='<unknown>';

var StackTraceParser={




parse:function(stackString){
var chrome=/^\s*at (?:(?:(?:Anonymous function)?|((?:\[object object\])?\S+(?: \[as \S+\])?)) )?\(?((?:file|http|https):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
gecko=/^(?:\s*(\S*)(?:\((.*?)\))?@)?((?:\w).*?):(\d+)(?::(\d+))?\s*$/i,
node=/^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i,
lines=stackString.split('\n'),
stack=[],
parts,
element;

for(var i=0,j=lines.length;i < j;++i) {
if(parts = gecko.exec(lines[i])){
element = {
'file':parts[3],
'methodName':parts[1] || UNKNOWN_FUNCTION,
'lineNumber':+parts[4],
'column':parts[5]?+parts[5]:null};}else 

if(parts = chrome.exec(lines[i])){
element = {
'file':parts[2],
'methodName':parts[1] || UNKNOWN_FUNCTION,
'lineNumber':+parts[3],
'column':parts[4]?+parts[4]:null};}else 

if(parts = node.exec(lines[i])){
element = {
'file':parts[2],
'methodName':parts[1] || UNKNOWN_FUNCTION,
'lineNumber':+parts[3],
'column':parts[4]?+parts[4]:null};}else 

{
continue;}


stack.push(element);}


return stack;}};




module.exports = StackTraceParser;
});
__d('Platform',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var Platform={
OS:'ios'};


module.exports = Platform;
});
__d('XMLHttpRequest',["FormData","NativeModules","RCTDeviceEventEmitter","XMLHttpRequestBase"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var FormData=require('FormData');
var RCTNetworking=require('NativeModules').Networking;
var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');

var XMLHttpRequestBase=require('XMLHttpRequestBase');var 

XMLHttpRequest=(function(_XMLHttpRequestBase){_inherits(XMLHttpRequest,_XMLHttpRequestBase);




function XMLHttpRequest(){_classCallCheck(this,XMLHttpRequest);
_get(Object.getPrototypeOf(XMLHttpRequest.prototype),'constructor',this).call(this);
this._requestId = null;
this._subscriptions = [];}_createClass(XMLHttpRequest,[{key:'_didCreateRequest',value:


function _didCreateRequest(requestId){var _this=this;
this._requestId = requestId;
this._subscriptions.push(RCTDeviceEventEmitter.addListener(
'didReceiveNetworkResponse',
function(args){return _this._didReceiveResponse.call(_this,args[0],args[1],args[2]);}));

this._subscriptions.push(RCTDeviceEventEmitter.addListener(
'didReceiveNetworkData',
function(args){return _this._didReceiveData.call(_this,args[0],args[1]);}));

this._subscriptions.push(RCTDeviceEventEmitter.addListener(
'didCompleteNetworkResponse',
function(args){return _this._didCompleteResponse.call(_this,args[0],args[1]);}));}},{key:'_didReceiveResponse',value:



function _didReceiveResponse(requestId,status,responseHeaders){
if(requestId === this._requestId){
this.status = status;
this.setResponseHeaders(responseHeaders);
this.setReadyState(this.HEADERS_RECEIVED);}}},{key:'_didReceiveData',value:



function _didReceiveData(requestId,responseText){
if(requestId === this._requestId){
if(!this.responseText){
this.responseText = responseText;}else 
{
this.responseText += responseText;}

this.setReadyState(this.LOADING);}}},{key:'_didCompleteResponse',value:



function _didCompleteResponse(requestId,error){
if(requestId === this._requestId){
if(error){
this.responseText = error;}

this._clearSubscriptions();
this._requestId = null;
this.setReadyState(this.DONE);}}},{key:'_clearSubscriptions',value:



function _clearSubscriptions(){
for(var i=0;i < this._subscriptions.length;i++) {
var sub=this._subscriptions[i];
sub.remove();}

this._subscriptions = [];}},{key:'sendImpl',value:


function sendImpl(method,url,headers,data){
if(typeof data === 'string'){
data = {string:data};}

if(data instanceof FormData){
data = {formData:data.getParts()};}

RCTNetworking.sendRequest(
{
method:method,
url:url,
data:data,
headers:headers,
incrementalUpdates:this.onreadystatechange?true:false},

this._didCreateRequest.bind(this));}},{key:'abortImpl',value:



function abortImpl(){
if(this._requestId){
RCTNetworking.cancelRequest(this._requestId);
this._clearSubscriptions();
this._requestId = null;}}}]);return XMLHttpRequest;})(XMLHttpRequestBase);




module.exports = XMLHttpRequest;
});
__d('FormData',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _slicedToArray=(function(){function sliceIterator(arr,i){var _arr=[];var _n=true;var _d=false;var _e=undefined;try{for(var _i=arr[Symbol.iterator](),_s;!(_n = (_s = _i.next()).done);_n = true) {_arr.push(_s.value);if(i && _arr.length === i)break;}}catch(err) {_d = true;_e = err;}finally {try{if(!_n && _i['return'])_i['return']();}finally {if(_d)throw _e;}}return _arr;}return function(arr,i){if(Array.isArray(arr)){return arr;}else if(Symbol.iterator in Object(arr)){return sliceIterator(arr,i);}else {throw new TypeError('Invalid attempt to destructure non-iterable instance');}};})();var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};var _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');}}var 



















FormData=(function(){



function FormData(){_classCallCheck(this,FormData);
this._parts = [];
this._partsByKey = {};}_createClass(FormData,[{key:'append',value:


function append(key,value){
var parts=this._partsByKey[key];
if(parts){




parts[1] = value;
return;}

parts = [key,value];
this._parts.push(parts);
this._partsByKey[key] = parts;}},{key:'getParts',value:


function getParts(){
return this._parts.map(function(_ref){var _ref2=_slicedToArray(_ref,2);var name=_ref2[0];var value=_ref2[1];
if(typeof value === 'string'){
return {
string:value,
headers:{
'content-disposition':'form-data; name="' + name + '"'}};}



var contentDisposition='form-data; name="' + name + '"';
if(typeof value.name === 'string'){
contentDisposition += '; filename="' + value.name + '"';}

return _extends({},
value,{
headers:{'content-disposition':contentDisposition}});});}}]);return FormData;})();





module.exports = FormData;
});
__d('XMLHttpRequestBase',[],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}var 















XMLHttpRequestBase=(function(){






















function XMLHttpRequestBase(){_classCallCheck(this,XMLHttpRequestBase);
this.UNSENT = 0;
this.OPENED = 1;
this.HEADERS_RECEIVED = 2;
this.LOADING = 3;
this.DONE = 4;

this.onreadystatechange = null;
this.onload = null;
this.upload = undefined;

this._reset();
this._method = null;
this._url = null;
this._aborted = false;}_createClass(XMLHttpRequestBase,[{key:'_reset',value:


function _reset(){
this.readyState = this.UNSENT;
this.responseHeaders = undefined;
this.responseText = '';
this.status = 0;

this._headers = {};
this._sent = false;
this._lowerCaseResponseHeaders = {};}},{key:'getAllResponseHeaders',value:


function getAllResponseHeaders(){
if(!this.responseHeaders){

return null;}

var headers=this.responseHeaders || {};
return Object.keys(headers).map(function(headerName){
return headerName + ': ' + headers[headerName];}).
join('\n');}},{key:'getResponseHeader',value:


function getResponseHeader(header){
var value=this._lowerCaseResponseHeaders[header.toLowerCase()];
return value !== undefined?value:null;}},{key:'setRequestHeader',value:


function setRequestHeader(header,value){
if(this.readyState !== this.OPENED){
throw new Error('Request has not been opened');}

this._headers[header.toLowerCase()] = value;}},{key:'open',value:


function open(method,url,async){

if(this.readyState !== this.UNSENT){
throw new Error('Cannot open, already sending');}

if(async !== undefined && !async){

throw new Error('Synchronous http requests are not supported');}

this._reset();
this._method = method;
this._url = url;
this._aborted = false;
this.setReadyState(this.OPENED);}},{key:'sendImpl',value:


function sendImpl(method,url,headers,data){
throw new Error('Subclass must define sendImpl method');}},{key:'abortImpl',value:


function abortImpl(){
throw new Error('Subclass must define abortImpl method');}},{key:'send',value:


function send(data){
if(this.readyState !== this.OPENED){
throw new Error('Request has not been opened');}

if(this._sent){
throw new Error('Request has already been sent');}

this._sent = true;
this.sendImpl(this._method,this._url,this._headers,data);}},{key:'abort',value:


function abort(){
this._aborted = true;
this.abortImpl();


if(!(this.readyState === this.UNSENT || 
this.readyState === this.OPENED && !this._sent || 
this.readyState === this.DONE)){
this._reset();
this.setReadyState(this.DONE);}


this._reset();}},{key:'callback',value:


function callback(status,responseHeaders,responseText){
if(this._aborted){
return;}

this.status = status;
this.setResponseHeaders(responseHeaders || {});
this.responseText = responseText;
this.setReadyState(this.DONE);}},{key:'setResponseHeaders',value:


function setResponseHeaders(responseHeaders){
this.responseHeaders = responseHeaders || null;
var headers=responseHeaders || {};
this._lowerCaseResponseHeaders = 
Object.keys(headers).reduce(function(lcaseHeaders,headerName){
lcaseHeaders[headerName.toLowerCase()] = headers[headerName];
return headers;},
{});}},{key:'setReadyState',value:


function setReadyState(newState){
this.readyState = newState;

var onreadystatechange=this.onreadystatechange;
if(onreadystatechange){


onreadystatechange(null);}

if(newState === this.DONE && !this._aborted){
this._sendLoad();}}},{key:'_sendLoad',value:



function _sendLoad(){

var onload=this.onload;
if(onload){


onload(null);}}}]);return XMLHttpRequestBase;})();




module.exports = XMLHttpRequestBase;
});
__d('fetch',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';
















var self={};

























(function(){
'use strict';

if(self.fetch){
return;}


function normalizeName(name){
if(typeof name !== 'string'){
name = name.toString();}

if(/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)){
throw new TypeError('Invalid character in header field name');}

return name.toLowerCase();}


function normalizeValue(value){
if(typeof value !== 'string'){
value = value.toString();}

return value;}


function Headers(headers){
this.map = {};

var self=this;
if(headers instanceof Headers){
headers.forEach(function(name,values){
values.forEach(function(value){
self.append(name,value);});});}else 



if(headers){
Object.getOwnPropertyNames(headers).forEach(function(name){
self.append(name,headers[name]);});}}




Headers.prototype.append = function(name,value){
name = normalizeName(name);
value = normalizeValue(value);
var list=this.map[name];
if(!list){
list = [];
this.map[name] = list;}

list.push(value);};


Headers.prototype['delete'] = function(name){
delete this.map[normalizeName(name)];};


Headers.prototype.get = function(name){
var values=this.map[normalizeName(name)];
return values?values[0]:null;};


Headers.prototype.getAll = function(name){
return this.map[normalizeName(name)] || [];};


Headers.prototype.has = function(name){
return this.map.hasOwnProperty(normalizeName(name));};


Headers.prototype.set = function(name,value){
this.map[normalizeName(name)] = [normalizeValue(value)];};



Headers.prototype.forEach = function(callback){
var self=this;
Object.getOwnPropertyNames(this.map).forEach(function(name){
callback(name,self.map[name]);});};



function consumed(body){
if(body.bodyUsed){
return Promise.reject(new TypeError('Already read'));}

body.bodyUsed = true;}


function fileReaderReady(reader){
return new Promise(function(resolve,reject){
reader.onload = function(){
resolve(reader.result);};

reader.onerror = function(){
reject(reader.error);};});}




function readBlobAsArrayBuffer(blob){
var reader=new FileReader();
reader.readAsArrayBuffer(blob);
return fileReaderReady(reader);}


function readBlobAsText(blob){
var reader=new FileReader();
reader.readAsText(blob);
return fileReaderReady(reader);}


var support={
blob:'FileReader' in self && 'Blob' in self && (function(){
try{
new Blob();
return true;}
catch(e) {
return false;}})(),


formData:'FormData' in self};


function Body(){
this.bodyUsed = false;


this._initBody = function(body){
this._bodyInit = body;
if(typeof body === 'string'){
this._bodyText = body;}else 
if(support.blob && Blob.prototype.isPrototypeOf(body)){
this._bodyBlob = body;}else 
if(support.formData && FormData.prototype.isPrototypeOf(body)){
this._bodyFormData = body;}else 
if(!body){
this._bodyText = '';}else 
{
throw new Error('unsupported BodyInit type');}};



if(support.blob){
this.blob = function(){
var rejected=consumed(this);
if(rejected){
return rejected;}


if(this._bodyBlob){
return Promise.resolve(this._bodyBlob);}else 
if(this._bodyFormData){
throw new Error('could not read FormData body as blob');}else 
{
return Promise.resolve(new Blob([this._bodyText]));}};



this.arrayBuffer = function(){
return this.blob().then(readBlobAsArrayBuffer);};


this.text = function(){
var rejected=consumed(this);
if(rejected){
return rejected;}


if(this._bodyBlob){
return readBlobAsText(this._bodyBlob);}else 
if(this._bodyFormData){
throw new Error('could not read FormData body as text');}else 
{
return Promise.resolve(this._bodyText);}};}else 


{
this.text = function(){
var rejected=consumed(this);
return rejected?rejected:Promise.resolve(this._bodyText);};}



if(support.formData){
this.formData = function(){
return this.text().then(decode);};}



this.json = function(){
return this.text().then(JSON.parse);};


return this;}



var methods=['DELETE','GET','HEAD','OPTIONS','POST','PUT'];

function normalizeMethod(method){
var upcased=method.toUpperCase();
return methods.indexOf(upcased) > -1?upcased:method;}


function Request(url,options){
options = options || {};
this.url = url;

this.credentials = options.credentials || 'omit';
this.headers = new Headers(options.headers);
this.method = normalizeMethod(options.method || 'GET');
this.mode = options.mode || null;
this.referrer = null;

if((this.method === 'GET' || this.method === 'HEAD') && options.body){
throw new TypeError('Body not allowed for GET or HEAD requests');}

this._initBody(options.body);}


function decode(body){
var form=new FormData();
body.trim().split('&').forEach(function(bytes){
if(bytes){
var split=bytes.split('=');
var name=split.shift().replace(/\+/g,' ');
var value=split.join('=').replace(/\+/g,' ');
form.append(decodeURIComponent(name),decodeURIComponent(value));}});


return form;}


function headers(xhr){
var head=new Headers();
var pairs=xhr.getAllResponseHeaders().trim().split('\n');
pairs.forEach(function(header){
var split=header.trim().split(':');
var key=split.shift().trim();
var value=split.join(':').trim();
head.append(key,value);});

return head;}


Body.call(Request.prototype);

function Response(bodyInit,options){
if(!options){
options = {};}


this._initBody(bodyInit);
this.type = 'default';
this.url = null;
this.status = options.status;
this.ok = this.status >= 200 && this.status < 300;
this.statusText = options.statusText;
this.headers = options.headers instanceof Headers?options.headers:new Headers(options.headers);
this.url = options.url || '';}


Body.call(Response.prototype);

self.Headers = Headers;
self.Request = Request;
self.Response = Response;

self.fetch = function(input,init){

var request;
if(Request.prototype.isPrototypeOf(input) && !init){
request = input;}else 
{
request = new Request(input,init);}


return new Promise(function(resolve,reject){
var xhr=new XMLHttpRequest();
if(request.credentials === 'cors'){
xhr.withCredentials = true;}


function responseURL(){
if('responseURL' in xhr){
return xhr.responseURL;}



if(/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())){
return xhr.getResponseHeader('X-Request-URL');}


return;}


xhr.onload = function(){
var status=xhr.status === 1223?204:xhr.status;
if(status < 100 || status > 599){
reject(new TypeError('Network request failed'));
return;}

var options={
status:status,
statusText:xhr.statusText,
headers:headers(xhr),
url:responseURL()};

var body='response' in xhr?xhr.response:xhr.responseText;
resolve(new Response(body,options));};


xhr.onerror = function(){
reject(new TypeError('Network request failed'));};


xhr.open(request.method,request.url,true);

if('responseType' in xhr && support.blob){
xhr.responseType = 'blob';}


request.headers.forEach(function(name,values){
values.forEach(function(value){
xhr.setRequestHeader(name,value);});});



xhr.send(typeof request._bodyInit === 'undefined'?null:request._bodyInit);});};


self.fetch.polyfill = true;})();




module.exports = self;
});
__d('Geolocation',["RCTDeviceEventEmitter","NativeModules","invariant","logError","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');
var RCTLocationObserver=require('NativeModules').LocationObserver;

var invariant=require('invariant');
var logError=require('logError');
var warning=require('warning');

var subscriptions=[];

var updatesEnabled=false;















var Geolocation={





getCurrentPosition:function(
geo_success,
geo_error,
geo_options)
{
invariant(
typeof geo_success === 'function',
'Must provide a valid geo_success callback.');

RCTLocationObserver.getCurrentPosition(
geo_options || {},
geo_success,
geo_error || logError);},







watchPosition:function(success,error,options){
if(!updatesEnabled){
RCTLocationObserver.startObserving(options || {});
updatesEnabled = true;}

var watchID=subscriptions.length;
subscriptions.push([
RCTDeviceEventEmitter.addListener(
'geolocationDidChange',
success),

error?RCTDeviceEventEmitter.addListener(
'geolocationError',
error):
null]);

return watchID;},


clearWatch:function(watchID){
var sub=subscriptions[watchID];
if(!sub){


return;}


sub[0].remove();

var sub1=sub[1];sub1 && sub1.remove();
subscriptions[watchID] = undefined;
var noWatchers=true;
for(var ii=0;ii < subscriptions.length;ii++) {
if(subscriptions[ii]){
noWatchers = false;}}


if(noWatchers){
Geolocation.stopObserving();}},



stopObserving:function(){
if(updatesEnabled){
RCTLocationObserver.stopObserving();
updatesEnabled = false;
for(var ii=0;ii < subscriptions.length;ii++) {
var sub=subscriptions[ii];
if(sub){
warning('Called stopObserving with existing subscriptions.');
sub[0].remove();

var sub1=sub[1];sub1 && sub1.remove();}}


subscriptions = [];}}};




module.exports = Geolocation;
});
__d('logError',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

















var logError=function(){
if(arguments.length === 1 && arguments[0] instanceof Error){
var err=arguments[0];
console.error('Error: "' + err.message + '".  Stack:\n' + err.stack);}else 
{
console.error.apply(console,arguments);}};



module.exports = logError;
});
__d('WebSocket',["RCTDeviceEventEmitter","NativeModules","WebSocketBase"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');
var RCTWebSocketManager=require('NativeModules').WebSocketManager;

var WebSocketBase=require('WebSocketBase');

var WebSocketId=0;var 

WebSocket=(function(_WebSocketBase){_inherits(WebSocket,_WebSocketBase);function WebSocket(){_classCallCheck(this,WebSocket);_get(Object.getPrototypeOf(WebSocket.prototype),'constructor',this).apply(this,arguments);}_createClass(WebSocket,[{key:'connectToSocketImpl',value:



function connectToSocketImpl(url){
this._socketId = WebSocketId++;
RCTWebSocketManager.connect(url,this._socketId);
this._registerEvents(this._socketId);}},{key:'closeConnectionImpl',value:


function closeConnectionImpl(){
RCTWebSocketManager.close(this._socketId);}},{key:'cancelConnectionImpl',value:


function cancelConnectionImpl(){
RCTWebSocketManager.close(this._socketId);}},{key:'sendStringImpl',value:


function sendStringImpl(message){
RCTWebSocketManager.send(message,this._socketId);}},{key:'sendArrayBufferImpl',value:


function sendArrayBufferImpl(){

console.warn('Sending ArrayBuffers is not yet supported');}},{key:'_unregisterEvents',value:


function _unregisterEvents(){
this._subs.forEach(function(e){return e.remove();});
this._subs = [];}},{key:'_registerEvents',value:


function _registerEvents(id){
this._subs = [
RCTDeviceEventEmitter.addListener(
'websocketMessage',
(function(ev){
if(ev.id !== id){
return;}

this.onmessage && this.onmessage({
data:ev.data});}).

bind(this)),

RCTDeviceEventEmitter.addListener(
'websocketOpen',
(function(ev){
if(ev.id !== id){
return;}

this.readyState = this.OPEN;
this.onopen && this.onopen();}).
bind(this)),

RCTDeviceEventEmitter.addListener(
'websocketClosed',
(function(ev){
if(ev.id !== id){
return;}

this.readyState = this.CLOSED;
this.onclose && this.onclose(ev);
this._unregisterEvents();
RCTWebSocketManager.close(id);}).
bind(this)),

RCTDeviceEventEmitter.addListener(
'websocketFailed',
(function(ev){
if(ev.id !== id){
return;}

this.onerror && this.onerror(new Error(ev.message));
this._unregisterEvents();
RCTWebSocketManager.close(id);}).
bind(this))];}}]);return WebSocket;})(WebSocketBase);






module.exports = WebSocket;
});
__d('WebSocketBase',[],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}var 















WebSocketBase=(function(){

















function WebSocketBase(url,protocols){_classCallCheck(this,WebSocketBase);
this.CONNECTING = 0;
this.OPEN = 1;
this.CLOSING = 2;
this.CLOSED = 3;

if(!protocols){
protocols = [];}


this.connectToSocketImpl(url);}_createClass(WebSocketBase,[{key:'close',value:


function close(){
if(this.readyState === WebSocketBase.CLOSING || 
this.readyState === WebSocketBase.CLOSED){
return;}


if(this.readyState === WebSocketBase.CONNECTING){
this.cancelConnectionImpl();}


this.closeConnectionImpl();}},{key:'send',value:


function send(data){
if(this.readyState === WebSocketBase.CONNECTING){
throw new Error('INVALID_STATE_ERR');}


if(typeof data === 'string'){
this.sendStringImpl(data);}else 
if(data instanceof ArrayBuffer){
this.sendArrayBufferImpl(data);}else 
{
throw new Error('Not supported data type');}}},{key:'closeConnectionImpl',value:



function closeConnectionImpl(){
throw new Error('Subclass must define closeConnectionImpl method');}},{key:'connectToSocketImpl',value:


function connectToSocketImpl(){
throw new Error('Subclass must define connectToSocketImpl method');}},{key:'cancelConnectionImpl',value:


function cancelConnectionImpl(){
throw new Error('Subclass must define cancelConnectionImpl method');}},{key:'sendStringImpl',value:


function sendStringImpl(){
throw new Error('Subclass must define sendStringImpl method');}},{key:'sendArrayBufferImpl',value:


function sendArrayBufferImpl(){
throw new Error('Subclass must define sendArrayBufferImpl method');}}]);return WebSocketBase;})();




module.exports = WebSocketBase;
});
__d('EventPluginHub',["EventPluginRegistry","EventPluginUtils","accumulateInto","forEachAccumulated","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventPluginRegistry=require('EventPluginRegistry');
var EventPluginUtils=require('EventPluginUtils');

var accumulateInto=require('accumulateInto');
var forEachAccumulated=require('forEachAccumulated');
var invariant=require('invariant');




var listenerBank={};





var eventQueue=null;







var executeDispatchesAndRelease=function(event){
if(event){
var executeDispatch=EventPluginUtils.executeDispatch;

var PluginModule=EventPluginRegistry.getPluginModuleForEvent(event);
if(PluginModule && PluginModule.executeDispatch){
executeDispatch = PluginModule.executeDispatch;}

EventPluginUtils.executeDispatchesInOrder(event,executeDispatch);

if(!event.isPersistent()){
event.constructor.release(event);}}};








var InstanceHandle=null;

function validateInstanceHandle(){
var valid=
InstanceHandle && 
InstanceHandle.traverseTwoPhase && 
InstanceHandle.traverseEnterLeave;
invariant(
valid,
'InstanceHandle not injected before use!');}

























var EventPluginHub={




injection:{





injectMount:EventPluginUtils.injection.injectMount,





injectInstanceHandle:function(InjectedInstanceHandle){
InstanceHandle = InjectedInstanceHandle;
if(__DEV__){
validateInstanceHandle();}},



getInstanceHandle:function(){
if(__DEV__){
validateInstanceHandle();}

return InstanceHandle;},






injectEventPluginOrder:EventPluginRegistry.injectEventPluginOrder,




injectEventPluginsByName:EventPluginRegistry.injectEventPluginsByName},



eventNameDispatchConfigs:EventPluginRegistry.eventNameDispatchConfigs,

registrationNameModules:EventPluginRegistry.registrationNameModules,








putListener:function(id,registrationName,listener){
invariant(
!listener || typeof listener === 'function',
'Expected %s listener to be a function, instead got type %s',
registrationName,typeof listener);


var bankForRegistrationName=
listenerBank[registrationName] || (listenerBank[registrationName] = {});
bankForRegistrationName[id] = listener;},







getListener:function(id,registrationName){
var bankForRegistrationName=listenerBank[registrationName];
return bankForRegistrationName && bankForRegistrationName[id];},








deleteListener:function(id,registrationName){
var bankForRegistrationName=listenerBank[registrationName];
if(bankForRegistrationName){
delete bankForRegistrationName[id];}},








deleteAllListeners:function(id){
for(var registrationName in listenerBank) {
delete listenerBank[registrationName][id];}},














extractEvents:function(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent){
var events;
var plugins=EventPluginRegistry.plugins;
for(var i=0,l=plugins.length;i < l;i++) {

var possiblePlugin=plugins[i];
if(possiblePlugin){
var extractedEvents=possiblePlugin.extractEvents(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent);

if(extractedEvents){
events = accumulateInto(events,extractedEvents);}}}



return events;},









enqueueEvents:function(events){
if(events){
eventQueue = accumulateInto(eventQueue,events);}},








processEventQueue:function(){


var processingEventQueue=eventQueue;
eventQueue = null;
forEachAccumulated(processingEventQueue,executeDispatchesAndRelease);
invariant(
!eventQueue,
'processEventQueue(): Additional events were enqueued while processing ' + 
'an event queue. Support for this has not yet been implemented.');},






__purge:function(){
listenerBank = {};},


__getListenerBank:function(){
return listenerBank;}};




module.exports = EventPluginHub;
});
__d('EventPluginRegistry',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var invariant=require('invariant');




var EventPluginOrder=null;




var namesToPlugins={};






function recomputePluginOrdering(){
if(!EventPluginOrder){

return;}

for(var pluginName in namesToPlugins) {
var PluginModule=namesToPlugins[pluginName];
var pluginIndex=EventPluginOrder.indexOf(pluginName);
invariant(
pluginIndex > -1,
'EventPluginRegistry: Cannot inject event plugins that do not exist in ' + 
'the plugin ordering, `%s`.',
pluginName);

if(EventPluginRegistry.plugins[pluginIndex]){
continue;}

invariant(
PluginModule.extractEvents,
'EventPluginRegistry: Event plugins must implement an `extractEvents` ' + 
'method, but `%s` does not.',
pluginName);

EventPluginRegistry.plugins[pluginIndex] = PluginModule;
var publishedEvents=PluginModule.eventTypes;
for(var eventName in publishedEvents) {
invariant(
publishEventForPlugin(
publishedEvents[eventName],
PluginModule,
eventName),

'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.',
eventName,
pluginName);}}}













function publishEventForPlugin(dispatchConfig,PluginModule,eventName){
invariant(
!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName),
'EventPluginHub: More than one plugin attempted to publish the same ' + 
'event name, `%s`.',
eventName);

EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;

var phasedRegistrationNames=dispatchConfig.phasedRegistrationNames;
if(phasedRegistrationNames){
for(var phaseName in phasedRegistrationNames) {
if(phasedRegistrationNames.hasOwnProperty(phaseName)){
var phasedRegistrationName=phasedRegistrationNames[phaseName];
publishRegistrationName(
phasedRegistrationName,
PluginModule,
eventName);}}



return true;}else 
if(dispatchConfig.registrationName){
publishRegistrationName(
dispatchConfig.registrationName,
PluginModule,
eventName);

return true;}

return false;}










function publishRegistrationName(registrationName,PluginModule,eventName){
invariant(
!EventPluginRegistry.registrationNameModules[registrationName],
'EventPluginHub: More than one plugin attempted to publish the same ' + 
'registration name, `%s`.',
registrationName);

EventPluginRegistry.registrationNameModules[registrationName] = PluginModule;
EventPluginRegistry.registrationNameDependencies[registrationName] = 
PluginModule.eventTypes[eventName].dependencies;}







var EventPluginRegistry={




plugins:[],




eventNameDispatchConfigs:{},




registrationNameModules:{},




registrationNameDependencies:{},










injectEventPluginOrder:function(InjectedEventPluginOrder){
invariant(
!EventPluginOrder,
'EventPluginRegistry: Cannot inject event plugin ordering more than ' + 
'once. You are likely trying to load more than one copy of React.');


EventPluginOrder = Array.prototype.slice.call(InjectedEventPluginOrder);
recomputePluginOrdering();},












injectEventPluginsByName:function(injectedNamesToPlugins){
var isOrderingDirty=false;
for(var pluginName in injectedNamesToPlugins) {
if(!injectedNamesToPlugins.hasOwnProperty(pluginName)){
continue;}

var PluginModule=injectedNamesToPlugins[pluginName];
if(!namesToPlugins.hasOwnProperty(pluginName) || 
namesToPlugins[pluginName] !== PluginModule){
invariant(
!namesToPlugins[pluginName],
'EventPluginRegistry: Cannot inject two different event plugins ' + 
'using the same name, `%s`.',
pluginName);

namesToPlugins[pluginName] = PluginModule;
isOrderingDirty = true;}}


if(isOrderingDirty){
recomputePluginOrdering();}},










getPluginModuleForEvent:function(event){
var dispatchConfig=event.dispatchConfig;
if(dispatchConfig.registrationName){
return EventPluginRegistry.registrationNameModules[
dispatchConfig.registrationName] || 
null;}

for(var phase in dispatchConfig.phasedRegistrationNames) {
if(!dispatchConfig.phasedRegistrationNames.hasOwnProperty(phase)){
continue;}

var PluginModule=EventPluginRegistry.registrationNameModules[
dispatchConfig.phasedRegistrationNames[phase]];

if(PluginModule){
return PluginModule;}}


return null;},






_resetEventPlugins:function(){
EventPluginOrder = null;
for(var pluginName in namesToPlugins) {
if(namesToPlugins.hasOwnProperty(pluginName)){
delete namesToPlugins[pluginName];}}


EventPluginRegistry.plugins.length = 0;

var eventNameDispatchConfigs=EventPluginRegistry.eventNameDispatchConfigs;
for(var eventName in eventNameDispatchConfigs) {
if(eventNameDispatchConfigs.hasOwnProperty(eventName)){
delete eventNameDispatchConfigs[eventName];}}



var registrationNameModules=EventPluginRegistry.registrationNameModules;
for(var registrationName in registrationNameModules) {
if(registrationNameModules.hasOwnProperty(registrationName)){
delete registrationNameModules[registrationName];}}}};






module.exports = EventPluginRegistry;
});
__d('EventPluginUtils',["EventConstants","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventConstants=require('EventConstants');

var invariant=require('invariant');









var injection={
Mount:null,
injectMount:function(InjectedMount){
injection.Mount = InjectedMount;
if(__DEV__){
invariant(
InjectedMount && InjectedMount.getNode,
'EventPluginUtils.injection.injectMount(...): Injected Mount module ' + 
'is missing getNode.');}}};





var topLevelTypes=EventConstants.topLevelTypes;

function isEndish(topLevelType){
return topLevelType === topLevelTypes.topMouseUp || 
topLevelType === topLevelTypes.topTouchEnd || 
topLevelType === topLevelTypes.topTouchCancel;}


function isMoveish(topLevelType){
return topLevelType === topLevelTypes.topMouseMove || 
topLevelType === topLevelTypes.topTouchMove;}

function isStartish(topLevelType){
return topLevelType === topLevelTypes.topMouseDown || 
topLevelType === topLevelTypes.topTouchStart;}



var validateEventDispatches;
if(__DEV__){
validateEventDispatches = function(event){
var dispatchListeners=event._dispatchListeners;
var dispatchIDs=event._dispatchIDs;

var listenersIsArr=Array.isArray(dispatchListeners);
var idsIsArr=Array.isArray(dispatchIDs);
var IDsLen=idsIsArr?dispatchIDs.length:dispatchIDs?1:0;
var listenersLen=listenersIsArr?
dispatchListeners.length:
dispatchListeners?1:0;

invariant(
idsIsArr === listenersIsArr && IDsLen === listenersLen,
'EventPluginUtils: Invalid `event`.');};}









function forEachEventDispatch(event,cb){
var dispatchListeners=event._dispatchListeners;
var dispatchIDs=event._dispatchIDs;
if(__DEV__){
validateEventDispatches(event);}

if(Array.isArray(dispatchListeners)){
for(var i=0;i < dispatchListeners.length;i++) {
if(event.isPropagationStopped()){
break;}


cb(event,dispatchListeners[i],dispatchIDs[i]);}}else 

if(dispatchListeners){
cb(event,dispatchListeners,dispatchIDs);}}









function executeDispatch(event,listener,domID){
event.currentTarget = injection.Mount.getNode(domID);
var returnValue=listener(event,domID);
event.currentTarget = null;
return returnValue;}





function executeDispatchesInOrder(event,cb){
forEachEventDispatch(event,cb);
event._dispatchListeners = null;
event._dispatchIDs = null;}









function executeDispatchesInOrderStopAtTrueImpl(event){
var dispatchListeners=event._dispatchListeners;
var dispatchIDs=event._dispatchIDs;
if(__DEV__){
validateEventDispatches(event);}

if(Array.isArray(dispatchListeners)){
for(var i=0;i < dispatchListeners.length;i++) {
if(event.isPropagationStopped()){
break;}


if(dispatchListeners[i](event,dispatchIDs[i])){
return dispatchIDs[i];}}}else 


if(dispatchListeners){
if(dispatchListeners(event,dispatchIDs)){
return dispatchIDs;}}


return null;}





function executeDispatchesInOrderStopAtTrue(event){
var ret=executeDispatchesInOrderStopAtTrueImpl(event);
event._dispatchIDs = null;
event._dispatchListeners = null;
return ret;}











function executeDirectDispatch(event){
if(__DEV__){
validateEventDispatches(event);}

var dispatchListener=event._dispatchListeners;
var dispatchID=event._dispatchIDs;
invariant(
!Array.isArray(dispatchListener),
'executeDirectDispatch(...): Invalid `event`.');

var res=dispatchListener?
dispatchListener(event,dispatchID):
null;
event._dispatchListeners = null;
event._dispatchIDs = null;
return res;}






function hasDispatches(event){
return !!event._dispatchListeners;}





var EventPluginUtils={
isEndish:isEndish,
isMoveish:isMoveish,
isStartish:isStartish,

executeDirectDispatch:executeDirectDispatch,
executeDispatch:executeDispatch,
executeDispatchesInOrder:executeDispatchesInOrder,
executeDispatchesInOrderStopAtTrue:executeDispatchesInOrderStopAtTrue,
hasDispatches:hasDispatches,
injection:injection,
useTouchEvents:false};


module.exports = EventPluginUtils;
});
__d('EventConstants',["keyMirror"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var keyMirror=require('keyMirror');

var PropagationPhases=keyMirror({bubbled:null,captured:null});




var topLevelTypes=keyMirror({
topBlur:null,
topChange:null,
topClick:null,
topCompositionEnd:null,
topCompositionStart:null,
topCompositionUpdate:null,
topContextMenu:null,
topCopy:null,
topCut:null,
topDoubleClick:null,
topDrag:null,
topDragEnd:null,
topDragEnter:null,
topDragExit:null,
topDragLeave:null,
topDragOver:null,
topDragStart:null,
topDrop:null,
topError:null,
topFocus:null,
topInput:null,
topKeyDown:null,
topKeyPress:null,
topKeyUp:null,
topLoad:null,
topMouseDown:null,
topMouseMove:null,
topMouseOut:null,
topMouseOver:null,
topMouseUp:null,
topPaste:null,
topReset:null,
topScroll:null,
topSelectionChange:null,
topSubmit:null,
topTextInput:null,
topTouchCancel:null,
topTouchEnd:null,
topTouchMove:null,
topTouchStart:null,
topWheel:null});


var EventConstants={
topLevelTypes:topLevelTypes,
PropagationPhases:PropagationPhases};


module.exports = EventConstants;
});
__d('accumulateInto',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');















function accumulateInto(current,next){
invariant(
next != null,
'accumulateInto(...): Accumulated items must not be null or undefined.');

if(current == null){
return next;}




var currentIsArray=Array.isArray(current);
var nextIsArray=Array.isArray(next);

if(currentIsArray && nextIsArray){
current.push.apply(current,next);
return current;}


if(currentIsArray){
current.push(next);
return current;}


if(nextIsArray){

return [current].concat(next);}


return [current,next];}


module.exports = accumulateInto;
});
__d('forEachAccumulated',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



















var forEachAccumulated=function(arr,cb,scope){
if(Array.isArray(arr)){
arr.forEach(cb,scope);}else 
if(arr){
cb.call(scope,arr);}};



module.exports = forEachAccumulated;
});
__d('IOSDefaultEventPluginOrder',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var IOSDefaultEventPluginOrder=[
'ResponderEventPlugin',
'IOSNativeBridgeEventPlugin'];


module.exports = IOSDefaultEventPluginOrder;
});
__d('IOSNativeBridgeEventPlugin',["EventPropagators","NativeModules","SyntheticEvent","merge","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventPropagators=require('EventPropagators');
var NativeModules=require('NativeModules');
var SyntheticEvent=require('SyntheticEvent');

var merge=require('merge');
var warning=require('warning');

var RCTUIManager=NativeModules.UIManager;

var customBubblingEventTypes=RCTUIManager.customBubblingEventTypes;
var customDirectEventTypes=RCTUIManager.customDirectEventTypes;

var allTypesByEventName={};

for(var bubblingTypeName in customBubblingEventTypes) {
allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];}


for(var directTypeName in customDirectEventTypes) {
warning(
!customBubblingEventTypes[directTypeName],
'Event cannot be both direct and bubbling: %s',
directTypeName);

allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];}


var IOSNativeBridgeEventPlugin={

eventTypes:merge(customBubblingEventTypes,customDirectEventTypes),









extractEvents:function(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent)
{
var bubbleDispatchConfig=customBubblingEventTypes[topLevelType];
var directDispatchConfig=customDirectEventTypes[topLevelType];
var event=SyntheticEvent.getPooled(
bubbleDispatchConfig || directDispatchConfig,
topLevelTargetID,
nativeEvent);

if(bubbleDispatchConfig){
EventPropagators.accumulateTwoPhaseDispatches(event);}else 
if(directDispatchConfig){
EventPropagators.accumulateDirectDispatches(event);}else 
{
return null;}

return event;}};



module.exports = IOSNativeBridgeEventPlugin;
});
__d('EventPropagators',["EventConstants","EventPluginHub","accumulateInto","forEachAccumulated"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



















var EventConstants=require('EventConstants');
var EventPluginHub=require('EventPluginHub');

var accumulateInto=require('accumulateInto');
var forEachAccumulated=require('forEachAccumulated');

var PropagationPhases=EventConstants.PropagationPhases;
var getListener=EventPluginHub.getListener;





function listenerAtPhase(id,event,propagationPhase){
var registrationName=
event.dispatchConfig.phasedRegistrationNames[propagationPhase];
return getListener(id,registrationName);}








function accumulateDirectionalDispatches(domID,upwards,event){
if(__DEV__){
if(!domID){
throw new Error('Dispatching id must not be null');}}


var phase=upwards?PropagationPhases.bubbled:PropagationPhases.captured;
var listener=listenerAtPhase(domID,event,phase);
if(listener){
event._dispatchListeners = 
accumulateInto(event._dispatchListeners,listener);
event._dispatchIDs = accumulateInto(event._dispatchIDs,domID);}}










function accumulateTwoPhaseDispatchesSingle(event){
if(event && event.dispatchConfig.phasedRegistrationNames){
EventPluginHub.injection.getInstanceHandle().traverseTwoPhase(
event.dispatchMarker,
accumulateDirectionalDispatches,
event);}}







function accumulateTwoPhaseDispatchesSingleSkipTarget(event){
if(event && event.dispatchConfig.phasedRegistrationNames){
EventPluginHub.injection.getInstanceHandle().traverseTwoPhaseSkipTarget(
event.dispatchMarker,
accumulateDirectionalDispatches,
event);}}










function accumulateDispatches(id,ignoredDirection,event){
if(event && event.dispatchConfig.registrationName){
var registrationName=event.dispatchConfig.registrationName;
var listener=getListener(id,registrationName);
if(listener){
event._dispatchListeners = 
accumulateInto(event._dispatchListeners,listener);
event._dispatchIDs = accumulateInto(event._dispatchIDs,id);}}}









function accumulateDirectDispatchesSingle(event){
if(event && event.dispatchConfig.registrationName){
accumulateDispatches(event.dispatchMarker,null,event);}}



function accumulateTwoPhaseDispatches(events){
forEachAccumulated(events,accumulateTwoPhaseDispatchesSingle);}


function accumulateTwoPhaseDispatchesSkipTarget(events){
forEachAccumulated(events,accumulateTwoPhaseDispatchesSingleSkipTarget);}


function accumulateEnterLeaveDispatches(leave,enter,fromID,toID){
EventPluginHub.injection.getInstanceHandle().traverseEnterLeave(
fromID,
toID,
accumulateDispatches,
leave,
enter);}




function accumulateDirectDispatches(events){
forEachAccumulated(events,accumulateDirectDispatchesSingle);}















var EventPropagators={
accumulateTwoPhaseDispatches:accumulateTwoPhaseDispatches,
accumulateTwoPhaseDispatchesSkipTarget:accumulateTwoPhaseDispatchesSkipTarget,
accumulateDirectDispatches:accumulateDirectDispatches,
accumulateEnterLeaveDispatches:accumulateEnterLeaveDispatches};


module.exports = EventPropagators;
});
__d('SyntheticEvent',["PooledClass","Object.assign","emptyFunction","getEventTarget"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var PooledClass=require('PooledClass');

var assign=require('Object.assign');
var emptyFunction=require('emptyFunction');
var getEventTarget=require('getEventTarget');





var EventInterface={
type:null,
target:getEventTarget,

currentTarget:emptyFunction.thatReturnsNull,
eventPhase:null,
bubbles:null,
cancelable:null,
timeStamp:function(event){
return event.timeStamp || Date.now();},

defaultPrevented:null,
isTrusted:null};



















function SyntheticEvent(dispatchConfig,dispatchMarker,nativeEvent){
this.dispatchConfig = dispatchConfig;
this.dispatchMarker = dispatchMarker;
this.nativeEvent = nativeEvent;

var Interface=this.constructor.Interface;
for(var propName in Interface) {
if(!Interface.hasOwnProperty(propName)){
continue;}

var normalize=Interface[propName];
if(normalize){
this[propName] = normalize(nativeEvent);}else 
{
this[propName] = nativeEvent[propName];}}



var defaultPrevented=nativeEvent.defaultPrevented != null?
nativeEvent.defaultPrevented:
nativeEvent.returnValue === false;
if(defaultPrevented){
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;}else 
{
this.isDefaultPrevented = emptyFunction.thatReturnsFalse;}

this.isPropagationStopped = emptyFunction.thatReturnsFalse;}


assign(SyntheticEvent.prototype,{

preventDefault:function(){
this.defaultPrevented = true;
var event=this.nativeEvent;
if(event.preventDefault){
event.preventDefault();}else 
{
event.returnValue = false;}

this.isDefaultPrevented = emptyFunction.thatReturnsTrue;},


stopPropagation:function(){
var event=this.nativeEvent;
if(event.stopPropagation){
event.stopPropagation();}else 
{
event.cancelBubble = true;}

this.isPropagationStopped = emptyFunction.thatReturnsTrue;},







persist:function(){
this.isPersistent = emptyFunction.thatReturnsTrue;},







isPersistent:emptyFunction.thatReturnsFalse,




destructor:function(){
var Interface=this.constructor.Interface;
for(var propName in Interface) {
this[propName] = null;}

this.dispatchConfig = null;
this.dispatchMarker = null;
this.nativeEvent = null;}});




SyntheticEvent.Interface = EventInterface;







SyntheticEvent.augmentClass = function(Class,Interface){
var Super=this;

var prototype=Object.create(Super.prototype);
assign(prototype,Class.prototype);
Class.prototype = prototype;
Class.prototype.constructor = Class;

Class.Interface = assign({},Super.Interface,Interface);
Class.augmentClass = Super.augmentClass;

PooledClass.addPoolingTo(Class,PooledClass.threeArgumentPooler);};


PooledClass.addPoolingTo(SyntheticEvent,PooledClass.threeArgumentPooler);

module.exports = SyntheticEvent;
});
__d('getEventTarget',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




















function getEventTarget(nativeEvent){
var target=nativeEvent.target || nativeEvent.srcElement || window;


return target.nodeType === 3?target.parentNode:target;}


module.exports = getEventTarget;
});
__d('merge',["mergeInto"],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";
































var mergeInto=require("mergeInto");








var merge=function(one,two){
var result={};
mergeInto(result,one);
mergeInto(result,two);
return result;};


module.exports = merge;
});
__d('mergeInto',["mergeHelpers"],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";

































var mergeHelpers=require("mergeHelpers");

var checkMergeObjectArg=mergeHelpers.checkMergeObjectArg;
var checkMergeIntoObjectArg=mergeHelpers.checkMergeIntoObjectArg;







function mergeInto(one,two){
checkMergeIntoObjectArg(one);
if(two != null){
checkMergeObjectArg(two);
for(var key in two) {
if(!two.hasOwnProperty(key)){
continue;}

one[key] = two[key];}}}




module.exports = mergeInto;
});
__d('mergeHelpers',["invariant","keyMirror"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';


































var invariant=require('invariant');
var keyMirror=require('keyMirror');





var MAX_MERGE_DEPTH=36;







var isTerminal=function(o){
return typeof o !== 'object' || o === null;};


var mergeHelpers={

MAX_MERGE_DEPTH:MAX_MERGE_DEPTH,

isTerminal:isTerminal,







normalizeMergeArg:function(arg){
return arg === undefined || arg === null?{}:arg;},










checkMergeArrayArgs:function(one,two){
invariant(
Array.isArray(one) && Array.isArray(two),
'Tried to merge arrays, instead got %s and %s.',
one,
two);},







checkMergeObjectArgs:function(one,two){
mergeHelpers.checkMergeObjectArg(one);
mergeHelpers.checkMergeObjectArg(two);},





checkMergeObjectArg:function(arg){
invariant(
!isTerminal(arg) && !Array.isArray(arg),
'Tried to merge an object, instead got %s.',
arg);},






checkMergeIntoObjectArg:function(arg){
invariant(
(!isTerminal(arg) || typeof arg === 'function') && !Array.isArray(arg),
'Tried to merge into an object, instead got %s.',
arg);},









checkMergeLevel:function(level){
invariant(
level < MAX_MERGE_DEPTH,
'Maximum deep merge depth exceeded. You may be attempting to merge ' + 
'circular structures in an unsupported way.');},








checkArrayStrategy:function(strategy){
invariant(
strategy === undefined || strategy in mergeHelpers.ArrayStrategies,
'You must provide an array strategy to deep merge functions to ' + 
'instruct the deep merge how to resolve merging two arrays.');},










ArrayStrategies:keyMirror({
Clobber:true,
IndexByIndex:true})};




module.exports = mergeHelpers;
});
__d('NodeHandle',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var 




























































NodeHandle={



injection:{
injectImplementation:function(Impl){
NodeHandle._Implementation = Impl;}},



_Implementation:null,





getRootNodeID:function(nodeHandle){
return NodeHandle._Implementation.getRootNodeID(nodeHandle);}};



module.exports = NodeHandle;
});
__d('ReactDefaultBatchingStrategy',["ReactUpdates","Transaction","Object.assign","emptyFunction"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactUpdates=require('ReactUpdates');
var Transaction=require('Transaction');

var assign=require('Object.assign');
var emptyFunction=require('emptyFunction');

var RESET_BATCHED_UPDATES={
initialize:emptyFunction,
close:function(){
ReactDefaultBatchingStrategy.isBatchingUpdates = false;}};



var FLUSH_BATCHED_UPDATES={
initialize:emptyFunction,
close:ReactUpdates.flushBatchedUpdates.bind(ReactUpdates)};


var TRANSACTION_WRAPPERS=[FLUSH_BATCHED_UPDATES,RESET_BATCHED_UPDATES];

function ReactDefaultBatchingStrategyTransaction(){
this.reinitializeTransaction();}


assign(
ReactDefaultBatchingStrategyTransaction.prototype,
Transaction.Mixin,
{
getTransactionWrappers:function(){
return TRANSACTION_WRAPPERS;}});




var transaction=new ReactDefaultBatchingStrategyTransaction();

var ReactDefaultBatchingStrategy={
isBatchingUpdates:false,





batchedUpdates:function(callback,a,b,c,d){
var alreadyBatchingUpdates=ReactDefaultBatchingStrategy.isBatchingUpdates;

ReactDefaultBatchingStrategy.isBatchingUpdates = true;


if(alreadyBatchingUpdates){
callback(a,b,c,d);}else 
{
transaction.perform(callback,null,a,b,c,d);}}};




module.exports = ReactDefaultBatchingStrategy;
});
__d('ReactNativeComponentEnvironment',["ReactNativeDOMIDOperations","ReactNativeReconcileTransaction"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactNativeDOMIDOperations=require('ReactNativeDOMIDOperations');
var ReactNativeReconcileTransaction=require('ReactNativeReconcileTransaction');

var ReactNativeComponentEnvironment={

processChildrenUpdates:ReactNativeDOMIDOperations.dangerouslyProcessChildrenUpdates,

replaceNodeWithMarkupByID:ReactNativeDOMIDOperations.dangerouslyReplaceNodeWithMarkupByID,






unmountIDFromEnvironment:function(){},






clearNode:function(){},



ReactReconcileTransaction:ReactNativeReconcileTransaction};


module.exports = ReactNativeComponentEnvironment;
});
__d('ReactNativeDOMIDOperations',["ReactNativeTagHandles","ReactMultiChildUpdateTypes","NativeModules","ReactPerf"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactNativeTagHandles=require('ReactNativeTagHandles');
var ReactMultiChildUpdateTypes=require('ReactMultiChildUpdateTypes');
var RCTUIManager=require('NativeModules').UIManager;
var ReactPerf=require('ReactPerf');













var dangerouslyProcessChildrenUpdates=function(childrenUpdates,markupList){
if(!childrenUpdates.length){
return;}

var byContainerTag={};


for(var i=0;i < childrenUpdates.length;i++) {
var update=childrenUpdates[i];
var containerTag=ReactNativeTagHandles.mostRecentMountedNodeHandleForRootNodeID(update.parentID);
var updates=byContainerTag[containerTag] || (byContainerTag[containerTag] = {});
if(update.type === ReactMultiChildUpdateTypes.MOVE_EXISTING){
(updates.moveFromIndices || (updates.moveFromIndices = [])).push(update.fromIndex);
(updates.moveToIndices || (updates.moveToIndices = [])).push(update.toIndex);}else 
if(update.type === ReactMultiChildUpdateTypes.REMOVE_NODE){
(updates.removeAtIndices || (updates.removeAtIndices = [])).push(update.fromIndex);}else 
if(update.type === ReactMultiChildUpdateTypes.INSERT_MARKUP){
var mountImage=markupList[update.markupIndex];
var tag=mountImage.tag;
var rootNodeID=mountImage.rootNodeID;
ReactNativeTagHandles.associateRootNodeIDWithMountedNodeHandle(rootNodeID,tag);
(updates.addAtIndices || (updates.addAtIndices = [])).push(update.toIndex);
(updates.addChildTags || (updates.addChildTags = [])).push(tag);}}





for(var updateParentTagString in byContainerTag) {
var updateParentTagNumber=+updateParentTagString;
var childUpdatesToSend=byContainerTag[updateParentTagNumber];
RCTUIManager.manageChildren(
updateParentTagNumber,
childUpdatesToSend.moveFromIndices,
childUpdatesToSend.moveToIndices,
childUpdatesToSend.addChildTags,
childUpdatesToSend.addAtIndices,
childUpdatesToSend.removeAtIndices);}};








var ReactNativeDOMIDOperations={
dangerouslyProcessChildrenUpdates:ReactPerf.measure(

'ReactDOMIDOperations',
'dangerouslyProcessChildrenUpdates',
dangerouslyProcessChildrenUpdates),








dangerouslyReplaceNodeWithMarkupByID:ReactPerf.measure(
'ReactDOMIDOperations',
'dangerouslyReplaceNodeWithMarkupByID',
function(id,mountImage){
var oldTag=ReactNativeTagHandles.mostRecentMountedNodeHandleForRootNodeID(id);
RCTUIManager.replaceExistingNonRootView(oldTag,mountImage.tag);
ReactNativeTagHandles.associateRootNodeIDWithMountedNodeHandle(id,mountImage.tag);})};




module.exports = ReactNativeDOMIDOperations;
});
__d('ReactMultiChildUpdateTypes',["keyMirror"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var keyMirror=require('keyMirror');









var ReactMultiChildUpdateTypes=keyMirror({
INSERT_MARKUP:null,
MOVE_EXISTING:null,
REMOVE_NODE:null,
TEXT_CONTENT:null});


module.exports = ReactMultiChildUpdateTypes;
});
__d('ReactNativeReconcileTransaction',["CallbackQueue","PooledClass","Transaction"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var CallbackQueue=require('CallbackQueue');
var PooledClass=require('PooledClass');
var Transaction=require('Transaction');





var ON_DOM_READY_QUEUEING={



initialize:function(){
this.reactMountReady.reset();},





close:function(){
this.reactMountReady.notifyAll();}};








var TRANSACTION_WRAPPERS=[ON_DOM_READY_QUEUEING];















function ReactNativeReconcileTransaction(){
this.reinitializeTransaction();
this.reactMountReady = CallbackQueue.getPooled(null);}


var Mixin={







getTransactionWrappers:function(){
return TRANSACTION_WRAPPERS;},






getReactMountReady:function(){
return this.reactMountReady;},






destructor:function(){
CallbackQueue.release(this.reactMountReady);
this.reactMountReady = null;}};



Object.assign(
ReactNativeReconcileTransaction.prototype,
Transaction.Mixin,
ReactNativeReconcileTransaction,
Mixin);


PooledClass.addPoolingTo(ReactNativeReconcileTransaction);

module.exports = ReactNativeReconcileTransaction;
});
__d('ReactNativeGlobalInteractionHandler',["InteractionManager"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var InteractionManager=require('InteractionManager');



var interactionHandle=null;

var ReactNativeGlobalInteractionHandler={
onChange:function(numberActiveTouches){
if(numberActiveTouches === 0){
if(interactionHandle){
InteractionManager.clearInteractionHandle(interactionHandle);
interactionHandle = null;}}else 

if(!interactionHandle){
interactionHandle = InteractionManager.createInteractionHandle();}}};




module.exports = ReactNativeGlobalInteractionHandler;
});
__d('InteractionManager',["ErrorUtils","EventEmitter","Set","invariant","keyMirror","setImmediate"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ErrorUtils=require('ErrorUtils');
var EventEmitter=require('EventEmitter');
var Set=require('Set');

var invariant=require('invariant');
var keyMirror=require('keyMirror');
var setImmediate=require('setImmediate');






var DEV_TIMEOUT=2000;

var _emitter=new EventEmitter();
var _interactionSet=new Set();
var _addInteractionSet=new Set();
var _deleteInteractionSet=new Set();
var _nextUpdateHandle=null;
var _queue=[];
var _inc=0;




































var InteractionManager={
Events:keyMirror({
interactionStart:true,
interactionComplete:true}),





runAfterInteractions:function(callback){
invariant(
typeof callback === 'function',
'Must specify a function to schedule.');

scheduleUpdate();
_queue.push(callback);},





createInteractionHandle:function(){
scheduleUpdate();
var handle=++_inc;
_addInteractionSet.add(handle);
if(__DEV__){

var error=new Error(
'InteractionManager: interaction handle not cleared within ' + 
DEV_TIMEOUT + ' ms.');

setDevTimeoutHandle(handle,error,DEV_TIMEOUT);}

return handle;},





clearInteractionHandle:function(handle){
invariant(
!!handle,
'Must provide a handle to clear.');

scheduleUpdate();
_addInteractionSet.delete(handle);
_deleteInteractionSet.add(handle);},


addListener:_emitter.addListener.bind(_emitter)};





function scheduleUpdate(){
if(!_nextUpdateHandle){
_nextUpdateHandle = setImmediate(processUpdate);}}






function processUpdate(){
_nextUpdateHandle = null;

var interactionCount=_interactionSet.size;
_addInteractionSet.forEach(function(handle){return (
_interactionSet.add(handle));});

_deleteInteractionSet.forEach(function(handle){return (
_interactionSet.delete(handle));});

var nextInteractionCount=_interactionSet.size;

if(interactionCount !== 0 && nextInteractionCount === 0){

_emitter.emit(InteractionManager.Events.interactionComplete);}else 
if(interactionCount === 0 && nextInteractionCount !== 0){

_emitter.emit(InteractionManager.Events.interactionStart);}



if(nextInteractionCount === 0){
var queue=_queue;
_queue = [];
queue.forEach(function(callback){
ErrorUtils.applyWithGuard(callback);});}



_addInteractionSet.clear();
_deleteInteractionSet.clear();}





function setDevTimeoutHandle(
handle,
error,
timeout)
{
setTimeout(function(){
if(_interactionSet.has(handle)){
console.warn(error.message + '\n' + error.stack);}},

timeout);}


module.exports = InteractionManager;
});
__d('Set',["Map","toIterator","_shouldPolyfillES6Collection"],function(global, require, requireDynamic, requireLazy, module, exports) {  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');}}



















var Map=require('Map');
var toIterator=require('toIterator');
var _shouldPolyfillES6Collection=require('_shouldPolyfillES6Collection');

module.exports = (function(global,undefined){





if(!_shouldPolyfillES6Collection('Set')){
return global.Set;}var 











































Set=(function(){










function Set(iterable){_classCallCheck(this,Set);
if(this == null || 
typeof this !== 'object' && typeof this !== 'function'){
throw new TypeError('Wrong set object type.');}


initSet(this);

if(iterable != null){
var it=toIterator(iterable);
var next;
while(!(next = it.next()).done) {
this.add(next.value);}}}_createClass(Set,[{key:'add',value:












function add(value){
this._map.set(value,value);
this.size = this._map.size;
return this;}},{key:'clear',value:







function clear(){
initSet(this);}},{key:'delete',value:











function _delete(value){
var ret=this._map.delete(value);
this.size = this._map.size;
return ret;}},{key:'entries',value:







function entries(){
return this._map.entries();}},{key:'forEach',value:









function forEach(callback){
var thisArg=arguments[1];
var it=this._map.keys();
var next;
while(!(next = it.next()).done) {
callback.call(thisArg,next.value,next.value,this);}}},{key:'has',value:











function has(value){
return this._map.has(value);}},{key:'values',value:







function values(){
return this._map.values();}}]);return Set;})();




Set.prototype[toIterator.ITERATOR_SYMBOL] = Set.prototype.values;


Set.prototype.keys = Set.prototype.values;

function initSet(set){
set._map = new Map();
set.size = set._map.size;}


return Set;})(
Function('return this')());
});
__d('Map',["guid","isNode","toIterator","_shouldPolyfillES6Collection"],function(global, require, requireDynamic, requireLazy, module, exports) {  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');}}



















var guid=require('guid');
var isNode=require('isNode');
var toIterator=require('toIterator');
var _shouldPolyfillES6Collection=require('_shouldPolyfillES6Collection');

module.exports = (function(global,undefined){




if(!_shouldPolyfillES6Collection('Map')){
return global.Map;}

























































var KIND_KEY='key';
var KIND_VALUE='value';
var KIND_KEY_VALUE='key+value';



var KEY_PREFIX='$map_';



var SECRET_SIZE_PROP;
if(__DEV__){
SECRET_SIZE_PROP = '$size' + guid();}



var OLD_IE_HASH_PREFIX='IE_HASH_';var 

Map=(function(){










function Map(iterable){_classCallCheck(this,Map);
if(!isObject(this)){
throw new TypeError('Wrong map object type.');}


initMap(this);

if(iterable != null){
var it=toIterator(iterable);
var next;
while(!(next = it.next()).done) {
if(!isObject(next.value)){
throw new TypeError('Expected iterable items to be pair objects.');}

this.set(next.value[0],next.value[1]);}}}_createClass(Map,[{key:'clear',value:








function clear(){
initMap(this);}},{key:'has',value:









function has(key){
var index=getIndex(this,key);
return !!(index != null && this._mapData[index]);}},{key:'set',value:










function set(key,value){
var index=getIndex(this,key);

if(index != null && this._mapData[index]){
this._mapData[index][1] = value;}else 
{
index = this._mapData.push([
key,
value]) - 
1;
setIndex(this,key,index);
if(__DEV__){
this[SECRET_SIZE_PROP] += 1;}else 
{
this.size += 1;}}



return this;}},{key:'get',value:









function get(key){
var index=getIndex(this,key);
if(index == null){
return undefined;}else 
{
return this._mapData[index][1];}}},{key:'delete',value:











function _delete(key){
var index=getIndex(this,key);
if(index != null && this._mapData[index]){
setIndex(this,key,undefined);
this._mapData[index] = undefined;
if(__DEV__){
this[SECRET_SIZE_PROP] -= 1;}else 
{
this.size -= 1;}

return true;}else 
{
return false;}}},{key:'entries',value:










function entries(){
return new MapIterator(this,KIND_KEY_VALUE);}},{key:'keys',value:








function keys(){
return new MapIterator(this,KIND_KEY);}},{key:'values',value:








function values(){
return new MapIterator(this,KIND_VALUE);}},{key:'forEach',value:











function forEach(callback,thisArg){
if(typeof callback !== 'function'){
throw new TypeError('Callback must be callable.');}


var boundCallback=callback.bind(thisArg || undefined);
var mapData=this._mapData;




for(var i=0;i < mapData.length;i++) {
var entry=mapData[i];
if(entry != null){
boundCallback(entry[1],entry[0],this);}}}}]);return Map;})();






Map.prototype[toIterator.ITERATOR_SYMBOL] = Map.prototype.entries;var 

MapIterator=(function(){









function MapIterator(map,kind){_classCallCheck(this,MapIterator);
if(!(isObject(map) && map['_mapData'])){
throw new TypeError('Object is not a map.');}


if([KIND_KEY,KIND_KEY_VALUE,KIND_VALUE].indexOf(kind) === -1){
throw new Error('Invalid iteration kind.');}


this._map = map;
this._nextIndex = 0;
this._kind = kind;}_createClass(MapIterator,[{key:'next',value:








function next(){
if(!this instanceof Map){
throw new TypeError('Expected to be called on a MapIterator.');}


var map=this._map;
var index=this._nextIndex;
var kind=this._kind;

if(map == null){
return createIterResultObject(undefined,true);}


var entries=map['_mapData'];

while(index < entries.length) {
var record=entries[index];

index += 1;
this._nextIndex = index;

if(record){
if(kind === KIND_KEY){
return createIterResultObject(record[0],false);}else 
if(kind === KIND_VALUE){
return createIterResultObject(record[1],false);}else 
if(kind){
return createIterResultObject(record,false);}}}




this._map = undefined;

return createIterResultObject(undefined,true);}}]);return MapIterator;})();






MapIterator.prototype[toIterator.ITERATOR_SYMBOL] = function(){
return this;};













function getIndex(map,key){
if(isObject(key)){
var hash=getHash(key);
return map._objectIndex[hash];}else 
{
var prefixedKey=KEY_PREFIX + key;
if(typeof key === 'string'){
return map._stringIndex[prefixedKey];}else 
{
return map._otherIndex[prefixedKey];}}}










function setIndex(map,key,index){
var shouldDelete=index == null;

if(isObject(key)){
var hash=getHash(key);
if(shouldDelete){
delete map._objectIndex[hash];}else 
{
map._objectIndex[hash] = index;}}else 

{
var prefixedKey=KEY_PREFIX + key;
if(typeof key === 'string'){
if(shouldDelete){
delete map._stringIndex[prefixedKey];}else 
{
map._stringIndex[prefixedKey] = index;}}else 

{
if(shouldDelete){
delete map._otherIndex[prefixedKey];}else 
{
map._otherIndex[prefixedKey] = index;}}}}










function initMap(map){






map._mapData = [];







map._objectIndex = {};


map._stringIndex = {};


map._otherIndex = {};







if(__DEV__){
if(isES5){



if(map.hasOwnProperty(SECRET_SIZE_PROP)){
map[SECRET_SIZE_PROP] = 0;}else 
{
Object.defineProperty(map,SECRET_SIZE_PROP,{
value:0,
writable:true});

Object.defineProperty(map,'size',{
set:function(v){
console.error(
'PLEASE FIX ME: You are changing the map size property which ' + 
'should not be writable and will break in production.');

throw new Error('The map size property is not writable.');},

get:function(){return map[SECRET_SIZE_PROP];}});}




return;}}





map.size = 0;}








function isObject(o){
return o != null && (typeof o === 'object' || typeof o === 'function');}









function createIterResultObject(value,done){
return {value:value,done:done};}



var isES5=(function(){
try{
Object.defineProperty({},'x',{});
return true;}
catch(e) {
return false;}})();









function isExtensible(o){
if(!isES5){
return true;}else 
{
return Object.isExtensible(o);}}











function getIENodeHash(node){
var uniqueID;
switch(node.nodeType){
case 1:
uniqueID = node.uniqueID;
break;
case 9:
uniqueID = node.documentElement.uniqueID;
break;
default:
return null;}


if(uniqueID){
return OLD_IE_HASH_PREFIX + uniqueID;}else 
{
return null;}}



var getHash=(function(){
var propIsEnumerable=Object.prototype.propertyIsEnumerable;
var hashProperty=guid();
var hashCounter=0;







return function getHash(o){
if(o[hashProperty]){
return o[hashProperty];}else 
if(!isES5 && 
o.propertyIsEnumerable && 
o.propertyIsEnumerable[hashProperty]){
return o.propertyIsEnumerable[hashProperty];}else 
if(!isES5 && 
isNode(o) && 
getIENodeHash(o)){
return getIENodeHash(o);}else 
if(!isES5 && o[hashProperty]){
return o[hashProperty];}


if(isExtensible(o)){
hashCounter += 1;
if(isES5){
Object.defineProperty(o,hashProperty,{
enumerable:false,
writable:false,
configurable:false,
value:hashCounter});}else 

if(o.propertyIsEnumerable){




o.propertyIsEnumerable = function(){
return propIsEnumerable.apply(this,arguments);};

o.propertyIsEnumerable[hashProperty] = hashCounter;}else 
if(isNode(o)){




o[hashProperty] = hashCounter;}else 
{
throw new Error('Unable to set a non-enumerable property on object.');}

return hashCounter;}else 
{
throw new Error('Non-extensible objects are not allowed as keys.');}};})();




return Map;})(
Function('return this')());
});
__d('guid',[],function(global, require, requireDynamic, requireLazy, module, exports) {  function 

























guid(){
return 'f' + (Math.random() * (1 << 30)).toString(16).replace('.','');}


module.exports = guid;
});
__d('isNode',[],function(global, require, requireDynamic, requireLazy, module, exports) {  function 















isNode(object){
return !!(object && (
typeof Node === 'function'?object instanceof Node:
typeof object === 'object' && 
typeof object.nodeType === 'number' && 
typeof object.nodeName === 'string'));}



module.exports = isNode;
});
__d('toIterator',[],function(global, require, requireDynamic, requireLazy, module, exports) {  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');}}






























var KIND_KEY='key';
var KIND_VALUE='value';
var KIND_KEY_VAL='key+value';

var ITERATOR_SYMBOL=typeof Symbol === 'function'?
Symbol.iterator:
'@@iterator';

var toIterator=(function(){
if(!(Array.prototype[ITERATOR_SYMBOL] && 
String.prototype[ITERATOR_SYMBOL])){

return (function(){var 
ArrayIterator=(function(){

function ArrayIterator(array,kind){_classCallCheck(this,ArrayIterator);
if(!Array.isArray(array)){
throw new TypeError('Object is not an Array');}

this._iteratedObject = array;
this._kind = kind;
this._nextIndex = 0;}_createClass(ArrayIterator,[{key:'next',value:



function next(){
if(!this instanceof ArrayIterator){
throw new TypeError('Object is not an ArrayIterator');}


if(this._iteratedObject == null){
return createIterResultObject(undefined,true);}


var array=this._iteratedObject;
var len=this._iteratedObject.length;
var index=this._nextIndex;
var kind=this._kind;

if(index >= len){
this._iteratedObject = undefined;
return createIterResultObject(undefined,true);}


this._nextIndex = index + 1;

if(kind === KIND_KEY){
return createIterResultObject(index,false);}else 
if(kind === KIND_VALUE){
return createIterResultObject(array[index],false);}else 
if(kind === KIND_KEY_VAL){
return createIterResultObject([index,array[index]],false);}}},{key:




'@@iterator',value:function iterator(){
return this;}}]);return ArrayIterator;})();var 



StringIterator=(function(){

function StringIterator(string){_classCallCheck(this,StringIterator);
if(typeof string !== 'string'){
throw new TypeError('Object is not a string');}

this._iteratedString = string;
this._nextIndex = 0;}_createClass(StringIterator,[{key:'next',value:



function next(){
if(!this instanceof StringIterator){
throw new TypeError('Object is not a StringIterator');}


if(this._iteratedString == null){
return createIterResultObject(undefined,true);}


var index=this._nextIndex;
var s=this._iteratedString;
var len=s.length;

if(index >= len){
this._iteratedString = undefined;
return createIterResultObject(undefined,true);}


var ret;
var first=s.charCodeAt(index);

if(first < 0xD800 || first > 0xDBFF || index + 1 === len){
ret = s[index];}else 
{
var second=s.charCodeAt(index + 1);
if(second < 0xDC00 || second > 0xDFFF){
ret = s[index];}else 
{
ret = s[index] + s[index + 1];}}



this._nextIndex = index + ret.length;

return createIterResultObject(ret,false);}},{key:



'@@iterator',value:function iterator(){
return this;}}]);return StringIterator;})();




function createIterResultObject(value,done){
return {value:value,done:done};}


return function(object,kind){
if(typeof object === 'string'){
return new StringIterator(object);}else 
if(Array.isArray(object)){
return new ArrayIterator(object,kind || KIND_VALUE);}else 
{
return object[ITERATOR_SYMBOL]();}};})();}else 



{
return function(object){
return object[ITERATOR_SYMBOL]();};}})();








Object.assign(toIterator,{
KIND_KEY:KIND_KEY,
KIND_VALUE:KIND_VALUE,
KIND_KEY_VAL:KIND_KEY_VAL,
ITERATOR_SYMBOL:ITERATOR_SYMBOL});


module.exports = toIterator;
});
__d('_shouldPolyfillES6Collection',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}

























function shouldPolyfillES6Collection(collectionName){
var Collection=global[collectionName];
if(Collection == null){
return true;}


var proto=Collection.prototype;


return Collection == null || 
typeof Collection !== 'function' || 
typeof proto.clear !== 'function' || 
new Collection().size !== 0 || 
typeof proto.keys !== 'function' || 
typeof proto.forEach !== 'function' || 
isCallableWithoutNew(Collection) || 
!supportsSubclassing(Collection);}







function supportsSubclassing(Collection){var 
SubCollection=(function(_Collection){_inherits(SubCollection,_Collection);function SubCollection(){_classCallCheck(this,SubCollection);_get(Object.getPrototypeOf(SubCollection.prototype),'constructor',this).apply(this,arguments);}return SubCollection;})(Collection);
try{
var s=new SubCollection([]);


s.size;
return s instanceof Collection;}
catch(e) {
return false;}}








function isCallableWithoutNew(Collection){
try{
Collection();}
catch(e) {
return false;}

return true;}


module.exports = shouldPolyfillES6Collection;
});
__d('ReactNativeGlobalResponderHandler',["NativeModules","ReactNativeTagHandles"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var RCTUIManager=require('NativeModules').UIManager;
var ReactNativeTagHandles=require('ReactNativeTagHandles');

var ReactNativeGlobalResponderHandler={
onChange:function(from,to,blockNativeResponder){
if(to !== null){
RCTUIManager.setJSResponder(
ReactNativeTagHandles.mostRecentMountedNodeHandleForRootNodeID(to),
blockNativeResponder);}else 

{
RCTUIManager.clearJSResponder();}}};




module.exports = ReactNativeGlobalResponderHandler;
});
__d('ReactNativeTextComponent',["ReactNativeTagHandles","NativeModules","Object.assign"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactNativeTagHandles=require('ReactNativeTagHandles');
var RCTUIManager=require('NativeModules').UIManager;

var assign=require('Object.assign');

var ReactNativeTextComponent=function(props){};



assign(ReactNativeTextComponent.prototype,{

construct:function(text){

this._currentElement = text;
this._stringText = '' + text;
this._rootNodeID = null;},


mountComponent:function(rootID,transaction,context){
this._rootNodeID = rootID;
var tag=ReactNativeTagHandles.allocateTag();
var nativeTopRootID=ReactNativeTagHandles.getNativeTopRootIDFromNodeID(rootID);
RCTUIManager.createView(
tag,
'RCTRawText',
nativeTopRootID?ReactNativeTagHandles.rootNodeIDToTag[nativeTopRootID]:null,
{text:this._stringText});

return {
rootNodeID:rootID,
tag:tag};},



receiveComponent:function(nextText,transaction,context){
if(nextText !== this._currentElement){
this._currentElement = nextText;
var nextStringText='' + nextText;
if(nextStringText !== this._stringText){
this._stringText = nextStringText;
RCTUIManager.updateView(
ReactNativeTagHandles.mostRecentMountedNodeHandleForRootNodeID(
this._rootNodeID),

'RCTRawText',
{text:this._stringText});}}},





unmountComponent:function(){
this._currentElement = null;
this._stringText = null;
this._rootNodeID = null;}});




module.exports = ReactNativeTextComponent;
});
__d('ResponderEventPlugin',["EventConstants","EventPluginUtils","EventPropagators","NodeHandle","ReactInstanceHandles","ResponderSyntheticEvent","ResponderTouchHistoryStore","accumulate","invariant","keyOf"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



















var EventConstants=require('EventConstants');
var EventPluginUtils=require('EventPluginUtils');
var EventPropagators=require('EventPropagators');
var NodeHandle=require('NodeHandle');
var ReactInstanceHandles=require('ReactInstanceHandles');
var ResponderSyntheticEvent=require('ResponderSyntheticEvent');
var ResponderTouchHistoryStore=require('ResponderTouchHistoryStore');

var accumulate=require('accumulate');
var invariant=require('invariant');
var keyOf=require('keyOf');

var isStartish=EventPluginUtils.isStartish;
var isMoveish=EventPluginUtils.isMoveish;
var isEndish=EventPluginUtils.isEndish;
var executeDirectDispatch=EventPluginUtils.executeDirectDispatch;
var hasDispatches=EventPluginUtils.hasDispatches;
var executeDispatchesInOrderStopAtTrue=
EventPluginUtils.executeDispatchesInOrderStopAtTrue;





var responderID=null;





var trackedTouchCount=0;




var previousActiveTouches=0;

var changeResponder=function(nextResponderID,blockNativeResponder){
var oldResponderID=responderID;
responderID = nextResponderID;
if(ResponderEventPlugin.GlobalResponderHandler !== null){
ResponderEventPlugin.GlobalResponderHandler.onChange(
oldResponderID,
nextResponderID,
blockNativeResponder);}};




var eventTypes={




startShouldSetResponder:{
phasedRegistrationNames:{
bubbled:keyOf({onStartShouldSetResponder:null}),
captured:keyOf({onStartShouldSetResponderCapture:null})}},












scrollShouldSetResponder:{
phasedRegistrationNames:{
bubbled:keyOf({onScrollShouldSetResponder:null}),
captured:keyOf({onScrollShouldSetResponderCapture:null})}},










selectionChangeShouldSetResponder:{
phasedRegistrationNames:{
bubbled:keyOf({onSelectionChangeShouldSetResponder:null}),
captured:keyOf({onSelectionChangeShouldSetResponderCapture:null})}},







moveShouldSetResponder:{
phasedRegistrationNames:{
bubbled:keyOf({onMoveShouldSetResponder:null}),
captured:keyOf({onMoveShouldSetResponderCapture:null})}},






responderStart:{registrationName:keyOf({onResponderStart:null})},
responderMove:{registrationName:keyOf({onResponderMove:null})},
responderEnd:{registrationName:keyOf({onResponderEnd:null})},
responderRelease:{registrationName:keyOf({onResponderRelease:null})},
responderTerminationRequest:{
registrationName:keyOf({onResponderTerminationRequest:null})},

responderGrant:{registrationName:keyOf({onResponderGrant:null})},
responderReject:{registrationName:keyOf({onResponderReject:null})},
responderTerminate:{registrationName:keyOf({onResponderTerminate:null})}};






































































































































































































function setResponderAndExtractTransfer(
topLevelType,
topLevelTargetID,
nativeEvent){
var shouldSetEventType=
isStartish(topLevelType)?eventTypes.startShouldSetResponder:
isMoveish(topLevelType)?eventTypes.moveShouldSetResponder:
topLevelType === EventConstants.topLevelTypes.topSelectionChange?
eventTypes.selectionChangeShouldSetResponder:
eventTypes.scrollShouldSetResponder;


var bubbleShouldSetFrom=!responderID?
topLevelTargetID:
ReactInstanceHandles._getFirstCommonAncestorID(responderID,topLevelTargetID);





var skipOverBubbleShouldSetFrom=bubbleShouldSetFrom === responderID;
var shouldSetEvent=ResponderSyntheticEvent.getPooled(
shouldSetEventType,
bubbleShouldSetFrom,
nativeEvent);

shouldSetEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
if(skipOverBubbleShouldSetFrom){
EventPropagators.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent);}else 
{
EventPropagators.accumulateTwoPhaseDispatches(shouldSetEvent);}

var wantsResponderID=executeDispatchesInOrderStopAtTrue(shouldSetEvent);
if(!shouldSetEvent.isPersistent()){
shouldSetEvent.constructor.release(shouldSetEvent);}


if(!wantsResponderID || wantsResponderID === responderID){
return null;}

var extracted;
var grantEvent=ResponderSyntheticEvent.getPooled(
eventTypes.responderGrant,
wantsResponderID,
nativeEvent);

grantEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;

EventPropagators.accumulateDirectDispatches(grantEvent);
var blockNativeResponder=executeDirectDispatch(grantEvent) === true;
if(responderID){

var terminationRequestEvent=ResponderSyntheticEvent.getPooled(
eventTypes.responderTerminationRequest,
responderID,
nativeEvent);

terminationRequestEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
EventPropagators.accumulateDirectDispatches(terminationRequestEvent);
var shouldSwitch=!hasDispatches(terminationRequestEvent) || 
executeDirectDispatch(terminationRequestEvent);
if(!terminationRequestEvent.isPersistent()){
terminationRequestEvent.constructor.release(terminationRequestEvent);}


if(shouldSwitch){
var terminateType=eventTypes.responderTerminate;
var terminateEvent=ResponderSyntheticEvent.getPooled(
terminateType,
responderID,
nativeEvent);

terminateEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
EventPropagators.accumulateDirectDispatches(terminateEvent);
extracted = accumulate(extracted,[grantEvent,terminateEvent]);
changeResponder(wantsResponderID,blockNativeResponder);}else 
{
var rejectEvent=ResponderSyntheticEvent.getPooled(
eventTypes.responderReject,
wantsResponderID,
nativeEvent);

rejectEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
EventPropagators.accumulateDirectDispatches(rejectEvent);
extracted = accumulate(extracted,rejectEvent);}}else 

{
extracted = accumulate(extracted,grantEvent);
changeResponder(wantsResponderID,blockNativeResponder);}

return extracted;}










function canTriggerTransfer(topLevelType,topLevelTargetID){
return topLevelTargetID && (
topLevelType === EventConstants.topLevelTypes.topScroll || 
trackedTouchCount > 0 && 
topLevelType === EventConstants.topLevelTypes.topSelectionChange || 
isStartish(topLevelType) || 
isMoveish(topLevelType));}










function noResponderTouches(nativeEvent){
var touches=nativeEvent.touches;
if(!touches || touches.length === 0){
return true;}

for(var i=0;i < touches.length;i++) {
var activeTouch=touches[i];
var target=activeTouch.target;
if(target !== null && target !== undefined && target !== 0){

var commonAncestor=
ReactInstanceHandles._getFirstCommonAncestorID(
responderID,
NodeHandle.getRootNodeID(target));

if(commonAncestor === responderID){
return false;}}}



return true;}



var ResponderEventPlugin={

getResponderID:function(){
return responderID;},


eventTypes:eventTypes,













extractEvents:function(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent){

if(isStartish(topLevelType)){
trackedTouchCount += 1;}else 
if(isEndish(topLevelType)){
trackedTouchCount -= 1;
invariant(
trackedTouchCount >= 0,
'Ended a touch event which was not counted in trackedTouchCount.');}



ResponderTouchHistoryStore.recordTouchTrack(topLevelType,nativeEvent);

var extracted=canTriggerTransfer(topLevelType,topLevelTargetID)?
setResponderAndExtractTransfer(topLevelType,topLevelTargetID,nativeEvent):
null;










var isResponderTouchStart=responderID && isStartish(topLevelType);
var isResponderTouchMove=responderID && isMoveish(topLevelType);
var isResponderTouchEnd=responderID && isEndish(topLevelType);
var incrementalTouch=
isResponderTouchStart?eventTypes.responderStart:
isResponderTouchMove?eventTypes.responderMove:
isResponderTouchEnd?eventTypes.responderEnd:
null;

if(incrementalTouch){
var gesture=
ResponderSyntheticEvent.getPooled(incrementalTouch,responderID,nativeEvent);
gesture.touchHistory = ResponderTouchHistoryStore.touchHistory;
EventPropagators.accumulateDirectDispatches(gesture);
extracted = accumulate(extracted,gesture);}


var isResponderTerminate=
responderID && 
topLevelType === EventConstants.topLevelTypes.topTouchCancel;
var isResponderRelease=
responderID && 
!isResponderTerminate && 
isEndish(topLevelType) && 
noResponderTouches(nativeEvent);
var finalTouch=
isResponderTerminate?eventTypes.responderTerminate:
isResponderRelease?eventTypes.responderRelease:
null;
if(finalTouch){
var finalEvent=
ResponderSyntheticEvent.getPooled(finalTouch,responderID,nativeEvent);
finalEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
EventPropagators.accumulateDirectDispatches(finalEvent);
extracted = accumulate(extracted,finalEvent);
changeResponder(null);}


var numberActiveTouches=
ResponderTouchHistoryStore.touchHistory.numberActiveTouches;
if(ResponderEventPlugin.GlobalInteractionHandler && 
numberActiveTouches !== previousActiveTouches){
ResponderEventPlugin.GlobalInteractionHandler.onChange(
numberActiveTouches);}


previousActiveTouches = numberActiveTouches;

return extracted;},


GlobalResponderHandler:null,
GlobalInteractionHandler:null,

injection:{





injectGlobalResponderHandler:function(GlobalResponderHandler){
ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;},






injectGlobalInteractionHandler:function(GlobalInteractionHandler){
ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;}}};




module.exports = ResponderEventPlugin;
});
__d('ResponderSyntheticEvent',["SyntheticEvent"],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";




















var SyntheticEvent=require("SyntheticEvent");






var ResponderEventInterface={
touchHistory:function(nativeEvent){
return null;}};









function ResponderSyntheticEvent(dispatchConfig,dispatchMarker,nativeEvent){
SyntheticEvent.call(this,dispatchConfig,dispatchMarker,nativeEvent);}


SyntheticEvent.augmentClass(ResponderSyntheticEvent,ResponderEventInterface);

module.exports = ResponderSyntheticEvent;
});
__d('ResponderTouchHistoryStore',["EventPluginUtils","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';





var EventPluginUtils=require('EventPluginUtils');

var invariant=require('invariant');

var isMoveish=EventPluginUtils.isMoveish;
var isStartish=EventPluginUtils.isStartish;
var isEndish=EventPluginUtils.isEndish;

var MAX_TOUCH_BANK=20;
















var touchHistory={
touchBank:[],
numberActiveTouches:0,



indexOfSingleActiveTouch:-1,
mostRecentTimeStamp:0};


var timestampForTouch=function(touch){



return touch.timeStamp || touch.timestamp;};







var initializeTouchData=function(touch){
return {
touchActive:true,
startTimeStamp:timestampForTouch(touch),
startPageX:touch.pageX,
startPageY:touch.pageY,
currentPageX:touch.pageX,
currentPageY:touch.pageY,
currentTimeStamp:timestampForTouch(touch),
previousPageX:touch.pageX,
previousPageY:touch.pageY,
previousTimeStamp:timestampForTouch(touch)};};



var reinitializeTouchTrack=function(touchTrack,touch){
touchTrack.touchActive = true;
touchTrack.startTimeStamp = timestampForTouch(touch);
touchTrack.startPageX = touch.pageX;
touchTrack.startPageY = touch.pageY;
touchTrack.currentPageX = touch.pageX;
touchTrack.currentPageY = touch.pageY;
touchTrack.currentTimeStamp = timestampForTouch(touch);
touchTrack.previousPageX = touch.pageX;
touchTrack.previousPageY = touch.pageY;
touchTrack.previousTimeStamp = timestampForTouch(touch);};


var validateTouch=function(touch){
var identifier=touch.identifier;
invariant(identifier != null,'Touch object is missing identifier');
if(identifier > MAX_TOUCH_BANK){
console.warn(
'Touch identifier ' + identifier + ' is greater than maximum ' + 
'supported ' + MAX_TOUCH_BANK + ' which causes performance issues ' + 
'backfilling array locations for all of the indices.');}};




var recordStartTouchData=function(touch){
var touchBank=touchHistory.touchBank;
var identifier=touch.identifier;
var touchTrack=touchBank[identifier];
if(__DEV__){
validateTouch(touch);}

if(!touchTrack){
touchBank[touch.identifier] = initializeTouchData(touch);}else 
{
reinitializeTouchTrack(touchTrack,touch);}

touchHistory.mostRecentTimeStamp = timestampForTouch(touch);};


var recordMoveTouchData=function(touch){
var touchBank=touchHistory.touchBank;
var touchTrack=touchBank[touch.identifier];
if(__DEV__){
validateTouch(touch);
invariant(touchTrack,'Touch data should have been recorded on start');}

touchTrack.touchActive = true;
touchTrack.previousPageX = touchTrack.currentPageX;
touchTrack.previousPageY = touchTrack.currentPageY;
touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;
touchTrack.currentPageX = touch.pageX;
touchTrack.currentPageY = touch.pageY;
touchTrack.currentTimeStamp = timestampForTouch(touch);
touchHistory.mostRecentTimeStamp = timestampForTouch(touch);};


var recordEndTouchData=function(touch){
var touchBank=touchHistory.touchBank;
var touchTrack=touchBank[touch.identifier];
if(__DEV__){
validateTouch(touch);
invariant(touchTrack,'Touch data should have been recorded on start');}

touchTrack.previousPageX = touchTrack.currentPageX;
touchTrack.previousPageY = touchTrack.currentPageY;
touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;
touchTrack.currentPageX = touch.pageX;
touchTrack.currentPageY = touch.pageY;
touchTrack.currentTimeStamp = timestampForTouch(touch);
touchTrack.touchActive = false;
touchHistory.mostRecentTimeStamp = timestampForTouch(touch);};


var ResponderTouchHistoryStore={
recordTouchTrack:function(topLevelType,nativeEvent){
var touchBank=touchHistory.touchBank;
if(isMoveish(topLevelType)){
nativeEvent.changedTouches.forEach(recordMoveTouchData);}else 
if(isStartish(topLevelType)){
nativeEvent.changedTouches.forEach(recordStartTouchData);
touchHistory.numberActiveTouches = nativeEvent.touches.length;
if(touchHistory.numberActiveTouches === 1){
touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier;}}else 

if(isEndish(topLevelType)){
nativeEvent.changedTouches.forEach(recordEndTouchData);
touchHistory.numberActiveTouches = nativeEvent.touches.length;
if(touchHistory.numberActiveTouches === 1){
for(var i=0;i < touchBank.length;i++) {
var touchTrackToCheck=touchBank[i];
if(touchTrackToCheck != null && touchTrackToCheck.touchActive){
touchHistory.indexOfSingleActiveTouch = i;
break;}}


if(__DEV__){
var activeTouchData=touchBank[touchHistory.indexOfSingleActiveTouch];
var foundActive=activeTouchData != null && !!activeTouchData.touchActive;
invariant(foundActive,'Cannot find single active touch');}}}},





touchHistory:touchHistory};



module.exports = ResponderTouchHistoryStore;
});
__d('accumulate',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');








function accumulate(current,next){
invariant(
next != null,
'accumulate(...): Accumulated items must be not be null or undefined.');

if(current == null){
return next;}else 
{


var currentIsArray=Array.isArray(current);
var nextIsArray=Array.isArray(next);
if(currentIsArray){
return current.concat(next);}else 
{
if(nextIsArray){
return [current].concat(next);}else 
{
return [current,next];}}}}





module.exports = accumulate;
});
__d('UniversalWorkerNodeHandle',["ReactNativeTagHandles","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 



ReactNativeTagHandles=require('ReactNativeTagHandles');

var invariant=require('invariant');

var UniversalWorkerNodeHandle={
getRootNodeID:function(nodeHandle){
invariant(
nodeHandle !== undefined && nodeHandle !== null && nodeHandle !== 0,
'No node handle defined');

return ReactNativeTagHandles.tagToRootNodeID[nodeHandle];}};



module.exports = UniversalWorkerNodeHandle;
});
__d('createReactNativeComponentClass',["ReactNativeBaseComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactNativeBaseComponent=require('ReactNativeBaseComponent');











var createReactNativeComponentClass=function(
viewConfig)
{
var Constructor=function(element){
this._currentElement = element;

this._rootNodeID = null;
this._renderedChildren = null;
this.previousFlattenedStyle = null;};

Constructor.displayName = viewConfig.uiViewClassName;
Constructor.viewConfig = viewConfig;
Constructor.prototype = new ReactNativeBaseComponent(viewConfig);
Constructor.prototype.constructor = Constructor;

return Constructor;};


module.exports = createReactNativeComponentClass;
});
__d('ReactNativeBaseComponent',["NativeMethodsMixin","ReactNativeEventEmitter","ReactNativeStyleAttributes","ReactNativeTagHandles","ReactMultiChild","NativeModules","styleDiffer","deepFreezeAndThrowOnMutationInDev","diffRawProperties","flattenStyle","precomputeStyle","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeMethodsMixin=require('NativeMethodsMixin');
var ReactNativeEventEmitter=require('ReactNativeEventEmitter');
var ReactNativeStyleAttributes=require('ReactNativeStyleAttributes');
var ReactNativeTagHandles=require('ReactNativeTagHandles');
var ReactMultiChild=require('ReactMultiChild');
var RCTUIManager=require('NativeModules').UIManager;

var styleDiffer=require('styleDiffer');
var deepFreezeAndThrowOnMutationInDev=require('deepFreezeAndThrowOnMutationInDev');
var diffRawProperties=require('diffRawProperties');
var flattenStyle=require('flattenStyle');
var precomputeStyle=require('precomputeStyle');
var warning=require('warning');

var registrationNames=ReactNativeEventEmitter.registrationNames;
var putListener=ReactNativeEventEmitter.putListener;
var deleteAllListeners=ReactNativeEventEmitter.deleteAllListeners;












var ReactNativeBaseComponent=function(
viewConfig)
{
this.viewConfig = viewConfig;};












var cachedIndexArray=function(size){
var cachedResult=cachedIndexArray._cache[size];
if(!cachedResult){
var arr=[];
for(var i=0;i < size;i++) {
arr[i] = i;}

cachedIndexArray._cache[size] = arr;
return arr;}else 
{
return cachedResult;}};


cachedIndexArray._cache = {};





ReactNativeBaseComponent.Mixin = {
getPublicInstance:function(){

return this;},


construct:function(element){
this._currentElement = element;},


unmountComponent:function(){
deleteAllListeners(this._rootNodeID);
this.unmountChildren();
this._rootNodeID = null;},










initializeChildren:function(children,containerTag,transaction,context){
var mountImages=this.mountChildren(children,transaction,context);



if(mountImages.length){
var indexes=cachedIndexArray(mountImages.length);


var createdTags=[];
for(var i=0;i < mountImages.length;i++) {
var mountImage=mountImages[i];
var childTag=mountImage.tag;
var childID=mountImage.rootNodeID;
warning(
mountImage && mountImage.rootNodeID && mountImage.tag,
'Mount image returned does not have required data');

ReactNativeTagHandles.associateRootNodeIDWithMountedNodeHandle(
childID,
childTag);

createdTags[i] = mountImage.tag;}

RCTUIManager.
manageChildren(containerTag,null,null,createdTags,indexes,null);}},












computeUpdatedProperties:function(prevProps,nextProps,validAttributes){
if(__DEV__){
for(var key in nextProps) {
if(nextProps.hasOwnProperty(key) && 
nextProps[key] && 
validAttributes[key]){
deepFreezeAndThrowOnMutationInDev(nextProps[key]);}}}




var updatePayload=diffRawProperties(
null,
prevProps,
nextProps,
validAttributes);







if(styleDiffer(nextProps.style,prevProps.style)){
var nextFlattenedStyle=precomputeStyle(flattenStyle(nextProps.style));
updatePayload = diffRawProperties(
updatePayload,
this.previousFlattenedStyle,
nextFlattenedStyle,
ReactNativeStyleAttributes);

this.previousFlattenedStyle = nextFlattenedStyle;}


return updatePayload;},











receiveComponent:function(nextElement,transaction,context){
var prevElement=this._currentElement;
this._currentElement = nextElement;

var updatePayload=this.computeUpdatedProperties(
prevElement.props,
nextElement.props,
this.viewConfig.validAttributes);


if(updatePayload){
RCTUIManager.updateView(
ReactNativeTagHandles.mostRecentMountedNodeHandleForRootNodeID(this._rootNodeID),
this.viewConfig.uiViewClassName,
updatePayload);}



this._reconcileListenersUponUpdate(
prevElement.props,
nextElement.props);

this.updateChildren(nextElement.props.children,transaction,context);},





_registerListenersUponCreation:function(initialProps){
for(var key in initialProps) {


if(registrationNames[key] && initialProps[key]){
var listener=initialProps[key];
putListener(this._rootNodeID,key,listener);}}},









_reconcileListenersUponUpdate:function(prevProps,nextProps){
for(var key in nextProps) {
if(registrationNames[key] && nextProps[key] !== prevProps[key]){
putListener(this._rootNodeID,key,nextProps[key]);}}},









mountComponent:function(rootID,transaction,context){
this._rootNodeID = rootID;

var tag=ReactNativeTagHandles.allocateTag();

this.previousFlattenedStyle = {};
var updatePayload=this.computeUpdatedProperties(
{},
this._currentElement.props,
this.viewConfig.validAttributes);


var nativeTopRootID=ReactNativeTagHandles.getNativeTopRootIDFromNodeID(rootID);
RCTUIManager.createView(
tag,
this.viewConfig.uiViewClassName,
nativeTopRootID?ReactNativeTagHandles.rootNodeIDToTag[nativeTopRootID]:null,
updatePayload);


this._registerListenersUponCreation(this._currentElement.props);
this.initializeChildren(
this._currentElement.props.children,
tag,
transaction,
context);

return {
rootNodeID:rootID,
tag:tag};}};








Object.assign(
ReactNativeBaseComponent.prototype,
ReactMultiChild.Mixin,
ReactNativeBaseComponent.Mixin,
NativeMethodsMixin);


module.exports = ReactNativeBaseComponent;
});
__d('NativeMethodsMixin',["NativeModules","TextInputState","findNodeHandle","flattenStyle","invariant","mergeFast","precomputeStyle"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeModules=require('NativeModules');
var RCTPOPAnimationManager=NativeModules.POPAnimationManager;
var RCTUIManager=NativeModules.UIManager;
var TextInputState=require('TextInputState');

var findNodeHandle=require('findNodeHandle');
var flattenStyle=require('flattenStyle');
var invariant=require('invariant');
var mergeFast=require('mergeFast');
var precomputeStyle=require('precomputeStyle');

















var animationIDInvariant=function(
funcName,
anim)
{
invariant(
anim,
funcName + ' must be called with a valid animation ID returned from' + 
' POPAnimation.createAnimation, received: "' + anim + '"');};



var NativeMethodsMixin={
addAnimation:function(anim,callback){
animationIDInvariant('addAnimation',anim);
RCTPOPAnimationManager.addAnimation(
findNodeHandle(this),
anim,
mountSafeCallback(this,callback));},



removeAnimation:function(anim){
animationIDInvariant('removeAnimation',anim);
RCTPOPAnimationManager.removeAnimation(findNodeHandle(this),anim);},


measure:function(callback){
RCTUIManager.measure(
findNodeHandle(this),
mountSafeCallback(this,callback));},



measureLayout:function(
relativeToNativeNode,
onSuccess,
onFail)
{
RCTUIManager.measureLayout(
findNodeHandle(this),
relativeToNativeNode,
mountSafeCallback(this,onFail),
mountSafeCallback(this,onSuccess));},








setNativeProps:function(nativeProps){





var hasOnlyStyle=true;
for(var key in nativeProps) {
if(key !== 'style'){
hasOnlyStyle = false;
break;}}


var style=precomputeStyle(flattenStyle(nativeProps.style));

var props=null;
if(hasOnlyStyle){
props = style;}else 
if(!style){
props = nativeProps;}else 
{
props = mergeFast(nativeProps,style);}


RCTUIManager.updateView(
findNodeHandle(this),
this.viewConfig.uiViewClassName,
props);},



focus:function(){
TextInputState.focusTextInput(findNodeHandle(this));},


blur:function(){
TextInputState.blurTextInput(findNodeHandle(this));}};



function throwOnStylesProp(component,props){
if(props.styles !== undefined){
var owner=component._owner || null;
var name=component.constructor.displayName;
var msg='`styles` is not a supported property of `' + name + '`, did ' + 
'you mean `style` (singular)?';
if(owner && owner.constructor && owner.constructor.displayName){
msg += '\n\nCheck the `' + owner.constructor.displayName + '` parent ' + 
' component.';}

throw new Error(msg);}}


if(__DEV__){



var NativeMethodsMixin_DEV=NativeMethodsMixin;
invariant(
!NativeMethodsMixin_DEV.componentWillMount && 
!NativeMethodsMixin_DEV.componentWillReceiveProps,
'Do not override existing functions.');

NativeMethodsMixin_DEV.componentWillMount = function(){
throwOnStylesProp(this,this.props);};

NativeMethodsMixin_DEV.componentWillReceiveProps = function(newProps){
throwOnStylesProp(this,newProps);};}







var mountSafeCallback=function(context,callback){
return function(){
if(!callback || context.isMounted && !context.isMounted()){
return;}

return callback.apply(context,arguments);};};



module.exports = NativeMethodsMixin;
});
__d('TextInputState',["NativeModules"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';
















var RCTUIManager=require('NativeModules').UIManager;

var TextInputState={



_currentlyFocusedID:null,





currentlyFocusedField:function(){
return this._currentlyFocusedID;},







focusTextInput:function(textFieldID){
if(this._currentlyFocusedID !== textFieldID && textFieldID !== null){
this._currentlyFocusedID = textFieldID;
RCTUIManager.focus(textFieldID);}},








blurTextInput:function(textFieldID){
if(this._currentlyFocusedID === textFieldID && textFieldID !== null){
this._currentlyFocusedID = null;
RCTUIManager.blur(textFieldID);}}};




module.exports = TextInputState;
});
__d('findNodeHandle',["ReactCurrentOwner","ReactInstanceMap","ReactNativeTagHandles","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactNativeTagHandles=require('ReactNativeTagHandles');

var invariant=require('invariant');
var warning=require('warning');































function findNodeHandle(componentOrHandle){
if(__DEV__){
var owner=ReactCurrentOwner.current;
if(owner !== null){
warning(
owner._warnedAboutRefsInRender,
'%s is accessing findNodeHandle inside its render(). ' + 
'render() should be a pure function of props and state. It should ' + 
'never access something that requires stale data from the previous ' + 
'render, such as refs. Move this logic to componentDidMount and ' + 
'componentDidUpdate instead.',
owner.getName() || 'A component');

owner._warnedAboutRefsInRender = true;}}


if(componentOrHandle == null){
return null;}

if(typeof componentOrHandle === 'number'){

return componentOrHandle;}


var component=componentOrHandle;



var internalInstance=ReactInstanceMap.get(component);
if(internalInstance){
return ReactNativeTagHandles.rootNodeIDToTag[internalInstance._rootNodeID];}else 
{
var rootNodeID=component._rootNodeID;
if(rootNodeID){
return ReactNativeTagHandles.rootNodeIDToTag[rootNodeID];}else 
{
invariant(


typeof component === 'object' && 
'_rootNodeID' in component || 


component.render != null && 
typeof component.render === 'function',

'findNodeHandle(...): Argument is not a component ' + 
'(type: %s, keys: %s)',
typeof component,
Object.keys(component));

invariant(
false,
'findNodeHandle(...): Unable to find node handle for unmounted ' + 
'component.');}}}





module.exports = findNodeHandle;
});
__d('flattenStyle',["StyleSheetRegistry","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var StyleSheetRegistry=require('StyleSheetRegistry');
var invariant=require('invariant');




function getStyle(style){
if(typeof style === 'number'){
return StyleSheetRegistry.getStyleByID(style);}

return style;}


function flattenStyle(style){
if(!style){
return undefined;}

invariant(style !== true,'style may be false but not true');

if(!Array.isArray(style)){
return getStyle(style);}


var result={};
for(var i=0;i < style.length;++i) {
var computedStyle=flattenStyle(style[i]);
if(computedStyle){
for(var key in computedStyle) {
result[key] = computedStyle[key];

if(__DEV__){
var value=computedStyle[key];}}}}




return result;}


module.exports = flattenStyle;
});
__d('StyleSheetRegistry',[],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var styles={};
var uniqueID=1;
var emptyStyle={};var 

StyleSheetRegistry=(function(){function StyleSheetRegistry(){_classCallCheck(this,StyleSheetRegistry);}_createClass(StyleSheetRegistry,null,[{key:'registerStyle',value:
function registerStyle(style){
var id=++uniqueID;
if(__DEV__){
Object.freeze(style);}

styles[id] = style;
return id;}},{key:'getStyleByID',value:


function getStyleByID(id){
if(!id){


return emptyStyle;}


var style=styles[id];
if(!style){
console.warn('Invalid style with id `' + id + '`. Skipping ...');
return emptyStyle;}

return style;}}]);return StyleSheetRegistry;})();



module.exports = StyleSheetRegistry;
});
__d('mergeFast',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';





















var mergeFast=function(one,two){
var ret={};
for(var keyOne in one) {
ret[keyOne] = one[keyOne];}

for(var keyTwo in two) {
ret[keyTwo] = two[keyTwo];}

return ret;};


module.exports = mergeFast;
});
__d('precomputeStyle',["MatrixMath","Platform","deepFreezeAndThrowOnMutationInDev","invariant","stringifySafe"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var MatrixMath=require('MatrixMath');
var Platform=require('Platform');

var deepFreezeAndThrowOnMutationInDev=require('deepFreezeAndThrowOnMutationInDev');
var invariant=require('invariant');
var stringifySafe=require('stringifySafe');





function precomputeStyle(style){
if(!style || !style.transform){
return style;}

invariant(
!style.transformMatrix,
'transformMatrix and transform styles cannot be used on the same component');

var newStyle=_precomputeTransforms(_extends({},style));
deepFreezeAndThrowOnMutationInDev(newStyle);
return newStyle;}










function _precomputeTransforms(style){var 
transform=style.transform;
var result=MatrixMath.createIdentityMatrix();

transform.forEach(function(transformation){
var key=Object.keys(transformation)[0];
var value=transformation[key];
if(__DEV__){
_validateTransform(key,value,transformation);}


switch(key){
case 'matrix':
MatrixMath.multiplyInto(result,result,value);
break;
case 'rotate':
_multiplyTransform(result,MatrixMath.reuseRotateZCommand,[_convertToRadians(value)]);
break;
case 'scale':
_multiplyTransform(result,MatrixMath.reuseScaleCommand,[value]);
break;
case 'scaleX':
_multiplyTransform(result,MatrixMath.reuseScaleXCommand,[value]);
break;
case 'scaleY':
_multiplyTransform(result,MatrixMath.reuseScaleYCommand,[value]);
break;
case 'translate':
_multiplyTransform(result,MatrixMath.reuseTranslate3dCommand,[value[0],value[1],value[2] || 0]);
break;
case 'translateX':
_multiplyTransform(result,MatrixMath.reuseTranslate2dCommand,[value,0]);
break;
case 'translateY':
_multiplyTransform(result,MatrixMath.reuseTranslate2dCommand,[0,value]);
break;
default:
throw new Error('Invalid transform name: ' + key);}});







if(Platform.OS === 'android'){
return _extends({},
style,{
transformMatrix:result,
decomposedMatrix:MatrixMath.decomposeMatrix(result)});}


return _extends({},
style,{
transformMatrix:result});}






function _multiplyTransform(
result,
matrixMathFunction,
args)
{
var matrixToApply=MatrixMath.createIdentityMatrix();
var argsWithIdentity=[matrixToApply].concat(args);
matrixMathFunction.apply(this,argsWithIdentity);
MatrixMath.multiplyInto(result,result,matrixToApply);}






function _convertToRadians(value){
var floatValue=parseFloat(value,10);
return value.indexOf('rad') > -1?floatValue:floatValue * Math.PI / 180;}


function _validateTransform(key,value,transformation){
invariant(
!value.getValue,
'You passed an Animated.Value to a normal component. ' + 
'You need to wrap that component in an Animated. For example, ' + 
'replace <View /> by <Animated.View />.');


var multivalueTransforms=[
'matrix',
'translate'];

if(multivalueTransforms.indexOf(key) !== -1){
invariant(
Array.isArray(value),
'Transform with key of %s must have an array as the value: %s',
key,
stringifySafe(transformation));}


switch(key){
case 'matrix':
invariant(
value.length === 9 || value.length === 16,
'Matrix transform must have a length of 9 (2d) or 16 (3d). ' + 
'Provided matrix has a length of %s: %s',
value.length,
stringifySafe(transformation));

break;
case 'translate':
break;
case 'rotate':
invariant(
typeof value === 'string',
'Transform with key of "%s" must be a string: %s',
key,
stringifySafe(transformation));

invariant(
value.indexOf('deg') > -1 || value.indexOf('rad') > -1,
'Rotate transform must be expressed in degrees (deg) or radians ' + 
'(rad): %s',
stringifySafe(transformation));

break;
default:
invariant(
typeof value === 'number',
'Transform with key of "%s" must be a number: %s',
key,
stringifySafe(transformation));}}




module.exports = precomputeStyle;
});
__d('MatrixMath',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';







var invariant=require('invariant');





var MatrixMath={
createIdentityMatrix:function(){
return [
1,0,0,0,
0,1,0,0,
0,0,1,0,
0,0,0,1];},



createCopy:function(m){
return [
m[0],m[1],m[2],m[3],
m[4],m[5],m[6],m[7],
m[8],m[9],m[10],m[11],
m[12],m[13],m[14],m[15]];},



createTranslate2d:function(x,y){
var mat=MatrixMath.createIdentityMatrix();
MatrixMath.reuseTranslate2dCommand(mat,x,y);
return mat;},


reuseTranslate2dCommand:function(matrixCommand,x,y){
matrixCommand[12] = x;
matrixCommand[13] = y;},


reuseTranslate3dCommand:function(matrixCommand,x,y,z){
matrixCommand[12] = x;
matrixCommand[13] = y;
matrixCommand[14] = z;},


createScale:function(factor){
var mat=MatrixMath.createIdentityMatrix();
MatrixMath.reuseScaleCommand(mat,factor);
return mat;},


reuseScaleCommand:function(matrixCommand,factor){
matrixCommand[0] = factor;
matrixCommand[5] = factor;},


reuseScale3dCommand:function(matrixCommand,x,y,z){
matrixCommand[0] = x;
matrixCommand[5] = y;
matrixCommand[10] = z;},


reuseScaleXCommand:function(matrixCommand,factor){
matrixCommand[0] = factor;},


reuseScaleYCommand:function(matrixCommand,factor){
matrixCommand[5] = factor;},


reuseScaleZCommand:function(matrixCommand,factor){
matrixCommand[10] = factor;},


reuseRotateXCommand:function(matrixCommand,radians){
matrixCommand[5] = Math.cos(radians);
matrixCommand[6] = Math.sin(radians);
matrixCommand[9] = -Math.sin(radians);
matrixCommand[10] = Math.cos(radians);},


reuseRotateYCommand:function(matrixCommand,amount){
matrixCommand[0] = Math.cos(amount);
matrixCommand[2] = -Math.sin(amount);
matrixCommand[8] = Math.sin(amount);
matrixCommand[10] = Math.cos(amount);},



reuseRotateZCommand:function(matrixCommand,radians){
matrixCommand[0] = Math.cos(radians);
matrixCommand[1] = Math.sin(radians);
matrixCommand[4] = -Math.sin(radians);
matrixCommand[5] = Math.cos(radians);},


createRotateZ:function(radians){
var mat=MatrixMath.createIdentityMatrix();
MatrixMath.reuseRotateZCommand(mat,radians);
return mat;},


multiplyInto:function(out,a,b){
var a00=a[0],a01=a[1],a02=a[2],a03=a[3],
a10=a[4],a11=a[5],a12=a[6],a13=a[7],
a20=a[8],a21=a[9],a22=a[10],a23=a[11],
a30=a[12],a31=a[13],a32=a[14],a33=a[15];

var b0=b[0],b1=b[1],b2=b[2],b3=b[3];
out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;

b0 = b[4];b1 = b[5];b2 = b[6];b3 = b[7];
out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;

b0 = b[8];b1 = b[9];b2 = b[10];b3 = b[11];
out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;

b0 = b[12];b1 = b[13];b2 = b[14];b3 = b[15];
out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;},


determinant:function(matrix){var 

m00=



matrix[0];var m01=matrix[1];var m02=matrix[2];var m03=matrix[3];var m10=matrix[4];var m11=matrix[5];var m12=matrix[6];var m13=matrix[7];var m20=matrix[8];var m21=matrix[9];var m22=matrix[10];var m23=matrix[11];var m30=matrix[12];var m31=matrix[13];var m32=matrix[14];var m33=matrix[15];
return (
m03 * m12 * m21 * m30 - m02 * m13 * m21 * m30 - 
m03 * m11 * m22 * m30 + m01 * m13 * m22 * m30 + 
m02 * m11 * m23 * m30 - m01 * m12 * m23 * m30 - 
m03 * m12 * m20 * m31 + m02 * m13 * m20 * m31 + 
m03 * m10 * m22 * m31 - m00 * m13 * m22 * m31 - 
m02 * m10 * m23 * m31 + m00 * m12 * m23 * m31 + 
m03 * m11 * m20 * m32 - m01 * m13 * m20 * m32 - 
m03 * m10 * m21 * m32 + m00 * m13 * m21 * m32 + 
m01 * m10 * m23 * m32 - m00 * m11 * m23 * m32 - 
m02 * m11 * m20 * m33 + m01 * m12 * m20 * m33 + 
m02 * m10 * m21 * m33 - m00 * m12 * m21 * m33 - 
m01 * m10 * m22 * m33 + m00 * m11 * m22 * m33);},










inverse:function(matrix){
var det=MatrixMath.determinant(matrix);
if(!det){
return matrix;}var 


m00=



matrix[0];var m01=matrix[1];var m02=matrix[2];var m03=matrix[3];var m10=matrix[4];var m11=matrix[5];var m12=matrix[6];var m13=matrix[7];var m20=matrix[8];var m21=matrix[9];var m22=matrix[10];var m23=matrix[11];var m30=matrix[12];var m31=matrix[13];var m32=matrix[14];var m33=matrix[15];
return [
(m12 * m23 * m31 - m13 * m22 * m31 + m13 * m21 * m32 - m11 * m23 * m32 - m12 * m21 * m33 + m11 * m22 * m33) / det,
(m03 * m22 * m31 - m02 * m23 * m31 - m03 * m21 * m32 + m01 * m23 * m32 + m02 * m21 * m33 - m01 * m22 * m33) / det,
(m02 * m13 * m31 - m03 * m12 * m31 + m03 * m11 * m32 - m01 * m13 * m32 - m02 * m11 * m33 + m01 * m12 * m33) / det,
(m03 * m12 * m21 - m02 * m13 * m21 - m03 * m11 * m22 + m01 * m13 * m22 + m02 * m11 * m23 - m01 * m12 * m23) / det,
(m13 * m22 * m30 - m12 * m23 * m30 - m13 * m20 * m32 + m10 * m23 * m32 + m12 * m20 * m33 - m10 * m22 * m33) / det,
(m02 * m23 * m30 - m03 * m22 * m30 + m03 * m20 * m32 - m00 * m23 * m32 - m02 * m20 * m33 + m00 * m22 * m33) / det,
(m03 * m12 * m30 - m02 * m13 * m30 - m03 * m10 * m32 + m00 * m13 * m32 + m02 * m10 * m33 - m00 * m12 * m33) / det,
(m02 * m13 * m20 - m03 * m12 * m20 + m03 * m10 * m22 - m00 * m13 * m22 - m02 * m10 * m23 + m00 * m12 * m23) / det,
(m11 * m23 * m30 - m13 * m21 * m30 + m13 * m20 * m31 - m10 * m23 * m31 - m11 * m20 * m33 + m10 * m21 * m33) / det,
(m03 * m21 * m30 - m01 * m23 * m30 - m03 * m20 * m31 + m00 * m23 * m31 + m01 * m20 * m33 - m00 * m21 * m33) / det,
(m01 * m13 * m30 - m03 * m11 * m30 + m03 * m10 * m31 - m00 * m13 * m31 - m01 * m10 * m33 + m00 * m11 * m33) / det,
(m03 * m11 * m20 - m01 * m13 * m20 - m03 * m10 * m21 + m00 * m13 * m21 + m01 * m10 * m23 - m00 * m11 * m23) / det,
(m12 * m21 * m30 - m11 * m22 * m30 - m12 * m20 * m31 + m10 * m22 * m31 + m11 * m20 * m32 - m10 * m21 * m32) / det,
(m01 * m22 * m30 - m02 * m21 * m30 + m02 * m20 * m31 - m00 * m22 * m31 - m01 * m20 * m32 + m00 * m21 * m32) / det,
(m02 * m11 * m30 - m01 * m12 * m30 - m02 * m10 * m31 + m00 * m12 * m31 + m01 * m10 * m32 - m00 * m11 * m32) / det,
(m01 * m12 * m20 - m02 * m11 * m20 + m02 * m10 * m21 - m00 * m12 * m21 - m01 * m10 * m22 + m00 * m11 * m22) / det];},






transpose:function(m){
return [
m[0],m[4],m[8],m[12],
m[1],m[5],m[9],m[13],
m[2],m[6],m[10],m[14],
m[3],m[7],m[11],m[15]];},






multiplyVectorByMatrix:function(
v,
m)
{var 
vx=v[0];var vy=v[1];var vz=v[2];var vw=v[3];
return [
vx * m[0] + vy * m[4] + vz * m[8] + vw * m[12],
vx * m[1] + vy * m[5] + vz * m[9] + vw * m[13],
vx * m[2] + vy * m[6] + vz * m[10] + vw * m[14],
vx * m[3] + vy * m[7] + vz * m[11] + vw * m[15]];},






v3Length:function(a){
return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);},





v3Normalize:function(
vector,
v3Length)
{
var im=1 / (v3Length || MatrixMath.v3Length(vector));
return [
vector[0] * im,
vector[1] * im,
vector[2] * im];},







v3Dot:function(a,b){
return a[0] * b[0] + 
a[1] * b[1] + 
a[2] * b[2];},






v3Combine:function(
a,
b,
aScale,
bScale)
{
return [
aScale * a[0] + bScale * b[0],
aScale * a[1] + bScale * b[1],
aScale * a[2] + bScale * b[2]];},







v3Cross:function(a,b){
return [
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0]];},



















quaternionToDegreesXYZ:function(q,matrix,row){var 
qx=q[0];var qy=q[1];var qz=q[2];var qw=q[3];
var qw2=qw * qw;
var qx2=qx * qx;
var qy2=qy * qy;
var qz2=qz * qz;
var test=qx * qy + qz * qw;
var unit=qw2 + qx2 + qy2 + qz2;
var conv=180 / Math.PI;

if(test > 0.49999 * unit){
return [0,2 * Math.atan2(qx,qw) * conv,90];}

if(test < -0.49999 * unit){
return [0,-2 * Math.atan2(qx,qw) * conv,-90];}


return [
MatrixMath.roundTo3Places(
Math.atan2(2 * qx * qw - 2 * qy * qz,1 - 2 * qx2 - 2 * qz2) * conv),

MatrixMath.roundTo3Places(
Math.atan2(2 * qy * qw - 2 * qx * qz,1 - 2 * qy2 - 2 * qz2) * conv),

MatrixMath.roundTo3Places(
Math.asin(2 * qx * qy + 2 * qz * qw) * conv)];},








roundTo3Places:function(n){
var arr=n.toString().split('e');
return Math.round(arr[0] + 'e' + (arr[1]?+arr[1] - 3:3)) * 0.001;},













decomposeMatrix:function(transformMatrix){

invariant(
transformMatrix.length === 16,
'Matrix decomposition needs a list of 3d matrix values, received %s',
transformMatrix);



var perspective=[];
var quaternion=[];
var scale=[];
var skew=[];
var translation=[];



if(!transformMatrix[15]){
return;}

var matrix=[];
var perspectiveMatrix=[];
for(var i=0;i < 4;i++) {
matrix.push([]);
for(var j=0;j < 4;j++) {
var value=transformMatrix[i * 4 + j] / transformMatrix[15];
matrix[i].push(value);
perspectiveMatrix.push(j === 3?0:value);}}


perspectiveMatrix[15] = 1;


if(!MatrixMath.determinant(perspectiveMatrix)){
return;}



if(matrix[0][3] !== 0 || matrix[1][3] !== 0 || matrix[2][3] !== 0){


var rightHandSide=[
matrix[0][3],
matrix[1][3],
matrix[2][3],
matrix[3][3]];




var inversePerspectiveMatrix=MatrixMath.inverse3x3(
perspectiveMatrix);

var transposedInversePerspectiveMatrix=MatrixMath.transpose4x4(
inversePerspectiveMatrix);

var perspective=MatrixMath.multiplyVectorByMatrix(
rightHandSide,
transposedInversePerspectiveMatrix);}else 

{

perspective[0] = perspective[1] = perspective[2] = 0;
perspective[3] = 1;}



for(var i=0;i < 3;i++) {
translation[i] = matrix[3][i];}




var row=[];
for(i = 0;i < 3;i++) {
row[i] = [
matrix[i][0],
matrix[i][1],
matrix[i][2]];}




scale[0] = MatrixMath.v3Length(row[0]);
row[0] = MatrixMath.v3Normalize(row[0],scale[0]);


skew[0] = MatrixMath.v3Dot(row[0],row[1]);
row[1] = MatrixMath.v3Combine(row[1],row[0],1.0,-skew[0]);


skew[0] = MatrixMath.v3Dot(row[0],row[1]);
row[1] = MatrixMath.v3Combine(row[1],row[0],1.0,-skew[0]);


scale[1] = MatrixMath.v3Length(row[1]);
row[1] = MatrixMath.v3Normalize(row[1],scale[1]);
skew[0] /= scale[1];


skew[1] = MatrixMath.v3Dot(row[0],row[2]);
row[2] = MatrixMath.v3Combine(row[2],row[0],1.0,-skew[1]);
skew[2] = MatrixMath.v3Dot(row[1],row[2]);
row[2] = MatrixMath.v3Combine(row[2],row[1],1.0,-skew[2]);


scale[2] = MatrixMath.v3Length(row[2]);
row[2] = MatrixMath.v3Normalize(row[2],scale[2]);
skew[1] /= scale[2];
skew[2] /= scale[2];




var pdum3=MatrixMath.v3Cross(row[1],row[2]);
if(MatrixMath.v3Dot(row[0],pdum3) < 0){
for(i = 0;i < 3;i++) {
scale[i] *= -1;
row[i][0] *= -1;
row[i][1] *= -1;
row[i][2] *= -1;}}




quaternion[0] = 
0.5 * Math.sqrt(Math.max(1 + row[0][0] - row[1][1] - row[2][2],0));
quaternion[1] = 
0.5 * Math.sqrt(Math.max(1 - row[0][0] + row[1][1] - row[2][2],0));
quaternion[2] = 
0.5 * Math.sqrt(Math.max(1 - row[0][0] - row[1][1] + row[2][2],0));
quaternion[3] = 
0.5 * Math.sqrt(Math.max(1 + row[0][0] + row[1][1] + row[2][2],0));

if(row[2][1] > row[1][2]){
quaternion[0] = -quaternion[0];}

if(row[0][2] > row[2][0]){
quaternion[1] = -quaternion[1];}

if(row[1][0] > row[0][1]){
quaternion[2] = -quaternion[2];}



var rotationDegrees;
if(
quaternion[0] < 0.001 && quaternion[0] >= 0 && 
quaternion[1] < 0.001 && quaternion[1] >= 0)
{

rotationDegrees = [0,0,MatrixMath.roundTo3Places(
Math.atan2(row[0][1],row[0][0]) * 180 / Math.PI)];}else 

{
rotationDegrees = MatrixMath.quaternionToDegreesXYZ(quaternion,matrix,row);}



return {
rotationDegrees:rotationDegrees,
perspective:perspective,
quaternion:quaternion,
scale:scale,
skew:skew,
translation:translation,

rotate:rotationDegrees[2],
scaleX:scale[0],
scaleY:scale[1],
translateX:translation[0],
translateY:translation[1]};}};





module.exports = MatrixMath;
});
__d('deepFreezeAndThrowOnMutationInDev',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






























function deepFreezeAndThrowOnMutationInDev(object){
if(__DEV__){
if(typeof object !== 'object' || 
object === null || 
Object.isFrozen(object) || 
Object.isSealed(object)){
return;}


for(var key in object) {
if(object.hasOwnProperty(key)){
object.__defineGetter__(key,identity.bind(null,object[key]));
object.__defineSetter__(key,throwOnImmutableMutation.bind(null,key));
deepFreezeAndThrowOnMutationInDev(object[key]);}}


Object.freeze(object);
Object.seal(object);}}



function throwOnImmutableMutation(key,value){
throw Error(
'You attempted to set the key `' + key + '` with the value `' + 
JSON.stringify(value) + '` on an object that is meant to be immutable ' + 
'and has been frozen.');}



function identity(value){
return value;}


module.exports = deepFreezeAndThrowOnMutationInDev;
});
__d('ReactNativeEventEmitter',["EventPluginHub","ReactEventEmitterMixin","ReactNativeTagHandles","NodeHandle","EventConstants","merge","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventPluginHub=require('EventPluginHub');
var ReactEventEmitterMixin=require('ReactEventEmitterMixin');
var ReactNativeTagHandles=require('ReactNativeTagHandles');
var NodeHandle=require('NodeHandle');
var EventConstants=require('EventConstants');

var merge=require('merge');
var warning=require('warning');

var topLevelTypes=EventConstants.topLevelTypes;







var EMPTY_NATIVE_EVENT={};








var touchSubsequence=function(touches,indices){
var ret=[];
for(var i=0;i < indices.length;i++) {
ret.push(touches[indices[i]]);}

return ret;};













var removeTouchesAtIndices=function(
touches,
indices)
{
var rippedOut=[];


var temp=touches;
for(var i=0;i < indices.length;i++) {
var index=indices[i];
rippedOut.push(touches[index]);
temp[index] = null;}

var fillAt=0;
for(var j=0;j < temp.length;j++) {
var cur=temp[j];
if(cur !== null){
temp[fillAt++] = cur;}}


temp.length = fillAt;
return rippedOut;};











var ReactNativeEventEmitter=merge(ReactEventEmitterMixin,{

registrationNames:EventPluginHub.registrationNameModules,

putListener:EventPluginHub.putListener,

getListener:EventPluginHub.getListener,

deleteListener:EventPluginHub.deleteListener,

deleteAllListeners:EventPluginHub.deleteAllListeners,











_receiveRootNodeIDEvent:function(
rootNodeID,
topLevelType,
nativeEventParam)
{
var nativeEvent=nativeEventParam || EMPTY_NATIVE_EVENT;
ReactNativeEventEmitter.handleTopLevel(
topLevelType,
rootNodeID,
rootNodeID,
nativeEvent);},










receiveEvent:function(
tag,
topLevelType,
nativeEventParam)
{
var rootNodeID=ReactNativeTagHandles.tagToRootNodeID[tag];
ReactNativeEventEmitter._receiveRootNodeIDEvent(
rootNodeID,
topLevelType,
nativeEventParam);},



























receiveTouches:function(
eventTopLevelType,
touches,
changedIndices)
{
var changedTouches=
eventTopLevelType === topLevelTypes.topTouchEnd || 
eventTopLevelType === topLevelTypes.topTouchCancel?
removeTouchesAtIndices(touches,changedIndices):
touchSubsequence(touches,changedIndices);

for(var jj=0;jj < changedTouches.length;jj++) {
var touch=changedTouches[jj];


touch.changedTouches = changedTouches;
touch.touches = touches;
var nativeEvent=touch;
var rootNodeID=null;
var target=nativeEvent.target;
if(target !== null && target !== undefined){
if(target < ReactNativeTagHandles.tagsStartAt){
if(__DEV__){
warning(
false,
'A view is reporting that a touch occured on tag zero.');}}else 


{
rootNodeID = NodeHandle.getRootNodeID(target);}}


ReactNativeEventEmitter._receiveRootNodeIDEvent(
rootNodeID,
eventTopLevelType,
nativeEvent);}}});





module.exports = ReactNativeEventEmitter;
});
__d('ReactEventEmitterMixin',["EventPluginHub"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventPluginHub=require('EventPluginHub');

function runEventQueueInBatch(events){
EventPluginHub.enqueueEvents(events);
EventPluginHub.processEventQueue();}


var ReactEventEmitterMixin={










handleTopLevel:function(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent){
var events=EventPluginHub.extractEvents(
topLevelType,
topLevelTarget,
topLevelTargetID,
nativeEvent);


runEventQueueInBatch(events);}};



module.exports = ReactEventEmitterMixin;
});
__d('ReactNativeStyleAttributes',["ImageStylePropTypes","TextStylePropTypes","ViewStylePropTypes","keyMirror","matricesDiffer","sizesDiffer"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};













var ImageStylePropTypes=require('ImageStylePropTypes');
var TextStylePropTypes=require('TextStylePropTypes');
var ViewStylePropTypes=require('ViewStylePropTypes');

var keyMirror=require('keyMirror');
var matricesDiffer=require('matricesDiffer');
var sizesDiffer=require('sizesDiffer');

var ReactNativeStyleAttributes=_extends({},
keyMirror(ViewStylePropTypes),
keyMirror(TextStylePropTypes),
keyMirror(ImageStylePropTypes));


ReactNativeStyleAttributes.transformMatrix = {diff:matricesDiffer};
ReactNativeStyleAttributes.shadowOffset = {diff:sizesDiffer};


ReactNativeStyleAttributes.decomposedMatrix = 'decomposedMatrix';

module.exports = ReactNativeStyleAttributes;
});
__d('ImageStylePropTypes',["ImageResizeMode","LayoutPropTypes","ReactPropTypes","TransformPropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var ImageResizeMode=require('ImageResizeMode');
var LayoutPropTypes=require('LayoutPropTypes');
var ReactPropTypes=require('ReactPropTypes');
var TransformPropTypes=require('TransformPropTypes');

var ImageStylePropTypes=_extends({},
LayoutPropTypes,
TransformPropTypes,{
resizeMode:ReactPropTypes.oneOf(Object.keys(ImageResizeMode)),
backgroundColor:ReactPropTypes.string,
borderColor:ReactPropTypes.string,
borderWidth:ReactPropTypes.number,
borderRadius:ReactPropTypes.number,



tintColor:ReactPropTypes.string,
opacity:ReactPropTypes.number});


module.exports = ImageStylePropTypes;
});
__d('ImageResizeMode',["keyMirror"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var keyMirror=require('keyMirror');





var ImageResizeMode=keyMirror({




contain:null,




cover:null,





stretch:null});


module.exports = ImageResizeMode;
});
__d('LayoutPropTypes',["ReactPropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactPropTypes=require('ReactPropTypes');






var LayoutPropTypes={
width:ReactPropTypes.number,
height:ReactPropTypes.number,
top:ReactPropTypes.number,
left:ReactPropTypes.number,
right:ReactPropTypes.number,
bottom:ReactPropTypes.number,
margin:ReactPropTypes.number,
marginVertical:ReactPropTypes.number,
marginHorizontal:ReactPropTypes.number,
marginTop:ReactPropTypes.number,
marginBottom:ReactPropTypes.number,
marginLeft:ReactPropTypes.number,
marginRight:ReactPropTypes.number,
padding:ReactPropTypes.number,
paddingVertical:ReactPropTypes.number,
paddingHorizontal:ReactPropTypes.number,
paddingTop:ReactPropTypes.number,
paddingBottom:ReactPropTypes.number,
paddingLeft:ReactPropTypes.number,
paddingRight:ReactPropTypes.number,
borderWidth:ReactPropTypes.number,
borderTopWidth:ReactPropTypes.number,
borderRightWidth:ReactPropTypes.number,
borderBottomWidth:ReactPropTypes.number,
borderLeftWidth:ReactPropTypes.number,

position:ReactPropTypes.oneOf([
'absolute',
'relative']),



flexDirection:ReactPropTypes.oneOf([
'row',
'column']),



flexWrap:ReactPropTypes.oneOf([
'wrap',
'nowrap']),




justifyContent:ReactPropTypes.oneOf([
'flex-start',
'flex-end',
'center',
'space-between',
'space-around']),




alignItems:ReactPropTypes.oneOf([
'flex-start',
'flex-end',
'center',
'stretch']),




alignSelf:ReactPropTypes.oneOf([
'auto',
'flex-start',
'flex-end',
'center',
'stretch']),



flex:ReactPropTypes.number};


module.exports = LayoutPropTypes;
});
__d('ReactPropTypes',["ReactElement","ReactFragment","ReactPropTypeLocationNames","emptyFunction"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactElement=require('ReactElement');
var ReactFragment=require('ReactFragment');
var ReactPropTypeLocationNames=require('ReactPropTypeLocationNames');

var emptyFunction=require('emptyFunction');
















































var ANONYMOUS='<<anonymous>>';

var elementTypeChecker=createElementTypeChecker();
var nodeTypeChecker=createNodeChecker();

var ReactPropTypes={
array:createPrimitiveTypeChecker('array'),
bool:createPrimitiveTypeChecker('boolean'),
func:createPrimitiveTypeChecker('function'),
number:createPrimitiveTypeChecker('number'),
object:createPrimitiveTypeChecker('object'),
string:createPrimitiveTypeChecker('string'),

any:createAnyTypeChecker(),
arrayOf:createArrayOfTypeChecker,
element:elementTypeChecker,
instanceOf:createInstanceTypeChecker,
node:nodeTypeChecker,
objectOf:createObjectOfTypeChecker,
oneOf:createEnumTypeChecker,
oneOfType:createUnionTypeChecker,
shape:createShapeTypeChecker};


function createChainableTypeChecker(validate){
function checkType(isRequired,props,propName,componentName,location){
componentName = componentName || ANONYMOUS;
if(props[propName] == null){
var locationName=ReactPropTypeLocationNames[location];
if(isRequired){
return new Error(
'Required ' + locationName + ' `' + propName + '` was not specified in ' + ('`' + 
componentName + '`.'));}


return null;}else 
{
return validate(props,propName,componentName,location);}}



var chainedCheckType=checkType.bind(null,false);
chainedCheckType.isRequired = checkType.bind(null,true);

return chainedCheckType;}


function createPrimitiveTypeChecker(expectedType){
function validate(props,propName,componentName,location){
var propValue=props[propName];
var propType=getPropType(propValue);
if(propType !== expectedType){
var locationName=ReactPropTypeLocationNames[location];



var preciseType=getPreciseType(propValue);

return new Error(
'Invalid ' + locationName + ' `' + propName + '` of type `' + preciseType + '` ' + ('supplied to `' + 
componentName + '`, expected `' + expectedType + '`.'));}


return null;}

return createChainableTypeChecker(validate);}


function createAnyTypeChecker(){
return createChainableTypeChecker(emptyFunction.thatReturns(null));}


function createArrayOfTypeChecker(typeChecker){
function validate(props,propName,componentName,location){
var propValue=props[propName];
if(!Array.isArray(propValue)){
var locationName=ReactPropTypeLocationNames[location];
var propType=getPropType(propValue);
return new Error(
'Invalid ' + locationName + ' `' + propName + '` of type ' + ('`' + 
propType + '` supplied to `' + componentName + '`, expected an array.'));}


for(var i=0;i < propValue.length;i++) {
var error=typeChecker(propValue,i,componentName,location);
if(error instanceof Error){
return error;}}


return null;}

return createChainableTypeChecker(validate);}


function createElementTypeChecker(){
function validate(props,propName,componentName,location){
if(!ReactElement.isValidElement(props[propName])){
var locationName=ReactPropTypeLocationNames[location];
return new Error(
'Invalid ' + locationName + ' `' + propName + '` supplied to ' + ('`' + 
componentName + '`, expected a ReactElement.'));}


return null;}

return createChainableTypeChecker(validate);}


function createInstanceTypeChecker(expectedClass){
function validate(props,propName,componentName,location){
if(!(props[propName] instanceof expectedClass)){
var locationName=ReactPropTypeLocationNames[location];
var expectedClassName=expectedClass.name || ANONYMOUS;
return new Error(
'Invalid ' + locationName + ' `' + propName + '` supplied to ' + ('`' + 
componentName + '`, expected instance of `' + expectedClassName + '`.'));}


return null;}

return createChainableTypeChecker(validate);}


function createEnumTypeChecker(expectedValues){
function validate(props,propName,componentName,location){
var propValue=props[propName];
for(var i=0;i < expectedValues.length;i++) {
if(propValue === expectedValues[i]){
return null;}}



var locationName=ReactPropTypeLocationNames[location];
var valuesString=JSON.stringify(expectedValues);
return new Error(
'Invalid ' + locationName + ' `' + propName + '` of value `' + propValue + '` ' + ('supplied to `' + 
componentName + '`, expected one of ' + valuesString + '.'));}


return createChainableTypeChecker(validate);}


function createObjectOfTypeChecker(typeChecker){
function validate(props,propName,componentName,location){
var propValue=props[propName];
var propType=getPropType(propValue);
if(propType !== 'object'){
var locationName=ReactPropTypeLocationNames[location];
return new Error(
'Invalid ' + locationName + ' `' + propName + '` of type ' + ('`' + 
propType + '` supplied to `' + componentName + '`, expected an object.'));}


for(var key in propValue) {
if(propValue.hasOwnProperty(key)){
var error=typeChecker(propValue,key,componentName,location);
if(error instanceof Error){
return error;}}}



return null;}

return createChainableTypeChecker(validate);}


function createUnionTypeChecker(arrayOfTypeCheckers){
function validate(props,propName,componentName,location){
for(var i=0;i < arrayOfTypeCheckers.length;i++) {
var checker=arrayOfTypeCheckers[i];
if(checker(props,propName,componentName,location) == null){
return null;}}



var locationName=ReactPropTypeLocationNames[location];
return new Error(
'Invalid ' + locationName + ' `' + propName + '` supplied to ' + ('`' + 
componentName + '`.'));}


return createChainableTypeChecker(validate);}


function createNodeChecker(){
function validate(props,propName,componentName,location){
if(!isNode(props[propName])){
var locationName=ReactPropTypeLocationNames[location];
return new Error(
'Invalid ' + locationName + ' `' + propName + '` supplied to ' + ('`' + 
componentName + '`, expected a ReactNode.'));}


return null;}

return createChainableTypeChecker(validate);}


function createShapeTypeChecker(shapeTypes){
function validate(props,propName,componentName,location){
var propValue=props[propName];
var propType=getPropType(propValue);
if(propType !== 'object'){
var locationName=ReactPropTypeLocationNames[location];
return new Error(
'Invalid ' + locationName + ' `' + propName + '` of type `' + propType + '` ' + ('supplied to `' + 
componentName + '`, expected `object`.'));}


for(var key in shapeTypes) {
var checker=shapeTypes[key];
if(!checker){
continue;}

var error=checker(propValue,key,componentName,location);
if(error){
return error;}}


return null;}

return createChainableTypeChecker(validate);}


function isNode(propValue){
switch(typeof propValue){
case 'number':
case 'string':
case 'undefined':
return true;
case 'boolean':
return !propValue;
case 'object':
if(Array.isArray(propValue)){
return propValue.every(isNode);}

if(propValue === null || ReactElement.isValidElement(propValue)){
return true;}

propValue = ReactFragment.extractIfFragment(propValue);
for(var k in propValue) {
if(!isNode(propValue[k])){
return false;}}


return true;
default:
return false;}}




function getPropType(propValue){
var propType=typeof propValue;
if(Array.isArray(propValue)){
return 'array';}

if(propValue instanceof RegExp){



return 'object';}

return propType;}




function getPreciseType(propValue){
var propType=getPropType(propValue);
if(propType === 'object'){
if(propValue instanceof Date){
return 'date';}else 
if(propValue instanceof RegExp){
return 'regexp';}}


return propType;}


module.exports = ReactPropTypes;
});
__d('TransformPropTypes',["ReactPropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactPropTypes=require('ReactPropTypes');

var TransformPropTypes={
transform:ReactPropTypes.arrayOf(
ReactPropTypes.oneOfType([
ReactPropTypes.shape({rotate:ReactPropTypes.string}),
ReactPropTypes.shape({scaleX:ReactPropTypes.number}),
ReactPropTypes.shape({scaleY:ReactPropTypes.number}),
ReactPropTypes.shape({translateX:ReactPropTypes.number}),
ReactPropTypes.shape({translateY:ReactPropTypes.number})])),








transformMatrix:ReactPropTypes.arrayOf(ReactPropTypes.number),


rotation:ReactPropTypes.number,
scaleX:ReactPropTypes.number,
scaleY:ReactPropTypes.number,
translateX:ReactPropTypes.number,
translateY:ReactPropTypes.number};


module.exports = TransformPropTypes;
});
__d('TextStylePropTypes',["ReactPropTypes","ViewStylePropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactPropTypes=require('ReactPropTypes');
var ViewStylePropTypes=require('ViewStylePropTypes');


var TextStylePropTypes=Object.assign(Object.create(ViewStylePropTypes),{
fontFamily:ReactPropTypes.string,
fontSize:ReactPropTypes.number,
fontWeight:ReactPropTypes.oneOf(
['normal','bold',
'100','200','300','400','500','600','700','800','900']),

fontStyle:ReactPropTypes.oneOf(['normal','italic']),
lineHeight:ReactPropTypes.number,
color:ReactPropTypes.string,

textAlign:ReactPropTypes.oneOf(
['auto','left','right','center','justify']),

writingDirection:ReactPropTypes.oneOf(
['auto','ltr','rtl']),

letterSpacing:ReactPropTypes.number});



var unsupportedProps=Object.keys({
padding:null,
paddingTop:null,
paddingLeft:null,
paddingRight:null,
paddingBottom:null,
paddingVertical:null,
paddingHorizontal:null});


for(var ii=0;ii < unsupportedProps.length;ii++) {
delete TextStylePropTypes[unsupportedProps[ii]];}


module.exports = TextStylePropTypes;
});
__d('ViewStylePropTypes',["LayoutPropTypes","ReactPropTypes","TransformPropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var LayoutPropTypes=require('LayoutPropTypes');
var ReactPropTypes=require('ReactPropTypes');
var TransformPropTypes=require('TransformPropTypes');




var ViewStylePropTypes=_extends({},
LayoutPropTypes,
TransformPropTypes,{
backgroundColor:ReactPropTypes.string,
borderColor:ReactPropTypes.string,
borderTopColor:ReactPropTypes.string,
borderRightColor:ReactPropTypes.string,
borderBottomColor:ReactPropTypes.string,
borderLeftColor:ReactPropTypes.string,
borderRadius:ReactPropTypes.number,
borderTopLeftRadius:ReactPropTypes.number,
borderTopRightRadius:ReactPropTypes.number,
borderBottomLeftRadius:ReactPropTypes.number,
borderBottomRightRadius:ReactPropTypes.number,
opacity:ReactPropTypes.number,
overflow:ReactPropTypes.oneOf(['visible','hidden']),
shadowColor:ReactPropTypes.string,
shadowOffset:ReactPropTypes.shape(
{width:ReactPropTypes.number,height:ReactPropTypes.number}),

shadowOpacity:ReactPropTypes.number,
shadowRadius:ReactPropTypes.number});


module.exports = ViewStylePropTypes;
});
__d('matricesDiffer',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




















var matricesDiffer=function(one,two){
if(one === two){
return false;}

return !one || !two || 
one[12] !== two[12] || 
one[13] !== two[13] || 
one[14] !== two[14] || 
one[5] !== two[5] || 
one[10] !== two[10] || 
one[1] !== two[1] || 
one[2] !== two[2] || 
one[3] !== two[3] || 
one[4] !== two[4] || 
one[6] !== two[6] || 
one[7] !== two[7] || 
one[8] !== two[8] || 
one[9] !== two[9] || 
one[11] !== two[11] || 
one[15] !== two[15];};


module.exports = matricesDiffer;
});
__d('sizesDiffer',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






var dummySize={width:undefined,height:undefined};

var sizesDiffer=function(one,two){
one = one || dummySize;
two = two || dummySize;
return one !== two && (
one.width !== two.width || 
one.height !== two.height);};



module.exports = sizesDiffer;
});
__d('ReactMultiChild',["ReactComponentEnvironment","ReactMultiChildUpdateTypes","ReactReconciler","ReactChildReconciler"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactComponentEnvironment=require('ReactComponentEnvironment');
var ReactMultiChildUpdateTypes=require('ReactMultiChildUpdateTypes');

var ReactReconciler=require('ReactReconciler');
var ReactChildReconciler=require('ReactChildReconciler');








var updateDepth=0;









var updateQueue=[];







var markupQueue=[];









function enqueueMarkup(parentID,markup,toIndex){

updateQueue.push({
parentID:parentID,
parentNode:null,
type:ReactMultiChildUpdateTypes.INSERT_MARKUP,
markupIndex:markupQueue.push(markup) - 1,
textContent:null,
fromIndex:null,
toIndex:toIndex});}











function enqueueMove(parentID,fromIndex,toIndex){

updateQueue.push({
parentID:parentID,
parentNode:null,
type:ReactMultiChildUpdateTypes.MOVE_EXISTING,
markupIndex:null,
textContent:null,
fromIndex:fromIndex,
toIndex:toIndex});}










function enqueueRemove(parentID,fromIndex){

updateQueue.push({
parentID:parentID,
parentNode:null,
type:ReactMultiChildUpdateTypes.REMOVE_NODE,
markupIndex:null,
textContent:null,
fromIndex:fromIndex,
toIndex:null});}










function enqueueTextContent(parentID,textContent){

updateQueue.push({
parentID:parentID,
parentNode:null,
type:ReactMultiChildUpdateTypes.TEXT_CONTENT,
markupIndex:null,
textContent:textContent,
fromIndex:null,
toIndex:null});}








function processQueue(){
if(updateQueue.length){
ReactComponentEnvironment.processChildrenUpdates(
updateQueue,
markupQueue);

clearQueue();}}








function clearQueue(){
updateQueue.length = 0;
markupQueue.length = 0;}








var ReactMultiChild={








Mixin:{









mountChildren:function(nestedChildren,transaction,context){
var children=ReactChildReconciler.instantiateChildren(
nestedChildren,transaction,context);

this._renderedChildren = children;
var mountImages=[];
var index=0;
for(var name in children) {
if(children.hasOwnProperty(name)){
var child=children[name];

var rootID=this._rootNodeID + name;
var mountImage=ReactReconciler.mountComponent(
child,
rootID,
transaction,
context);

child._mountIndex = index;
mountImages.push(mountImage);
index++;}}


return mountImages;},








updateTextContent:function(nextContent){
updateDepth++;
var errorThrown=true;
try{
var prevChildren=this._renderedChildren;

ReactChildReconciler.unmountChildren(prevChildren);

for(var name in prevChildren) {
if(prevChildren.hasOwnProperty(name)){
this._unmountChildByName(prevChildren[name],name);}}



this.setTextContent(nextContent);
errorThrown = false;}finally 
{
updateDepth--;
if(!updateDepth){
if(errorThrown){
clearQueue();}else 
{
processQueue();}}}},












updateChildren:function(nextNestedChildren,transaction,context){
updateDepth++;
var errorThrown=true;
try{
this._updateChildren(nextNestedChildren,transaction,context);
errorThrown = false;}finally 
{
updateDepth--;
if(!updateDepth){
if(errorThrown){
clearQueue();}else 
{
processQueue();}}}},















_updateChildren:function(nextNestedChildren,transaction,context){
var prevChildren=this._renderedChildren;
var nextChildren=ReactChildReconciler.updateChildren(
prevChildren,nextNestedChildren,transaction,context);

this._renderedChildren = nextChildren;
if(!nextChildren && !prevChildren){
return;}

var name;


var lastIndex=0;
var nextIndex=0;
for(name in nextChildren) {
if(!nextChildren.hasOwnProperty(name)){
continue;}

var prevChild=prevChildren && prevChildren[name];
var nextChild=nextChildren[name];
if(prevChild === nextChild){
this.moveChild(prevChild,nextIndex,lastIndex);
lastIndex = Math.max(prevChild._mountIndex,lastIndex);
prevChild._mountIndex = nextIndex;}else 
{
if(prevChild){

lastIndex = Math.max(prevChild._mountIndex,lastIndex);
this._unmountChildByName(prevChild,name);}


this._mountChildByNameAtIndex(
nextChild,name,nextIndex,transaction,context);}


nextIndex++;}


for(name in prevChildren) {
if(prevChildren.hasOwnProperty(name) && 
!(nextChildren && nextChildren.hasOwnProperty(name))){
this._unmountChildByName(prevChildren[name],name);}}},










unmountChildren:function(){
var renderedChildren=this._renderedChildren;
ReactChildReconciler.unmountChildren(renderedChildren);
this._renderedChildren = null;},










moveChild:function(child,toIndex,lastIndex){



if(child._mountIndex < lastIndex){
enqueueMove(this._rootNodeID,child._mountIndex,toIndex);}},










createChild:function(child,mountImage){
enqueueMarkup(this._rootNodeID,mountImage,child._mountIndex);},








removeChild:function(child){
enqueueRemove(this._rootNodeID,child._mountIndex);},








setTextContent:function(textContent){
enqueueTextContent(this._rootNodeID,textContent);},













_mountChildByNameAtIndex:function(
child,
name,
index,
transaction,
context){

var rootID=this._rootNodeID + name;
var mountImage=ReactReconciler.mountComponent(
child,
rootID,
transaction,
context);

child._mountIndex = index;
this.createChild(child,mountImage);},











_unmountChildByName:function(child,name){
this.removeChild(child);
child._mountIndex = null;}}};






module.exports = ReactMultiChild;
});
__d('ReactChildReconciler',["ReactReconciler","flattenChildren","instantiateReactComponent","shouldUpdateReactComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactReconciler=require('ReactReconciler');

var flattenChildren=require('flattenChildren');
var instantiateReactComponent=require('instantiateReactComponent');
var shouldUpdateReactComponent=require('shouldUpdateReactComponent');






var ReactChildReconciler={









instantiateChildren:function(nestedChildNodes,transaction,context){
var children=flattenChildren(nestedChildNodes);
for(var name in children) {
if(children.hasOwnProperty(name)){
var child=children[name];


var childInstance=instantiateReactComponent(child,null);
children[name] = childInstance;}}


return children;},












updateChildren:function(
prevChildren,
nextNestedChildNodes,
transaction,
context){





var nextChildren=flattenChildren(nextNestedChildNodes);
if(!nextChildren && !prevChildren){
return null;}

var name;
for(name in nextChildren) {
if(!nextChildren.hasOwnProperty(name)){
continue;}

var prevChild=prevChildren && prevChildren[name];
var prevElement=prevChild && prevChild._currentElement;
var nextElement=nextChildren[name];
if(shouldUpdateReactComponent(prevElement,nextElement)){
ReactReconciler.receiveComponent(
prevChild,nextElement,transaction,context);

nextChildren[name] = prevChild;}else 
{
if(prevChild){
ReactReconciler.unmountComponent(prevChild,name);}


var nextChildInstance=instantiateReactComponent(
nextElement,
null);

nextChildren[name] = nextChildInstance;}}



for(name in prevChildren) {
if(prevChildren.hasOwnProperty(name) && 
!(nextChildren && nextChildren.hasOwnProperty(name))){
ReactReconciler.unmountComponent(prevChildren[name]);}}


return nextChildren;},









unmountChildren:function(renderedChildren){
for(var name in renderedChildren) {
var renderedChild=renderedChildren[name];
ReactReconciler.unmountComponent(renderedChild);}}};





module.exports = ReactChildReconciler;
});
__d('flattenChildren',["traverseAllChildren","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var traverseAllChildren=require('traverseAllChildren');
var warning=require('warning');






function flattenSingleChildIntoContext(traverseContext,child,name){

var result=traverseContext;
var keyUnique=!result.hasOwnProperty(name);
if(__DEV__){
warning(
keyUnique,
'flattenChildren(...): Encountered two children with the same key, ' + 
'`%s`. Child keys must be unique; when two children share a key, only ' + 
'the first child will be used.',
name);}


if(keyUnique && child != null){
result[name] = child;}}








function flattenChildren(children){
if(children == null){
return children;}

var result={};
traverseAllChildren(children,flattenSingleChildIntoContext,result);
return result;}


module.exports = flattenChildren;
});
__d('styleDiffer',["deepDiffer"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var deepDiffer=require('deepDiffer');

function styleDiffer(a,b){
return !styleEqual(a,b);}


function styleEqual(a,b){
if(!a){
return !b;}

if(!b){
return !a;}

if(typeof a !== typeof b){
return false;}

if(typeof a === 'number'){
return a === b;}


if(Array.isArray(a)){
if(!Array.isArray(b) || a.length !== b.length){
return false;}

for(var i=0;i < a.length;++i) {
if(!styleEqual(a[i],b[i])){
return false;}}


return true;}


for(var key in a) {
if(deepDiffer(a[key],b[key])){
return false;}}



for(var key in b) {
if(!a.hasOwnProperty(key)){
return false;}}



return true;}


module.exports = styleDiffer;
});
__d('deepDiffer',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';















var deepDiffer=function(one,two){
if(one === two){

return false;}

if(typeof one === 'function' && typeof two === 'function'){

return false;}

if(typeof one !== 'object' || one === null){

return one !== two;}

if(typeof two !== 'object' || two === null){


return true;}

if(one.constructor !== two.constructor){
return true;}

if(Array.isArray(one)){

var len=one.length;
if(two.length !== len){
return true;}

for(var ii=0;ii < len;ii++) {
if(deepDiffer(one[ii],two[ii])){
return true;}}}else 


{
for(var key in one) {
if(deepDiffer(one[key],two[key])){
return true;}}


for(var twoKey in two) {


if(one[twoKey] === undefined && two[twoKey] !== undefined){
return true;}}}



return false;};


module.exports = deepDiffer;
});
__d('diffRawProperties',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';























function diffRawProperties(
updatePayload,
prevProps,
nextProps,
validAttributes)
{
var validAttributeConfig;
var nextProp;
var prevProp;
var isScalar;
var shouldUpdate;

if(nextProps){
for(var propKey in nextProps) {
validAttributeConfig = validAttributes[propKey];
if(!validAttributeConfig){
continue;}

prevProp = prevProps && prevProps[propKey];
nextProp = nextProps[propKey];



if(typeof prevProp === 'function'){
prevProp = true;}

if(typeof nextProp === 'function'){
nextProp = true;}


if(prevProp !== nextProp){




isScalar = typeof nextProp !== 'object' || nextProp === null;
shouldUpdate = isScalar || 
!prevProp || 
validAttributeConfig.diff && 
validAttributeConfig.diff(prevProp,nextProp);

if(shouldUpdate){
updatePayload = updatePayload || {};
updatePayload[propKey] = nextProp;}}}}








if(prevProps){
for(var propKey in prevProps) {
validAttributeConfig = validAttributes[propKey];
if(!validAttributeConfig){
continue;}

if(updatePayload && updatePayload[propKey] !== undefined){
continue;}

prevProp = prevProps[propKey];
nextProp = nextProps && nextProps[propKey];



if(typeof prevProp === 'function'){
prevProp = true;}

if(typeof nextProp === 'function'){
nextProp = true;}


if(prevProp !== nextProp){
if(nextProp === undefined){
nextProp = null;}





isScalar = typeof nextProp !== 'object' || nextProp === null;
shouldUpdate = isScalar && prevProp !== nextProp || 
validAttributeConfig.diff && 
validAttributeConfig.diff(prevProp,nextProp);
if(shouldUpdate){
updatePayload = updatePayload || {};
updatePayload[propKey] = nextProp;}}}}




return updatePayload;}


module.exports = diffRawProperties;
});
__d('RCTEventEmitter',["ReactNativeEventEmitter"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactNativeEventEmitter=require('ReactNativeEventEmitter');


module.exports = ReactNativeEventEmitter;
});
__d('RCTLog',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var invariant=require('invariant');

var levelsMap={
log:'log',
info:'info',
warn:'warn',
error:'error',
mustfix:'error'};var 


RCTLog=(function(){function RCTLog(){_classCallCheck(this,RCTLog);}_createClass(RCTLog,null,[{key:'logIfNoNativeHook',value:

function logIfNoNativeHook(){
var args=Array.prototype.slice.call(arguments);
var level=args.shift();
var logFn=levelsMap[level];
invariant(
logFn,
'Level "' + level + '" not one of ' + Object.keys(levelsMap));

if(typeof global.nativeLoggingHook === 'undefined'){

console[logFn].apply(console,args);}

return true;}}]);return RCTLog;})();



module.exports = RCTLog;
});
__d('deprecated',["Object.assign","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var assign=require('Object.assign');
var warning=require('warning');












function deprecated(namespace,oldName,newName,ctx,fn){
var warned=false;
if(__DEV__){
var newFn=function(){
warning(
warned,
'%s.%s will be deprecated in a future version. ' + 
'Use %s.%s instead.',
namespace,
oldName,
namespace,
newName);

warned = true;
return fn.apply(ctx,arguments);};

newFn.displayName = namespace + '_' + oldName;


return assign(newFn,fn);}


return fn;}


module.exports = deprecated;
});
__d('onlyChild',["ReactElement","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';











var ReactElement=require('ReactElement');

var invariant=require('invariant');












function onlyChild(children){
invariant(
ReactElement.isValidElement(children),
'onlyChild must be passed a children with exactly one child.');

return children;}


module.exports = onlyChild;
});
__d('ActivityIndicatorIOS',["NativeMethodsMixin","ReactPropTypes","React","StyleSheet","View","requireNativeComponent","verifyPropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';function _objectWithoutProperties(obj,keys){var target={};for(var i in obj) {if(keys.indexOf(i) >= 0)continue;if(!Object.prototype.hasOwnProperty.call(obj,i))continue;target[i] = obj[i];}return target;}












var NativeMethodsMixin=require('NativeMethodsMixin');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var StyleSheet=require('StyleSheet');
var View=require('View');

var requireNativeComponent=require('requireNativeComponent');
var verifyPropTypes=require('verifyPropTypes');

var GRAY='#999999';








var ActivityIndicatorIOS=React.createClass({displayName:'ActivityIndicatorIOS',
mixins:[NativeMethodsMixin],

propTypes:{



animating:PropTypes.bool,



color:PropTypes.string,



hidesWhenStopped:PropTypes.bool,



size:PropTypes.oneOf([
'small',
'large']),






onLayout:PropTypes.func},


getDefaultProps:function(){
return {
animating:true,
color:GRAY,
hidesWhenStopped:true,
size:'small'};},



render:function(){var _props=
this.props;var onLayout=_props.onLayout;var style=_props.style;var props=_objectWithoutProperties(_props,['onLayout','style']);
var sizeStyle=this.props.size === 'large'?styles.sizeLarge:styles.sizeSmall;
return (
React.createElement(View,{
onLayout:onLayout,
style:[styles.container,sizeStyle,style]},
React.createElement(RCTActivityIndicatorView,props)));}});





var styles=StyleSheet.create({
container:{
alignItems:'center',
justifyContent:'center'},

sizeSmall:{
width:20,
height:20},

sizeLarge:{
width:36,
height:36}});



var RCTActivityIndicatorView=requireNativeComponent(
'RCTActivityIndicatorView',
null);

if(__DEV__){
var nativeOnlyProps={activityIndicatorViewStyle:true};
verifyPropTypes(
ActivityIndicatorIOS,
RCTActivityIndicatorView.viewConfig,
nativeOnlyProps);}



module.exports = ActivityIndicatorIOS;
});
__d('StyleSheet',["StyleSheetRegistry","StyleSheetValidation"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var StyleSheetRegistry=require('StyleSheetRegistry');
var StyleSheetValidation=require('StyleSheetValidation');var 













































StyleSheet=(function(){function StyleSheet(){_classCallCheck(this,StyleSheet);}_createClass(StyleSheet,null,[{key:'create',value:
function create(obj){
var result={};
for(var key in obj) {
StyleSheetValidation.validateStyle(key,obj);
result[key] = StyleSheetRegistry.registerStyle(obj[key]);}

return result;}}]);return StyleSheet;})();



module.exports = StyleSheet;
});
__d('StyleSheetValidation',["ImageStylePropTypes","ReactPropTypeLocations","TextStylePropTypes","ViewStylePropTypes","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var ImageStylePropTypes=require('ImageStylePropTypes');
var ReactPropTypeLocations=require('ReactPropTypeLocations');
var TextStylePropTypes=require('TextStylePropTypes');
var ViewStylePropTypes=require('ViewStylePropTypes');

var invariant=require('invariant');var 

StyleSheetValidation=(function(){function StyleSheetValidation(){_classCallCheck(this,StyleSheetValidation);}_createClass(StyleSheetValidation,null,[{key:'validateStyleProp',value:
function validateStyleProp(prop,style,caller){
if(!__DEV__){
return;}

if(allStylePropTypes[prop] === undefined){
var message1='"' + prop + '" is not a valid style property.';
var message2='\nValid style props: ' + 
JSON.stringify(Object.keys(allStylePropTypes).sort(),null,'  ');
styleError(message1,style,caller,message2);}

var error=allStylePropTypes[prop](
style,
prop,
caller,
ReactPropTypeLocations.prop);

if(error){
styleError(error.message,style,caller);}}},{key:'validateStyle',value:



function validateStyle(name,styles){
if(!__DEV__){
return;}

for(var prop in styles[name]) {
StyleSheetValidation.validateStyleProp(prop,styles[name],'StyleSheet ' + name);}}},{key:'addValidStylePropTypes',value:



function addValidStylePropTypes(stylePropTypes){
for(var key in stylePropTypes) {
invariant(
allStylePropTypes[key] === undefined || 
allStylePropTypes[key] === stylePropTypes[key],
'Attemped to redefine existing style prop type "' + key + '".');

allStylePropTypes[key] = stylePropTypes[key];}}}]);return StyleSheetValidation;})();




var styleError=function(message1,style,caller,message2){
invariant(
false,
message1 + '\n' + (caller || '<<unknown>>') + ': ' + 
JSON.stringify(style,null,'  ') + (message2 || ''));};



var allStylePropTypes={};

StyleSheetValidation.addValidStylePropTypes(ImageStylePropTypes);
StyleSheetValidation.addValidStylePropTypes(TextStylePropTypes);
StyleSheetValidation.addValidStylePropTypes(ViewStylePropTypes);

module.exports = StyleSheetValidation;
});
__d('View',["NativeMethodsMixin","ReactPropTypes","NativeModules","React","ReactNativeStyleAttributes","ReactNativeViewAttributes","StyleSheetPropType","ViewStylePropTypes","createReactNativeComponentClass"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeMethodsMixin=require('NativeMethodsMixin');
var PropTypes=require('ReactPropTypes');
var RCTUIManager=require('NativeModules').UIManager;
var React=require('React');
var ReactNativeStyleAttributes=require('ReactNativeStyleAttributes');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var StyleSheetPropType=require('StyleSheetPropType');
var ViewStylePropTypes=require('ViewStylePropTypes');

var createReactNativeComponentClass=require('createReactNativeComponentClass');

var stylePropType=StyleSheetPropType(ViewStylePropTypes);

var AccessibilityTraits=[
'none',
'button',
'link',
'header',
'search',
'image',
'selected',
'plays',
'key',
'text',
'summary',
'disabled',
'frequentUpdates',
'startsMedia',
'adjustable',
'allowsDirectInteraction',
'pageTurn'];






















var View=React.createClass({displayName:'View',
mixins:[NativeMethodsMixin],





viewConfig:{
uiViewClassName:'RCTView',
validAttributes:ReactNativeViewAttributes.RCTView},


propTypes:{




accessible:PropTypes.bool,






accessibilityLabel:PropTypes.string,





accessibilityTraits:PropTypes.oneOfType([
PropTypes.oneOf(AccessibilityTraits),
PropTypes.arrayOf(PropTypes.oneOf(AccessibilityTraits))]),






onAcccessibilityTap:PropTypes.func,





onMagicTap:PropTypes.func,




testID:PropTypes.string,






onMoveShouldSetResponder:PropTypes.func,
onResponderGrant:PropTypes.func,
onResponderMove:PropTypes.func,
onResponderReject:PropTypes.func,
onResponderRelease:PropTypes.func,
onResponderTerminate:PropTypes.func,
onResponderTerminationRequest:PropTypes.func,
onStartShouldSetResponder:PropTypes.func,
onStartShouldSetResponderCapture:PropTypes.func,






onLayout:PropTypes.func,































pointerEvents:PropTypes.oneOf([
'box-none',
'none',
'box-only',
'auto']),

style:stylePropType,









removeClippedSubviews:PropTypes.bool,













renderToHardwareTextureAndroid:PropTypes.bool},


render:function(){
return React.createElement(RCTView,this.props);}});



var RCTView=createReactNativeComponentClass({
validAttributes:ReactNativeViewAttributes.RCTView,
uiViewClassName:'RCTView'});

RCTView.propTypes = View.propTypes;
if(__DEV__){
var viewConfig=RCTUIManager.viewConfigs && RCTUIManager.viewConfigs.RCTView || {};
for(var prop in viewConfig.nativeProps) {
var viewAny=View;
if(!viewAny.propTypes[prop] && !ReactNativeStyleAttributes[prop]){
throw new Error(
'View is missing propType for native prop `' + prop + '`');}}}





var ViewToExport=RCTView;
if(__DEV__){
ViewToExport = View;}


module.exports = ViewToExport;
});
__d('ReactNativeViewAttributes',["merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var merge=require('merge');

var ReactNativeViewAttributes={};

ReactNativeViewAttributes.UIView = {
pointerEvents:true,
accessible:true,
accessibilityLabel:true,
accessibilityTraits:true,
testID:true,
onLayout:true,
onAccessibilityTap:true,
onMagicTap:true};


ReactNativeViewAttributes.RCTView = merge(
ReactNativeViewAttributes.UIView,{






removeClippedSubviews:true});


module.exports = ReactNativeViewAttributes;
});
__d('StyleSheetPropType',["createStrictShapeTypeChecker","flattenStyle"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var createStrictShapeTypeChecker=require('createStrictShapeTypeChecker');
var flattenStyle=require('flattenStyle');

function StyleSheetPropType(
shape)
{
var shapePropType=createStrictShapeTypeChecker(shape);
return function(props,propName,componentName,location){
var newProps=props;
if(props[propName]){

newProps = {};
newProps[propName] = flattenStyle(props[propName]);}

return shapePropType(newProps,propName,componentName,location);};}



module.exports = StyleSheetPropType;
});
__d('createStrictShapeTypeChecker',["ReactPropTypeLocationNames","invariant","merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactPropTypeLocationNames=require('ReactPropTypeLocationNames');

var invariant=require('invariant');
var merge=require('merge');

function createStrictShapeTypeChecker(
shapeTypes)
{
function checkType(isRequired,props,propName,componentName,location){
if(!props[propName]){
if(isRequired){
invariant(
false,
'Required object `' + propName + '` was not specified in ' + ('`' + 
componentName + '`.'));}


return;}

var propValue=props[propName];
var propType=typeof propValue;
var locationName=
location && ReactPropTypeLocationNames[location] || '(unknown)';
if(propType !== 'object'){
invariant(
false,
'Invalid ' + locationName + ' `' + propName + '` of type `' + propType + '` ' + ('supplied to `' + 
componentName + '`, expected `object`.'));}




var allKeys=merge(props[propName],shapeTypes);
for(var key in allKeys) {
var checker=shapeTypes[key];
if(!checker){
invariant(
false,
'Invalid props.' + propName + ' key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + 
JSON.stringify(props[propName],null,'  ') + '\nValid keys: ' + 
JSON.stringify(Object.keys(shapeTypes),null,'  '));}


var error=checker(propValue,key,componentName,location);
if(error){
invariant(
false,
error.message + '\nBad object: ' + 
JSON.stringify(props[propName],null,'  '));}}}




function chainedCheckType(
props,
propName,
componentName,
location)
{
return checkType(false,props,propName,componentName,location);}

chainedCheckType.isRequired = checkType.bind(null,true);
return chainedCheckType;}


module.exports = createStrictShapeTypeChecker;
});
__d('requireNativeComponent',["NativeModules","UnimplementedView","createReactNativeComponentClass","deepDiffer","insetsDiffer","pointsDiffer","matricesDiffer","sizesDiffer","verifyPropTypes","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var RCTUIManager=require('NativeModules').UIManager;
var UnimplementedView=require('UnimplementedView');

var createReactNativeComponentClass=require('createReactNativeComponentClass');
var deepDiffer=require('deepDiffer');
var insetsDiffer=require('insetsDiffer');
var pointsDiffer=require('pointsDiffer');
var matricesDiffer=require('matricesDiffer');
var sizesDiffer=require('sizesDiffer');
var verifyPropTypes=require('verifyPropTypes');
var warning=require('warning');
















function requireNativeComponent(
viewName,
wrapperComponent)
{
var viewConfig=RCTUIManager[viewName];
if(!viewConfig || !viewConfig.NativeProps){
warning(false,'Native component for "%s" does not exist',viewName);
return UnimplementedView;}

var nativeProps=_extends({},
RCTUIManager.RCTView.NativeProps,
viewConfig.NativeProps);

viewConfig.uiViewClassName = viewName;
viewConfig.validAttributes = {};
for(var key in nativeProps) {

var differ=TypeToDifferMap[nativeProps[key]] || deepDiffer;
viewConfig.validAttributes[key] = {diff:differ};}

if(__DEV__){
wrapperComponent && verifyPropTypes(wrapperComponent,viewConfig);}

return createReactNativeComponentClass(viewConfig);}


var TypeToDifferMap={

CATransform3D:matricesDiffer,
CGPoint:pointsDiffer,
CGSize:sizesDiffer,
UIEdgeInsets:insetsDiffer};




module.exports = requireNativeComponent;
});
__d('UnimplementedView',["React","StyleSheet","View"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';








var React=require('React');
var StyleSheet=require('StyleSheet');
var View=require('View');

var UnimplementedView=React.createClass({displayName:'UnimplementedView',
setNativeProps:function(){},




render:function(){
return (
React.createElement(View,{style:[styles.unimplementedView,this.props.style]},
this.props.children));}});





var styles=StyleSheet.create({
unimplementedView:{
borderWidth:1,
borderColor:'red',
alignSelf:'flex-start'}});



module.exports = UnimplementedView;
});
__d('insetsDiffer',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



















var dummyInsets={
top:undefined,
left:undefined,
right:undefined,
bottom:undefined};


var insetsDiffer=function(
one,
two)
{
one = one || dummyInsets;
two = two || dummyInsets;
return one !== two && (
one.top !== two.top || 
one.left !== two.left || 
one.right !== two.right || 
one.bottom !== two.bottom);};



module.exports = insetsDiffer;
});
__d('pointsDiffer',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

















var dummyPoint={x:undefined,y:undefined};

var pointsDiffer=function(one,two){
one = one || dummyPoint;
two = two || dummyPoint;
return one !== two && (
one.x !== two.x || 
one.y !== two.y);};



module.exports = pointsDiffer;
});
__d('verifyPropTypes',["ReactNativeStyleAttributes","View"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactNativeStyleAttributes=require('ReactNativeStyleAttributes');
var View=require('View');

function verifyPropTypes(
component,
viewConfig,
nativePropsToIgnore)
{
if(!viewConfig){
return;}

var componentName=component.name || component.displayName;
if(!component.propTypes){
throw new Error(
'`' + componentName + '` has no propTypes defined`');}



var nativeProps=viewConfig.NativeProps;
for(var prop in nativeProps) {
if(!component.propTypes[prop] && 
!View.propTypes[prop] && 
!ReactNativeStyleAttributes[prop] && (
!nativePropsToIgnore || !nativePropsToIgnore[prop])){
throw new Error(
'`' + componentName + '` has no propType for native prop `' + 
viewConfig.uiViewClassName + '.' + prop + '` of native type `' + 
nativeProps[prop] + '`');}}}





module.exports = verifyPropTypes;
});
__d('DatePickerIOS',["NativeMethodsMixin","ReactPropTypes","React","NativeModules","StyleSheet","View","requireNativeComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';














var NativeMethodsMixin=require('NativeMethodsMixin');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var RCTDatePickerIOSConsts=require('NativeModules').UIManager.RCTDatePicker.Constants;
var StyleSheet=require('StyleSheet');
var View=require('View');

var requireNativeComponent=require('requireNativeComponent');

var DATEPICKER='datepicker';














var DatePickerIOS=React.createClass({displayName:'DatePickerIOS',
mixins:[NativeMethodsMixin],

propTypes:{



date:PropTypes.instanceOf(Date).isRequired,








onDateChange:PropTypes.func.isRequired,






maximumDate:PropTypes.instanceOf(Date),






minimumDate:PropTypes.instanceOf(Date),




mode:PropTypes.oneOf(['date','time','datetime']),




minuteInterval:PropTypes.oneOf([1,2,3,4,5,6,10,12,15,20,30]),








timeZoneOffsetInMinutes:PropTypes.number},


getDefaultProps:function(){
return {
mode:'datetime'};},



_onChange:function(event){
var nativeTimeStamp=event.nativeEvent.timestamp;
this.props.onDateChange && this.props.onDateChange(
new Date(nativeTimeStamp));

this.props.onChange && this.props.onChange(event);





var propsTimeStamp=this.props.date.getTime();
if(nativeTimeStamp !== propsTimeStamp){
this.refs[DATEPICKER].setNativeProps({
date:propsTimeStamp});}},




render:function(){
var props=this.props;
return (
React.createElement(View,{style:props.style},
React.createElement(RCTDatePickerIOS,{
ref:DATEPICKER,
style:styles.datePickerIOS,
date:props.date.getTime(),
maximumDate:
props.maximumDate?props.maximumDate.getTime():undefined,

minimumDate:
props.minimumDate?props.minimumDate.getTime():undefined,

mode:props.mode,
minuteInterval:props.minuteInterval,
timeZoneOffsetInMinutes:props.timeZoneOffsetInMinutes,
onChange:this._onChange})));}});






var styles=StyleSheet.create({
datePickerIOS:{
height:RCTDatePickerIOSConsts.ComponentHeight,
width:RCTDatePickerIOSConsts.ComponentWidth}});



var RCTDatePickerIOS=requireNativeComponent('RCTDatePicker',DatePickerIOS);

module.exports = DatePickerIOS;
});
__d('Image',["EdgeInsetsPropType","ImageResizeMode","ImageStylePropTypes","NativeMethodsMixin","NativeModules","ReactPropTypes","React","ReactNativeViewAttributes","StyleSheet","StyleSheetPropType","flattenStyle","invariant","merge","requireNativeComponent","resolveAssetSource","verifyPropTypes","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EdgeInsetsPropType=require('EdgeInsetsPropType');
var ImageResizeMode=require('ImageResizeMode');
var ImageStylePropTypes=require('ImageStylePropTypes');
var NativeMethodsMixin=require('NativeMethodsMixin');
var NativeModules=require('NativeModules');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var StyleSheet=require('StyleSheet');
var StyleSheetPropType=require('StyleSheetPropType');

var flattenStyle=require('flattenStyle');
var invariant=require('invariant');
var merge=require('merge');
var requireNativeComponent=require('requireNativeComponent');
var resolveAssetSource=require('resolveAssetSource');
var verifyPropTypes=require('verifyPropTypes');
var warning=require('warning');


























var Image=React.createClass({displayName:'Image',
propTypes:{





source:PropTypes.shape({
uri:PropTypes.string}),





defaultSource:PropTypes.shape({
uri:PropTypes.string}),




accessible:PropTypes.bool,



accessibilityLabel:PropTypes.string,







capInsets:EdgeInsetsPropType,




resizeMode:PropTypes.oneOf(['cover','contain','stretch']),
style:StyleSheetPropType(ImageStylePropTypes),




testID:PropTypes.string,





onLayout:PropTypes.func},


statics:{
resizeMode:ImageResizeMode},


mixins:[NativeMethodsMixin],





viewConfig:{
uiViewClassName:'UIView',
validAttributes:ReactNativeViewAttributes.UIView},


render:function(){
for(var prop in nativeOnlyProps) {
if(this.props[prop] !== undefined){
console.warn('Prop `' + prop + ' = ' + this.props[prop] + '` should ' + 
'not be set directly on Image.');}}


var source=resolveAssetSource(this.props.source) || {};var 

width=source.width;var height=source.height;
var style=flattenStyle([{width:width,height:height},styles.base,this.props.style]);
invariant(style,'style must be initialized');

var isNetwork=source.uri && source.uri.match(/^https?:/);
invariant(
!(isNetwork && source.isStatic),
'static image uris cannot start with "http": "' + source.uri + '"');

var isStored=!source.isStatic && !isNetwork;
var RawImage=isNetwork?RCTNetworkImage:RCTStaticImage;

if(this.props.style && this.props.style.tintColor){
warning(RawImage === RCTStaticImage,'tintColor style only supported on static images.');}

var resizeMode=this.props.resizeMode || style.resizeMode || 'cover';

var nativeProps=merge(this.props,{
style:style,
resizeMode:resizeMode,
tintColor:style.tintColor});

if(isStored){
nativeProps.imageTag = source.uri;}else 
{
nativeProps.src = source.uri;}

if(this.props.defaultSource){
nativeProps.defaultImageSrc = this.props.defaultSource.uri;}

return React.createElement(RawImage,nativeProps);}});



var styles=StyleSheet.create({
base:{
overflow:'hidden'}});



var RCTNetworkImage=requireNativeComponent('RCTNetworkImageView',null);
var RCTStaticImage=requireNativeComponent('RCTStaticImage',null);

var nativeOnlyProps={
src:true,
defaultImageSrc:true,
imageTag:true};

if(__DEV__){
verifyPropTypes(Image,RCTStaticImage.viewConfig,nativeOnlyProps);
verifyPropTypes(Image,RCTNetworkImage.viewConfig,nativeOnlyProps);}


module.exports = Image;
});
__d('EdgeInsetsPropType',["ReactPropTypes","createStrictShapeTypeChecker"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var PropTypes=require('ReactPropTypes');

var createStrictShapeTypeChecker=require('createStrictShapeTypeChecker');

var EdgeInsetsPropType=createStrictShapeTypeChecker({
top:PropTypes.number,
left:PropTypes.number,
bottom:PropTypes.number,
right:PropTypes.number});


module.exports = EdgeInsetsPropType;
});
__d('resolveAssetSource',["AssetRegistry","PixelRatio","Platform","NativeModules"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var AssetRegistry=require('AssetRegistry');
var PixelRatio=require('PixelRatio');
var Platform=require('Platform');
var SourceCode=require('NativeModules').SourceCode;

var _serverURL;

function getDevServerURL(){
if(!__DEV__){

return null;}

if(_serverURL === undefined){
var scriptURL=SourceCode.scriptURL;
var match=scriptURL && scriptURL.match(/^https?:\/\/.*?\//);
if(match){

_serverURL = match[0];}else 
{

_serverURL = null;}}



return _serverURL;}





function getPathInArchive(asset){
if(Platform.OS === 'android'){
var assetDir=getBasePath(asset);


return (assetDir + '/' + asset.name).
toLowerCase().
replace(/\//g,'_').
replace(/([^a-z0-9_])/g,'').
replace(/^assets_/,'');}else 
{

return getScaledAssetPath(asset);}}







function getPathOnDevserver(devServerUrl,asset){
return devServerUrl + getScaledAssetPath(asset) + '?hash=' + asset.hash;}





function getBasePath(asset){


var path=asset.httpServerLocation;
if(path[0] === '/'){
path = path.substr(1);}

return path;}





function getScaledAssetPath(asset){
var scale=pickScale(asset.scales,PixelRatio.get());
var scaleSuffix=scale === 1?'':'@' + scale + 'x';
var assetDir=getBasePath(asset);
return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;}


function pickScale(scales,deviceScale){

for(var i=0;i < scales.length;i++) {
if(scales[i] >= deviceScale){
return scales[i];}}






return scales[scales.length - 1] || 1;}


function resolveAssetSource(source){
if(typeof source === 'object'){
return source;}


var asset=AssetRegistry.getAssetByID(source);
if(asset){
return assetToImageSource(asset);}


return null;}


function assetToImageSource(asset){
var devServerURL=getDevServerURL();
if(devServerURL){
return {
width:asset.width,
height:asset.height,
uri:getPathOnDevserver(devServerURL,asset),
isStatic:false};}else 

{
return {
width:asset.width,
height:asset.height,
uri:getPathInArchive(asset),
isStatic:true};}}




module.exports = resolveAssetSource;
module.exports.pickScale = pickScale;
});
__d('AssetRegistry',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






var assets=[];

function registerAsset(asset){


return assets.push(asset);}


function getAssetByID(assetId){
return assets[assetId - 1];}


module.exports = {registerAsset:registerAsset,getAssetByID:getAssetByID};
});
__d('PixelRatio',["Dimensions"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var Dimensions=require('Dimensions');var 






























PixelRatio=(function(){function PixelRatio(){_classCallCheck(this,PixelRatio);}_createClass(PixelRatio,null,[{key:'get',value:












function get(){
return Dimensions.get('window').scale;}},{key:'getFontScale',value:












function getFontScale(){
return Dimensions.get('window').fontScale || PixelRatio.get();}},{key:'getPixelSizeForLayoutSize',value:







function getPixelSizeForLayoutSize(layoutSize){
return Math.round(layoutSize * PixelRatio.get());}},{key:'startDetecting',value:



function startDetecting(){}}]);return PixelRatio;})();


module.exports = PixelRatio;
});
__d('Dimensions',["NativeModules","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var NativeModules=require('NativeModules');

var invariant=require('invariant');

var dimensions=NativeModules.UIManager.Dimensions;




if(dimensions && dimensions.windowPhysicalPixels){

dimensions = JSON.parse(JSON.stringify(dimensions));

var windowPhysicalPixels=dimensions.windowPhysicalPixels;
dimensions.window = {
width:windowPhysicalPixels.width / windowPhysicalPixels.scale,
height:windowPhysicalPixels.height / windowPhysicalPixels.scale,
scale:windowPhysicalPixels.scale,
fontScale:windowPhysicalPixels.fontScale};



delete dimensions.windowPhysicalPixels;}var 


Dimensions=(function(){function Dimensions(){_classCallCheck(this,Dimensions);}_createClass(Dimensions,null,[{key:'set',value:





function set(dims){
Object.assign(dimensions,dims);
return true;}},{key:'get',value:















function get(dim){
invariant(dimensions[dim],'No dimension set for key ' + dim);
return dimensions[dim];}}]);return Dimensions;})();



module.exports = Dimensions;
});
__d('ListView',["ListViewDataSource","React","NativeModules","ScrollView","ScrollResponder","StaticRenderer","logError","merge","isEmpty","react-timer-mixin/TimerMixin.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};



























var ListViewDataSource=require('ListViewDataSource');
var React=require('React');
var RCTUIManager=require('NativeModules').UIManager;
var ScrollView=require('ScrollView');
var ScrollResponder=require('ScrollResponder');
var StaticRenderer=require('StaticRenderer');
var TimerMixin=require('react-timer-mixin/TimerMixin.js');

var logError=require('logError');
var merge=require('merge');
var isEmpty=require('isEmpty');

var PropTypes=React.PropTypes;

var DEFAULT_PAGE_SIZE=1;
var DEFAULT_INITIAL_ROWS=10;
var DEFAULT_SCROLL_RENDER_AHEAD=1000;
var DEFAULT_END_REACHED_THRESHOLD=1000;
var DEFAULT_SCROLL_CALLBACK_THROTTLE=50;
var SCROLLVIEW_REF='listviewscroll';


















































var ListView=React.createClass({displayName:'ListView',
mixins:[ScrollResponder.Mixin,TimerMixin],

statics:{
DataSource:ListViewDataSource},









propTypes:_extends({},
ScrollView.propTypes,{

dataSource:PropTypes.instanceOf(ListViewDataSource).isRequired,







renderSeparator:PropTypes.func,










renderRow:PropTypes.func.isRequired,





initialListSize:PropTypes.number,





onEndReached:PropTypes.func,



onEndReachedThreshold:PropTypes.number,



pageSize:PropTypes.number,








renderFooter:PropTypes.func,
renderHeader:PropTypes.func,









renderSectionHeader:PropTypes.func,




scrollRenderAheadDistance:React.PropTypes.number,









onChangeVisibleRows:React.PropTypes.func,





removeClippedSubviews:React.PropTypes.bool}),





getMetrics:function(){
return {
contentHeight:this.scrollProperties.contentHeight,
totalRows:this.props.dataSource.getRowCount(),
renderedRows:this.state.curRenderedRowsCount,
visibleRows:Object.keys(this._visibleRows).length};},







getScrollResponder:function(){
return this.refs[SCROLLVIEW_REF];},


setNativeProps:function(props){
this.refs[SCROLLVIEW_REF].setNativeProps(props);},






getDefaultProps:function(){
return {
initialListSize:DEFAULT_INITIAL_ROWS,
pageSize:DEFAULT_PAGE_SIZE,
scrollRenderAheadDistance:DEFAULT_SCROLL_RENDER_AHEAD,
onEndReachedThreshold:DEFAULT_END_REACHED_THRESHOLD};},



getInitialState:function(){
return {
curRenderedRowsCount:this.props.initialListSize,
prevRenderedRowsCount:0,
highlightedRow:{}};},



componentWillMount:function(){

this.scrollProperties = {
visibleHeight:null,
contentHeight:null,
offsetY:0};

this._childFrames = [];
this._visibleRows = {};},


componentDidMount:function(){var _this=this;


this.requestAnimationFrame(function(){
_this._measureAndUpdateScrollProps();});},



componentWillReceiveProps:function(nextProps){
if(this.props.dataSource !== nextProps.dataSource){
this.setState(function(state,props){
var rowsToRender=Math.min(
state.curRenderedRowsCount + props.pageSize,
props.dataSource.getRowCount());

return {
prevRenderedRowsCount:0,
curRenderedRowsCount:rowsToRender};});}},





componentDidUpdate:function(){var _this2=this;
this.requestAnimationFrame(function(){
_this2._measureAndUpdateScrollProps();});},



onRowHighlighted:function(sectionID,rowID){
this.setState({highlightedRow:{sectionID:sectionID,rowID:rowID}});},


render:function(){
var bodyComponents=[];

var dataSource=this.props.dataSource;
var allRowIDs=dataSource.rowIdentities;
var rowCount=0;
var sectionHeaderIndices=[];

var header=this.props.renderHeader && this.props.renderHeader();
var footer=this.props.renderFooter && this.props.renderFooter();
var totalIndex=header?1:0;

for(var sectionIdx=0;sectionIdx < allRowIDs.length;sectionIdx++) {
var sectionID=dataSource.sectionIdentities[sectionIdx];
var rowIDs=allRowIDs[sectionIdx];
if(rowIDs.length === 0){
continue;}


if(this.props.renderSectionHeader){
var shouldUpdateHeader=rowCount >= this.state.prevRenderedRowsCount && 
dataSource.sectionHeaderShouldUpdate(sectionIdx);
bodyComponents.push(
React.createElement(StaticRenderer,{
key:'s_' + sectionID,
shouldUpdate:!!shouldUpdateHeader,
render:this.props.renderSectionHeader.bind(
null,
dataSource.getSectionHeaderData(sectionIdx),
sectionID)}));



sectionHeaderIndices.push(totalIndex++);}


for(var rowIdx=0;rowIdx < rowIDs.length;rowIdx++) {
var rowID=rowIDs[rowIdx];
var comboID=sectionID + rowID;
var shouldUpdateRow=rowCount >= this.state.prevRenderedRowsCount && 
dataSource.rowShouldUpdate(sectionIdx,rowIdx);
var row=
React.createElement(StaticRenderer,{
key:'r_' + comboID,
shouldUpdate:!!shouldUpdateRow,
render:this.props.renderRow.bind(
null,
dataSource.getRowData(sectionIdx,rowIdx),
sectionID,
rowID,
this.onRowHighlighted)});


bodyComponents.push(row);
totalIndex++;

if(this.props.renderSeparator && (
rowIdx !== rowIDs.length - 1 || sectionIdx === allRowIDs.length - 1)){
var adjacentRowHighlighted=
this.state.highlightedRow.sectionID === sectionID && (
this.state.highlightedRow.rowID === rowID || 
this.state.highlightedRow.rowID === rowIDs[rowIdx + 1]);

var separator=this.props.renderSeparator(
sectionID,
rowID,
adjacentRowHighlighted);

bodyComponents.push(separator);
totalIndex++;}

if(++rowCount === this.state.curRenderedRowsCount){
break;}}


if(rowCount >= this.state.curRenderedRowsCount){
break;}}



var props=merge(
this.props,{
onScroll:this._onScroll,
stickyHeaderIndices:sectionHeaderIndices});


if(!props.scrollEventThrottle){
props.scrollEventThrottle = DEFAULT_SCROLL_CALLBACK_THROTTLE;}

return (
React.createElement(ScrollView,_extends({},props,{
ref:SCROLLVIEW_REF}),
header,
bodyComponents,
footer));},








_measureAndUpdateScrollProps:function(){
RCTUIManager.measureLayout(
this.refs[SCROLLVIEW_REF].getInnerViewNode(),
React.findNodeHandle(this.refs[SCROLLVIEW_REF]),
logError,
this._setScrollContentHeight);

RCTUIManager.measureLayoutRelativeToParent(
React.findNodeHandle(this.refs[SCROLLVIEW_REF]),
logError,
this._setScrollVisibleHeight);},



_setScrollContentHeight:function(left,top,width,height){
this.scrollProperties.contentHeight = height;},


_setScrollVisibleHeight:function(left,top,width,height){
this.scrollProperties.visibleHeight = height;
this._updateVisibleRows();
this._renderMoreRowsIfNeeded();},


_renderMoreRowsIfNeeded:function(){
if(this.scrollProperties.contentHeight === null || 
this.scrollProperties.visibleHeight === null || 
this.state.curRenderedRowsCount === this.props.dataSource.getRowCount()){
return;}


var distanceFromEnd=this._getDistanceFromEnd(this.scrollProperties);
if(distanceFromEnd < this.props.scrollRenderAheadDistance){
this._pageInNewRows();}},



_pageInNewRows:function(){var _this3=this;
this.setState(function(state,props){
var rowsToRender=Math.min(
state.curRenderedRowsCount + props.pageSize,
props.dataSource.getRowCount());

return {
prevRenderedRowsCount:state.curRenderedRowsCount,
curRenderedRowsCount:rowsToRender};},

function(){
_this3._measureAndUpdateScrollProps();
_this3.setState(function(state){return {
prevRenderedRowsCount:state.curRenderedRowsCount};});});},




_getDistanceFromEnd:function(scrollProperties){
return scrollProperties.contentHeight - 
scrollProperties.visibleHeight - 
scrollProperties.offsetY;},


_updateVisibleRows:function(e){var _this4=this;
if(!this.props.onChangeVisibleRows){
return;}

var updatedFrames=e && e.nativeEvent.updatedChildFrames;
if(updatedFrames){
updatedFrames.forEach(function(newFrame){
_this4._childFrames[newFrame.index] = merge(newFrame);});}


var dataSource=this.props.dataSource;
var visibleTop=this.scrollProperties.offsetY;
var visibleBottom=visibleTop + this.scrollProperties.visibleHeight;
var allRowIDs=dataSource.rowIdentities;

var header=this.props.renderHeader && this.props.renderHeader();
var totalIndex=header?1:0;
var visibilityChanged=false;
var changedRows={};
for(var sectionIdx=0;sectionIdx < allRowIDs.length;sectionIdx++) {
var rowIDs=allRowIDs[sectionIdx];
if(rowIDs.length === 0){
continue;}

var sectionID=dataSource.sectionIdentities[sectionIdx];
if(this.props.renderSectionHeader){
totalIndex++;}

var visibleSection=this._visibleRows[sectionID];
if(!visibleSection){
visibleSection = {};}

for(var rowIdx=0;rowIdx < rowIDs.length;rowIdx++) {
var rowID=rowIDs[rowIdx];
var frame=this._childFrames[totalIndex];
totalIndex++;
if(!frame){
break;}

var rowVisible=visibleSection[rowID];
var top=frame.y;
var bottom=top + frame.height;
if(top > visibleBottom || bottom < visibleTop){
if(rowVisible){
visibilityChanged = true;
delete visibleSection[rowID];
if(!changedRows[sectionID]){
changedRows[sectionID] = {};}

changedRows[sectionID][rowID] = false;}}else 

if(!rowVisible){
visibilityChanged = true;
visibleSection[rowID] = true;
if(!changedRows[sectionID]){
changedRows[sectionID] = {};}

changedRows[sectionID][rowID] = true;}}


if(!isEmpty(visibleSection)){
this._visibleRows[sectionID] = visibleSection;}else 
if(this._visibleRows[sectionID]){
delete this._visibleRows[sectionID];}}


visibilityChanged && this.props.onChangeVisibleRows(this._visibleRows,changedRows);},


_onScroll:function(e){
this.scrollProperties.visibleHeight = e.nativeEvent.layoutMeasurement.height;
this.scrollProperties.contentHeight = e.nativeEvent.contentSize.height;
this.scrollProperties.offsetY = e.nativeEvent.contentOffset.y;
this._updateVisibleRows(e);
var nearEnd=this._getDistanceFromEnd(this.scrollProperties) < this.props.onEndReachedThreshold;
if(nearEnd && 
this.props.onEndReached && 
this.scrollProperties.contentHeight !== this._sentEndForContentHeight && 
this.state.curRenderedRowsCount === this.props.dataSource.getRowCount()){
this._sentEndForContentHeight = this.scrollProperties.contentHeight;
this.props.onEndReached(e);}else 
{
this._renderMoreRowsIfNeeded();}


this.props.onScroll && this.props.onScroll(e);}});



module.exports = ListView;
});
__d('ListViewDataSource',["invariant","isEmpty","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}





























var invariant=require('invariant');
var isEmpty=require('isEmpty');
var warning=require('warning');

function defaultGetRowData(
dataBlob,
sectionID,
rowID)
{
return dataBlob[sectionID][rowID];}


function defaultGetSectionHeaderData(
dataBlob,
sectionID)
{
return dataBlob[sectionID];}var 













































ListViewDataSource=(function(){


























function ListViewDataSource(params){_classCallCheck(this,ListViewDataSource);
invariant(
params && typeof params.rowHasChanged === 'function',
'Must provide a rowHasChanged function.');

this._rowHasChanged = params.rowHasChanged;
this._getRowData = params.getRowData || defaultGetRowData;
this._sectionHeaderHasChanged = params.sectionHeaderHasChanged;
this._getSectionHeaderData = 
params.getSectionHeaderData || defaultGetSectionHeaderData;

this._dataBlob = null;
this._dirtyRows = [];
this._dirtySections = [];
this._cachedRowCount = 0;



this.rowIdentities = [];
this.sectionIdentities = [];}_createClass(ListViewDataSource,[{key:'cloneWithRows',value:


















function cloneWithRows(
dataBlob,
rowIdentities)
{
var rowIds=rowIdentities?[rowIdentities]:null;
if(!this._sectionHeaderHasChanged){
this._sectionHeaderHasChanged = function(){return false;};}

return this.cloneWithRowsAndSections({s1:dataBlob},['s1'],rowIds);}},{key:'cloneWithRowsAndSections',value:













function cloneWithRowsAndSections(
dataBlob,
sectionIdentities,
rowIdentities)
{
invariant(
typeof this._sectionHeaderHasChanged === 'function',
'Must provide a sectionHeaderHasChanged function with section data.');

var newSource=new ListViewDataSource({
getRowData:this._getRowData,
getSectionHeaderData:this._getSectionHeaderData,
rowHasChanged:this._rowHasChanged,
sectionHeaderHasChanged:this._sectionHeaderHasChanged});

newSource._dataBlob = dataBlob;
if(sectionIdentities){
newSource.sectionIdentities = sectionIdentities;}else 
{
newSource.sectionIdentities = Object.keys(dataBlob);}

if(rowIdentities){
newSource.rowIdentities = rowIdentities;}else 
{
newSource.rowIdentities = [];
newSource.sectionIdentities.forEach(function(sectionID){
newSource.rowIdentities.push(Object.keys(dataBlob[sectionID]));});}


newSource._cachedRowCount = countRows(newSource.rowIdentities);

newSource._calculateDirtyArrays(
this._dataBlob,
this.sectionIdentities,
this.rowIdentities);


return newSource;}},{key:'getRowCount',value:


function getRowCount(){
return this._cachedRowCount;}},{key:'rowShouldUpdate',value:





function rowShouldUpdate(sectionIndex,rowIndex){
var needsUpdate=this._dirtyRows[sectionIndex][rowIndex];
warning(needsUpdate !== undefined,
'missing dirtyBit for section, row: ' + sectionIndex + ', ' + rowIndex);
return needsUpdate;}},{key:'getRowData',value:





function getRowData(sectionIndex,rowIndex){
var sectionID=this.sectionIdentities[sectionIndex];
var rowID=this.rowIdentities[sectionIndex][rowIndex];
warning(
sectionID !== undefined && rowID !== undefined,
'rendering invalid section, row: ' + sectionIndex + ', ' + rowIndex);

return this._getRowData(this._dataBlob,sectionID,rowID);}},{key:'getRowIDForFlatIndex',value:






function getRowIDForFlatIndex(index){
var accessIndex=index;
for(var ii=0;ii < this.sectionIdentities.length;ii++) {
if(accessIndex >= this.rowIdentities[ii].length){
accessIndex -= this.rowIdentities[ii].length;}else 
{
return this.rowIdentities[ii][accessIndex];}}


return null;}},{key:'getSectionIDForFlatIndex',value:






function getSectionIDForFlatIndex(index){
var accessIndex=index;
for(var ii=0;ii < this.sectionIdentities.length;ii++) {
if(accessIndex >= this.rowIdentities[ii].length){
accessIndex -= this.rowIdentities[ii].length;}else 
{
return this.sectionIdentities[ii];}}


return null;}},{key:'getSectionLengths',value:





function getSectionLengths(){
var results=[];
for(var ii=0;ii < this.sectionIdentities.length;ii++) {
results.push(this.rowIdentities[ii].length);}

return results;}},{key:'sectionHeaderShouldUpdate',value:





function sectionHeaderShouldUpdate(sectionIndex){
var needsUpdate=this._dirtySections[sectionIndex];
warning(needsUpdate !== undefined,
'missing dirtyBit for section: ' + sectionIndex);
return needsUpdate;}},{key:'getSectionHeaderData',value:





function getSectionHeaderData(sectionIndex){
if(!this._getSectionHeaderData){
return null;}

var sectionID=this.sectionIdentities[sectionIndex];
warning(sectionID !== undefined,
'renderSection called on invalid section: ' + sectionIndex);
return this._getSectionHeaderData(this._dataBlob,sectionID);}},{key:'_calculateDirtyArrays',value:





















function _calculateDirtyArrays(
prevDataBlob,
prevSectionIDs,
prevRowIDs)
{

var prevSectionsHash=keyedDictionaryFromArray(prevSectionIDs);
var prevRowsHash={};
for(var ii=0;ii < prevRowIDs.length;ii++) {
var sectionID=prevSectionIDs[ii];
warning(
!prevRowsHash[sectionID],
'SectionID appears more than once: ' + sectionID);

prevRowsHash[sectionID] = keyedDictionaryFromArray(prevRowIDs[ii]);}



this._dirtySections = [];
this._dirtyRows = [];

var dirty;
for(var sIndex=0;sIndex < this.sectionIdentities.length;sIndex++) {
var sectionID=this.sectionIdentities[sIndex];

dirty = !prevSectionsHash[sectionID];
var sectionHeaderHasChanged=this._sectionHeaderHasChanged;
if(!dirty && sectionHeaderHasChanged){
dirty = sectionHeaderHasChanged(
this._getSectionHeaderData(prevDataBlob,sectionID),
this._getSectionHeaderData(this._dataBlob,sectionID));}


this._dirtySections.push(!!dirty);

this._dirtyRows[sIndex] = [];
for(var rIndex=0;rIndex < this.rowIdentities[sIndex].length;rIndex++) {
var rowID=this.rowIdentities[sIndex][rIndex];

dirty = 
!prevSectionsHash[sectionID] || 
!prevRowsHash[sectionID][rowID] || 
this._rowHasChanged(
this._getRowData(prevDataBlob,sectionID,rowID),
this._getRowData(this._dataBlob,sectionID,rowID));

this._dirtyRows[sIndex].push(!!dirty);}}}}]);return ListViewDataSource;})();





function countRows(allRowIDs){
var totalRows=0;
for(var sectionIdx=0;sectionIdx < allRowIDs.length;sectionIdx++) {
var rowIDs=allRowIDs[sectionIdx];
totalRows += rowIDs.length;}

return totalRows;}


function keyedDictionaryFromArray(arr){
if(isEmpty(arr)){
return {};}

var result={};
for(var ii=0;ii < arr.length;ii++) {
var key=arr[ii];
warning(!result[key],'Value appears more than once in array: ' + key);
result[key] = true;}

return result;}



module.exports = ListViewDataSource;
});
__d('isEmpty',[],function(global, require, requireDynamic, requireLazy, module, exports) {  function 



















isEmpty(obj){
if(Array.isArray(obj)){
return obj.length === 0;}else 
if(typeof obj === 'object'){
for(var i in obj) {
return false;}

return true;}else 
{
return !obj;}}



module.exports = isEmpty;
});
__d('ScrollView',["EdgeInsetsPropType","Platform","PointPropType","NativeModules","React","ReactNativeViewAttributes","NativeModules","ScrollResponder","StyleSheet","StyleSheetPropType","View","ViewStylePropTypes","createReactNativeComponentClass","deepDiffer","flattenStyle","insetsDiffer","invariant","pointsDiffer","requireNativeComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var EdgeInsetsPropType=require('EdgeInsetsPropType');
var Platform=require('Platform');
var PointPropType=require('PointPropType');
var RCTScrollView=require('NativeModules').UIManager.RCTScrollView;
var RCTScrollViewConsts=RCTScrollView.Constants;
var React=require('React');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var RCTUIManager=require('NativeModules').UIManager;
var ScrollResponder=require('ScrollResponder');
var StyleSheet=require('StyleSheet');
var StyleSheetPropType=require('StyleSheetPropType');
var View=require('View');
var ViewStylePropTypes=require('ViewStylePropTypes');

var createReactNativeComponentClass=require('createReactNativeComponentClass');
var deepDiffer=require('deepDiffer');
var flattenStyle=require('flattenStyle');
var insetsDiffer=require('insetsDiffer');
var invariant=require('invariant');
var pointsDiffer=require('pointsDiffer');
var requireNativeComponent=require('requireNativeComponent');

var PropTypes=React.PropTypes;

var SCROLLVIEW='ScrollView';
var INNERVIEW='InnerScrollView';

















var ScrollView=React.createClass({displayName:'ScrollView',
propTypes:{
automaticallyAdjustContentInsets:PropTypes.bool,
contentInset:EdgeInsetsPropType,
contentOffset:PointPropType,
onScroll:PropTypes.func,
onScrollAnimationEnd:PropTypes.func,
scrollEnabled:PropTypes.bool,
scrollIndicatorInsets:EdgeInsetsPropType,
showsHorizontalScrollIndicator:PropTypes.bool,
showsVerticalScrollIndicator:PropTypes.bool,
style:StyleSheetPropType(ViewStylePropTypes),
scrollEventThrottle:PropTypes.number,







bounces:PropTypes.bool,





bouncesZoom:PropTypes.bool,





alwaysBounceHorizontal:PropTypes.bool,





alwaysBounceVertical:PropTypes.bool,






centerContent:PropTypes.bool,















contentContainerStyle:StyleSheetPropType(ViewStylePropTypes),






decelerationRate:PropTypes.number,




horizontal:PropTypes.bool,




directionalLockEnabled:PropTypes.bool,




canCancelContentTouches:PropTypes.bool,








keyboardDismissMode:PropTypes.oneOf([
'none',
'interactive',
'on-drag']),







keyboardShouldPersistTaps:PropTypes.bool,



maximumZoomScale:PropTypes.number,



minimumZoomScale:PropTypes.number,





pagingEnabled:PropTypes.bool,




scrollsToTop:PropTypes.bool,







stickyHeaderIndices:PropTypes.arrayOf(PropTypes.number),






removeClippedSubviews:PropTypes.bool,



zoomScale:PropTypes.number},


mixins:[ScrollResponder.Mixin],

getInitialState:function(){
return this.scrollResponderMixinGetInitialState();},


setNativeProps:function(props){
this.refs[SCROLLVIEW].setNativeProps(props);},








getScrollResponder:function(){
return this;},


getInnerViewNode:function(){
return React.findNodeHandle(this.refs[INNERVIEW]);},


scrollTo:function(destY,destX){
if(Platform.OS === 'android'){
RCTUIManager.dispatchViewManagerCommand(
React.findNodeHandle(this),
RCTUIManager.RCTScrollView.Commands.scrollTo,
[destX || 0,destY || 0]);}else 

{
RCTUIManager.scrollTo(
React.findNodeHandle(this),
destX || 0,
destY || 0);}},




scrollWithoutAnimationTo:function(destY,destX){
RCTUIManager.scrollWithoutAnimationTo(
React.findNodeHandle(this),
destX || 0,
destY || 0);},



render:function(){
var contentContainerStyle=[
this.props.horizontal && styles.contentContainerHorizontal,
this.props.contentContainerStyle];

if(__DEV__ && this.props.style){
var style=flattenStyle(this.props.style);
var childLayoutProps=['alignItems','justifyContent'].
filter(function(prop){return style && style[prop] !== undefined;});
invariant(
childLayoutProps.length === 0,
'ScrollView child layout (' + JSON.stringify(childLayoutProps) + 
') must by applied through the contentContainerStyle prop.');}


if(__DEV__){
if(this.props.onScroll && !this.props.scrollEventThrottle){
var onScroll=this.props.onScroll;
this.props.onScroll = function(){
console.log(
'You specified `onScroll` on a <ScrollView> but not ' + 
'`scrollEventThrottle`. You will only receive one event. ' + 
'Using `16` you get all the events but be aware that it may ' + 
'cause frame drops, use a bigger number if you don\'t need as ' + 
'much precision.');

onScroll.apply(this,arguments);};}}




var contentContainer=
React.createElement(View,{
ref:INNERVIEW,
style:contentContainerStyle,
removeClippedSubviews:this.props.removeClippedSubviews},
this.props.children);


var alwaysBounceHorizontal=
this.props.alwaysBounceHorizontal !== undefined?
this.props.alwaysBounceHorizontal:
this.props.horizontal;

var alwaysBounceVertical=
this.props.alwaysBounceVertical !== undefined?
this.props.alwaysBounceVertical:
!this.props.horizontal;

var props=_extends({},
this.props,{
alwaysBounceHorizontal:alwaysBounceHorizontal,
alwaysBounceVertical:alwaysBounceVertical,
style:[styles.base,this.props.style],
onTouchStart:this.scrollResponderHandleTouchStart,
onTouchMove:this.scrollResponderHandleTouchMove,
onTouchEnd:this.scrollResponderHandleTouchEnd,
onScrollBeginDrag:this.scrollResponderHandleScrollBeginDrag,
onScrollEndDrag:this.scrollResponderHandleScrollEndDrag,
onMomentumScrollBegin:this.scrollResponderHandleMomentumScrollBegin,
onMomentumScrollEnd:this.scrollResponderHandleMomentumScrollEnd,
onStartShouldSetResponder:this.scrollResponderHandleStartShouldSetResponder,
onStartShouldSetResponderCapture:this.scrollResponderHandleStartShouldSetResponderCapture,
onScrollShouldSetResponder:this.scrollResponderHandleScrollShouldSetResponder,
onScroll:this.scrollResponderHandleScroll,
onResponderGrant:this.scrollResponderHandleResponderGrant,
onResponderTerminationRequest:this.scrollResponderHandleTerminationRequest,
onResponderTerminate:this.scrollResponderHandleTerminate,
onResponderRelease:this.scrollResponderHandleResponderRelease,
onResponderReject:this.scrollResponderHandleResponderReject});


var ScrollViewClass;
if(Platform.OS === 'ios'){
ScrollViewClass = RCTScrollView;}else 
if(Platform.OS === 'android'){
if(this.props.horizontal){
ScrollViewClass = AndroidHorizontalScrollView;}else 
{
ScrollViewClass = AndroidScrollView;}

var keyboardDismissModeConstants={
'none':RCTScrollViewConsts.KeyboardDismissMode.None,
'interactive':RCTScrollViewConsts.KeyboardDismissMode.Interactive,
'on-drag':RCTScrollViewConsts.KeyboardDismissMode.OnDrag};

props.keyboardDismissMode = props.keyboardDismissMode?
keyboardDismissModeConstants[props.keyboardDismissMode]:undefined;}

invariant(
ScrollViewClass !== undefined,
'ScrollViewClass must not be undefined');


return (
React.createElement(ScrollViewClass,_extends({},props,{ref:SCROLLVIEW}),
contentContainer));}});





var styles=StyleSheet.create({
base:{
flex:1},

contentContainerHorizontal:{
alignSelf:'flex-start',
flexDirection:'row'}});



var validAttributes=_extends({},
ReactNativeViewAttributes.UIView,{
alwaysBounceHorizontal:true,
alwaysBounceVertical:true,
automaticallyAdjustContentInsets:true,
bounces:true,
centerContent:true,
contentInset:{diff:insetsDiffer},
contentOffset:{diff:pointsDiffer},
decelerationRate:true,
horizontal:true,
keyboardDismissMode:true,
keyboardShouldPersistTaps:true,
maximumZoomScale:true,
minimumZoomScale:true,
pagingEnabled:true,
removeClippedSubviews:true,
scrollEnabled:true,
scrollIndicatorInsets:{diff:insetsDiffer},
scrollsToTop:true,
showsHorizontalScrollIndicator:true,
showsVerticalScrollIndicator:true,
stickyHeaderIndices:{diff:deepDiffer},
scrollEventThrottle:true,
zoomScale:true});


if(Platform.OS === 'android'){
var AndroidScrollView=createReactNativeComponentClass({
validAttributes:validAttributes,
uiViewClassName:'RCTScrollView'});

var AndroidHorizontalScrollView=createReactNativeComponentClass({
validAttributes:validAttributes,
uiViewClassName:'AndroidHorizontalScrollView'});}else 

if(Platform.OS === 'ios'){
var RCTScrollView=requireNativeComponent('RCTScrollView',ScrollView);}


module.exports = ScrollView;
});
__d('PointPropType',["ReactPropTypes","createStrictShapeTypeChecker"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var PropTypes=require('ReactPropTypes');

var createStrictShapeTypeChecker=require('createStrictShapeTypeChecker');

var PointPropType=createStrictShapeTypeChecker({
x:PropTypes.number,
y:PropTypes.number});


module.exports = PointPropType;
});
__d('ScrollResponder',["NativeModules","RCTDeviceEventEmitter","React","Subscribable","TextInputState","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeModules=require('NativeModules');
var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');
var React=require('React');
var Subscribable=require('Subscribable');
var TextInputState=require('TextInputState');

var RCTUIManager=NativeModules.UIManager;
var RCTUIManagerDeprecated=NativeModules.UIManager;
var RCTScrollViewConsts=RCTUIManager.RCTScrollView.Constants;

var warning=require('warning');















































































var IS_ANIMATING_TOUCH_START_THRESHOLD_MS=16;










var ScrollResponderMixin={
mixins:[Subscribable.Mixin],
statics:RCTScrollViewConsts,
scrollResponderMixinGetInitialState:function(){
return {
isTouching:false,
lastMomentumScrollBeginTime:0,
lastMomentumScrollEndTime:0,






observedScrollSinceBecomingResponder:false,
becameResponderWhileAnimating:false};},






scrollResponderHandleScrollShouldSetResponder:function(){
return this.state.isTouching;},



























scrollResponderHandleStartShouldSetResponder:function(){
return false;},













scrollResponderHandleStartShouldSetResponderCapture:function(e){

var currentlyFocusedTextInput=TextInputState.currentlyFocusedField();
if(!this.props.keyboardShouldPersistTaps && 
currentlyFocusedTextInput != null && 
e.target !== currentlyFocusedTextInput){
return true;}

return this.scrollResponderIsAnimating();},












scrollResponderHandleResponderReject:function(){
warning(false,'ScrollView doesn\'t take rejection well - scrolls anyway');},

















scrollResponderHandleTerminationRequest:function(){
return !this.state.observedScrollSinceBecomingResponder;},







scrollResponderHandleTouchEnd:function(e){
var nativeEvent=e.nativeEvent;
this.state.isTouching = nativeEvent.touches.length !== 0;
this.props.onTouchEnd && this.props.onTouchEnd(e);},





scrollResponderHandleResponderRelease:function(e){
this.props.onResponderRelease && this.props.onResponderRelease(e);



var currentlyFocusedTextInput=TextInputState.currentlyFocusedField();
if(!this.props.keyboardShouldPersistTaps && 
currentlyFocusedTextInput != null && 
e.target !== currentlyFocusedTextInput && 
!this.state.observedScrollSinceBecomingResponder && 
!this.state.becameResponderWhileAnimating){
this.props.onScrollResponderKeyboardDismissed && 
this.props.onScrollResponderKeyboardDismissed(e);
TextInputState.blurTextInput(currentlyFocusedTextInput);}},



scrollResponderHandleScroll:function(e){
this.state.observedScrollSinceBecomingResponder = true;
this.props.onScroll && this.props.onScroll(e);},





scrollResponderHandleResponderGrant:function(e){
this.state.observedScrollSinceBecomingResponder = false;
this.props.onResponderGrant && this.props.onResponderGrant(e);
this.state.becameResponderWhileAnimating = this.scrollResponderIsAnimating();},









scrollResponderHandleScrollBeginDrag:function(e){
this.props.onScrollBeginDrag && this.props.onScrollBeginDrag(e);},





scrollResponderHandleScrollEndDrag:function(e){
this.props.onScrollEndDrag && this.props.onScrollEndDrag(e);},





scrollResponderHandleMomentumScrollBegin:function(e){
this.state.lastMomentumScrollBeginTime = Date.now();
this.props.onMomentumScrollBegin && this.props.onMomentumScrollBegin(e);},





scrollResponderHandleMomentumScrollEnd:function(e){
this.state.lastMomentumScrollEndTime = Date.now();
this.props.onMomentumScrollEnd && this.props.onMomentumScrollEnd(e);},













scrollResponderHandleTouchStart:function(e){
this.state.isTouching = true;
this.props.onTouchStart && this.props.onTouchStart(e);},













scrollResponderHandleTouchMove:function(e){
this.props.onTouchMove && this.props.onTouchMove(e);},







scrollResponderIsAnimating:function(){
var now=Date.now();
var timeSinceLastMomentumScrollEnd=now - this.state.lastMomentumScrollEndTime;
var isAnimating=timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || 
this.state.lastMomentumScrollEndTime < this.state.lastMomentumScrollBeginTime;
return isAnimating;},







scrollResponderScrollTo:function(offsetX,offsetY){
RCTUIManagerDeprecated.scrollTo(React.findNodeHandle(this),offsetX,offsetY);},






scrollResponderZoomTo:function(rect){
RCTUIManagerDeprecated.zoomToRect(React.findNodeHandle(this),rect);},












scrollResponderScrollNativeHandleToKeyboard:function(nodeHandle,additionalOffset,preventNegativeScrollOffset){
this.additionalScrollOffset = additionalOffset || 0;
this.preventNegativeScrollOffset = !!preventNegativeScrollOffset;
RCTUIManager.measureLayout(
nodeHandle,
React.findNodeHandle(this),
this.scrollResponderTextInputFocusError,
this.scrollResponderInputMeasureAndScrollToKeyboard);},













scrollResponderInputMeasureAndScrollToKeyboard:function(left,top,width,height){
if(this.keyboardWillOpenTo){
var scrollOffsetY=
top - this.keyboardWillOpenTo.endCoordinates.screenY + height + 
this.additionalScrollOffset;





if(this.preventNegativeScrollOffset){
scrollOffsetY = Math.max(0,scrollOffsetY);}

this.scrollResponderScrollTo(0,scrollOffsetY);}

this.additionalOffset = 0;
this.preventNegativeScrollOffset = false;},


scrollResponderTextInputFocusError:function(e){
console.error('Error measuring text field: ',e);},








componentWillMount:function(){
this.keyboardWillOpenTo = null;
this.additionalScrollOffset = 0;
this.addListenerOn(RCTDeviceEventEmitter,'keyboardWillShow',this.scrollResponderKeyboardWillShow);
this.addListenerOn(RCTDeviceEventEmitter,'keyboardWillHide',this.scrollResponderKeyboardWillHide);
this.addListenerOn(RCTDeviceEventEmitter,'keyboardDidShow',this.scrollResponderKeyboardDidShow);
this.addListenerOn(RCTDeviceEventEmitter,'keyboardDidHide',this.scrollResponderKeyboardDidHide);},






























scrollResponderKeyboardWillShow:function(e){
this.keyboardWillOpenTo = e;
this.props.onKeyboardWillShow && this.props.onKeyboardWillShow(e);},


scrollResponderKeyboardWillHide:function(e){
this.keyboardWillOpenTo = null;
this.props.onKeyboardWillHide && this.props.onKeyboardWillHide(e);},


scrollResponderKeyboardDidShow:function(){
this.keyboardWillOpenTo = null;
this.props.onKeyboardDidShow && this.props.onKeyboardDidShow();},


scrollResponderKeyboardDidHide:function(){
this.keyboardWillOpenTo = null;
this.props.onKeyboardDidHide && this.props.onKeyboardDidHide();}};




var ScrollResponder={
Mixin:ScrollResponderMixin};


module.exports = ScrollResponder;
});
__d('Subscribable',["EventEmitter"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






















var Subscribable={};

Subscribable.Mixin = {

componentWillMount:function(){
this._subscribableSubscriptions = [];},


componentWillUnmount:function(){
this._subscribableSubscriptions.forEach(
function(subscription){return subscription.remove();});

this._subscribableSubscriptions = null;},















addListenerOn:function(
eventEmitter,
eventType,
listener,
context)
{
this._subscribableSubscriptions.push(
eventEmitter.addListener(eventType,listener,context));}};




module.exports = Subscribable;
});
__d('StaticRenderer',["React"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var React=require('React');

var StaticRenderer=React.createClass({displayName:'StaticRenderer',
propTypes:{
shouldUpdate:React.PropTypes.bool.isRequired,
render:React.PropTypes.func.isRequired},


shouldComponentUpdate:function(nextProps){
return nextProps.shouldUpdate;},


render:function(){
return this.props.render();}});



module.exports = StaticRenderer;
});
__d('react-timer-mixin/TimerMixin.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';










var GLOBAL=typeof window === 'undefined'?global:window;

var setter=function(_setter,_clearer,array){
return function(callback,delta){
var id=_setter((function(){
_clearer.call(this,id);
callback.apply(this,arguments);}).
bind(this),delta);

if(!this[array]){
this[array] = [id];}else 
{
this[array].push(id);}

return id;};};



var clearer=function(_clearer,array){
return function(id){
if(this[array]){
var index=this[array].indexOf(id);
if(index !== -1){
this[array].splice(index,1);}}


_clearer(id);};};



var _timeouts='TimerMixin_timeouts';
var _clearTimeout=clearer(GLOBAL.clearTimeout,_timeouts);
var _setTimeout=setter(GLOBAL.setTimeout,_clearTimeout,_timeouts);

var _intervals='TimerMixin_intervals';
var _clearInterval=clearer(GLOBAL.clearInterval,_intervals);
var _setInterval=setter(GLOBAL.setInterval,function(){},_intervals);

var _immediates='TimerMixin_immediates';
var _clearImmediate=clearer(GLOBAL.clearImmediate,_immediates);
var _setImmediate=setter(GLOBAL.setImmediate,_clearImmediate,_immediates);

var _rafs='TimerMixin_rafs';
var _cancelAnimationFrame=clearer(GLOBAL.cancelAnimationFrame,_rafs);
var _requestAnimationFrame=setter(GLOBAL.requestAnimationFrame,_cancelAnimationFrame,_rafs);

var TimerMixin={
componentWillUnmount:function(){
this[_timeouts] && this[_timeouts].forEach(this.clearTimeout);
this[_intervals] && this[_intervals].forEach(this.clearInterval);
this[_immediates] && this[_immediates].forEach(this.clearImmediate);
this[_rafs] && this[_rafs].forEach(this.cancelAnimationFrame);},


setTimeout:_setTimeout,
clearTimeout:_clearTimeout,

setInterval:_setInterval,
clearInterval:_clearInterval,

setImmediate:_setImmediate,
clearImmediate:_clearImmediate,

requestAnimationFrame:_requestAnimationFrame,
cancelAnimationFrame:_cancelAnimationFrame};


module.exports = TimerMixin;
});
__d('MapView',["EdgeInsetsPropType","NativeMethodsMixin","Platform","React","ReactNativeViewAttributes","View","createReactNativeComponentClass","deepDiffer","insetsDiffer","merge","requireNativeComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var EdgeInsetsPropType=require('EdgeInsetsPropType');
var NativeMethodsMixin=require('NativeMethodsMixin');
var Platform=require('Platform');
var React=require('React');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var View=require('View');

var createReactNativeComponentClass=require('createReactNativeComponentClass');
var deepDiffer=require('deepDiffer');
var insetsDiffer=require('insetsDiffer');
var merge=require('merge');
var requireNativeComponent=require('requireNativeComponent');









var MapView=React.createClass({displayName:'MapView',
mixins:[NativeMethodsMixin],

propTypes:{




style:View.propTypes.style,









showsUserLocation:React.PropTypes.bool,





zoomEnabled:React.PropTypes.bool,








rotateEnabled:React.PropTypes.bool,








pitchEnabled:React.PropTypes.bool,





scrollEnabled:React.PropTypes.bool,








mapType:React.PropTypes.oneOf([
'standard',
'satellite',
'hybrid']),








region:React.PropTypes.shape({



latitude:React.PropTypes.number.isRequired,
longitude:React.PropTypes.number.isRequired,





latitudeDelta:React.PropTypes.number.isRequired,
longitudeDelta:React.PropTypes.number.isRequired}),





annotations:React.PropTypes.arrayOf(React.PropTypes.shape({



latitude:React.PropTypes.number.isRequired,
longitude:React.PropTypes.number.isRequired,




title:React.PropTypes.string,
subtitle:React.PropTypes.string})),





maxDelta:React.PropTypes.number,




minDelta:React.PropTypes.number,





legalLabelInsets:EdgeInsetsPropType,




onRegionChange:React.PropTypes.func,




onRegionChangeComplete:React.PropTypes.func},


_onChange:function(event){
if(event.nativeEvent.continuous){
this.props.onRegionChange && 
this.props.onRegionChange(event.nativeEvent.region);}else 
{
this.props.onRegionChangeComplete && 
this.props.onRegionChangeComplete(event.nativeEvent.region);}},



render:function(){
return React.createElement(RCTMap,_extends({},this.props,{onChange:this._onChange}));}});



if(Platform.OS === 'android'){
var RCTMap=createReactNativeComponentClass({
validAttributes:merge(
ReactNativeViewAttributes.UIView,{
showsUserLocation:true,
zoomEnabled:true,
rotateEnabled:true,
pitchEnabled:true,
scrollEnabled:true,
region:{diff:deepDiffer},
annotations:{diff:deepDiffer},
maxDelta:true,
minDelta:true,
legalLabelInsets:{diff:insetsDiffer}}),


uiViewClassName:'RCTMap'});}else 

{
var RCTMap=requireNativeComponent('RCTMap',MapView);}


module.exports = MapView;
});
__d('Navigator',["NativeModules","Dimensions","InteractionMixin","NavigationContext","NavigatorBreadcrumbNavigationBar","NavigatorNavigationBar","NavigatorSceneConfigs","PanResponder","React","StaticContainer.react","StyleSheet","Subscribable","View","clamp","flattenStyle","invariant","react-timer-mixin/TimerMixin.js","rebound/rebound.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};




























var AnimationsDebugModule=require('NativeModules').AnimationsDebugModule;
var Dimensions=require('Dimensions');
var InteractionMixin=require('InteractionMixin');
var NavigationContext=require('NavigationContext');
var NavigatorBreadcrumbNavigationBar=require('NavigatorBreadcrumbNavigationBar');
var NavigatorNavigationBar=require('NavigatorNavigationBar');
var NavigatorSceneConfigs=require('NavigatorSceneConfigs');
var PanResponder=require('PanResponder');
var React=require('React');
var StaticContainer=require('StaticContainer.react');
var StyleSheet=require('StyleSheet');
var Subscribable=require('Subscribable');
var TimerMixin=require('react-timer-mixin/TimerMixin.js');
var View=require('View');

var clamp=require('clamp');
var flattenStyle=require('flattenStyle');
var invariant=require('invariant');
var rebound=require('rebound/rebound.js');

var PropTypes=React.PropTypes;




var SCREEN_WIDTH=Dimensions.get('window').width;
var SCREEN_HEIGHT=Dimensions.get('window').height;
var SCENE_DISABLED_NATIVE_PROPS={
style:{
left:SCREEN_WIDTH,
opacity:0}};



var __uid=0;
function getuid(){
return __uid++;}



var styles=StyleSheet.create({
container:{
flex:1,
overflow:'hidden'},

defaultSceneStyle:{
position:'absolute',
left:0,
right:0,
bottom:0,
top:0},

baseScene:{
position:'absolute',
overflow:'hidden',
left:0,
right:0,
bottom:0,
top:0},

disabledScene:{
left:SCREEN_WIDTH},

transitioner:{
flex:1,
backgroundColor:'transparent',
overflow:'hidden'}});



var GESTURE_ACTIONS=[
'pop',
'jumpBack',
'jumpForward'];





























































var Navigator=React.createClass({displayName:'Navigator',

propTypes:{









configureScene:PropTypes.func,










renderScene:PropTypes.func.isRequired,







initialRoute:PropTypes.object,






initialRouteStack:PropTypes.arrayOf(PropTypes.object),







onWillFocus:PropTypes.func,








onDidFocus:PropTypes.func,




onItemRef:PropTypes.func,





navigationBar:PropTypes.node,




navigator:PropTypes.object,




sceneStyle:View.propTypes.style},


statics:{
BreadcrumbNavigationBar:NavigatorBreadcrumbNavigationBar,
NavigationBar:NavigatorNavigationBar,
SceneConfigs:NavigatorSceneConfigs},


mixins:[TimerMixin,InteractionMixin,Subscribable.Mixin],

getDefaultProps:function(){
return {
configureScene:function(){return NavigatorSceneConfigs.PushFromRight;},
sceneStyle:styles.defaultSceneStyle};},



getInitialState:function(){var _this=this;
var routeStack=this.props.initialRouteStack || [this.props.initialRoute];
invariant(
routeStack.length >= 1,
'Navigator requires props.initialRoute or props.initialRouteStack.');

var initialRouteIndex=routeStack.length - 1;
if(this.props.initialRoute){
initialRouteIndex = routeStack.indexOf(this.props.initialRoute);
invariant(
initialRouteIndex !== -1,
'initialRoute is not in initialRouteStack.');}


return {
sceneConfigStack:routeStack.map(
function(route){return _this.props.configureScene(route);}),

idStack:routeStack.map(function(){return getuid();}),
routeStack:routeStack,


updatingRangeStart:0,
updatingRangeLength:routeStack.length,
presentedIndex:initialRouteIndex,
transitionFromIndex:null,
activeGesture:null,
pendingGestureProgress:null,
transitionQueue:[]};},



componentWillMount:function(){var _this2=this;

this.__defineGetter__('navigationContext',this._getNavigationContext);

this._subRouteFocus = [];
this.parentNavigator = this.props.navigator;
this._handlers = {};
this.springSystem = new rebound.SpringSystem();
this.spring = this.springSystem.createSpring();
this.spring.setRestSpeedThreshold(0.05);
this.spring.setCurrentValue(0).setAtRest();
this.spring.addListener({
onSpringEndStateChange:function(){
if(!_this2._interactionHandle){
_this2._interactionHandle = _this2.createInteractionHandle();}},


onSpringUpdate:function(){
_this2._handleSpringUpdate();},

onSpringAtRest:function(){
_this2._completeTransition();}});


this.panGesture = PanResponder.create({
onMoveShouldSetPanResponder:this._handleMoveShouldSetPanResponder,
onPanResponderGrant:this._handlePanResponderGrant,
onPanResponderRelease:this._handlePanResponderRelease,
onPanResponderMove:this._handlePanResponderMove,
onPanResponderTerminate:this._handlePanResponderTerminate});

this._itemRefs = {};
this._interactionHandle = null;
this._emitWillFocus(this.state.routeStack[this.state.presentedIndex]);},


componentDidMount:function(){
this._handleSpringUpdate();
this._emitDidFocus(this.state.routeStack[this.state.presentedIndex]);},


componentWillUnmount:function(){
if(this._navigationContext){
this._navigationContext.dispose();
this._navigationContext = null;}},










immediatelyResetRouteStack:function(nextRouteStack){var _this3=this;
var destIndex=nextRouteStack.length - 1;
this.setState({
idStack:nextRouteStack.map(getuid),
routeStack:nextRouteStack,
sceneConfigStack:nextRouteStack.map(
this.props.configureScene),

updatingRangeStart:0,
updatingRangeLength:nextRouteStack.length,
presentedIndex:destIndex,
activeGesture:null,
transitionFromIndex:null,
transitionQueue:[]},
function(){
_this3._handleSpringUpdate();});},



_transitionTo:function(destIndex,velocity,jumpSpringTo,cb){
if(destIndex === this.state.presentedIndex){
return;}

if(this.state.transitionFromIndex !== null){
this.state.transitionQueue.push({
destIndex:destIndex,
velocity:velocity,
cb:cb});

return;}

this.state.transitionFromIndex = this.state.presentedIndex;
this.state.presentedIndex = destIndex;
this.state.transitionCb = cb;
this._onAnimationStart();
if(AnimationsDebugModule){
AnimationsDebugModule.startRecordingFps();}

var sceneConfig=this.state.sceneConfigStack[this.state.transitionFromIndex] || 
this.state.sceneConfigStack[this.state.presentedIndex];
invariant(
sceneConfig,
'Cannot configure scene at index ' + this.state.transitionFromIndex);

if(jumpSpringTo != null){
this.spring.setCurrentValue(jumpSpringTo);}

this.spring.setOvershootClampingEnabled(true);
this.spring.getSpringConfig().friction = sceneConfig.springFriction;
this.spring.getSpringConfig().tension = sceneConfig.springTension;
this.spring.setVelocity(velocity || sceneConfig.defaultTransitionVelocity);
this.spring.setEndValue(1);
this._emitWillFocus(this.state.routeStack[this.state.presentedIndex]);},






_handleSpringUpdate:function(){

if(this.state.transitionFromIndex != null){
this._transitionBetween(
this.state.transitionFromIndex,
this.state.presentedIndex,
this.spring.getCurrentValue());}else 

if(this.state.activeGesture != null){
var presentedToIndex=this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);
this._transitionBetween(
this.state.presentedIndex,
presentedToIndex,
this.spring.getCurrentValue());}},







_completeTransition:function(){
if(this.spring.getCurrentValue() !== 1 && this.spring.getCurrentValue() !== 0){


if(this.state.pendingGestureProgress){
this.state.pendingGestureProgress = null;}

return;}

this._onAnimationEnd();
var presentedIndex=this.state.presentedIndex;
var didFocusRoute=this._subRouteFocus[presentedIndex] || this.state.routeStack[presentedIndex];
this._emitDidFocus(didFocusRoute);
if(AnimationsDebugModule){
AnimationsDebugModule.stopRecordingFps(Date.now());}

this.state.transitionFromIndex = null;
this.spring.setCurrentValue(0).setAtRest();
this._hideScenes();
if(this.state.transitionCb){
this.state.transitionCb();
this.state.transitionCb = null;}

if(this._interactionHandle){
this.clearInteractionHandle(this._interactionHandle);
this._interactionHandle = null;}

if(this.state.pendingGestureProgress){


var gestureToIndex=this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);
this._enableScene(gestureToIndex);
this.spring.setEndValue(this.state.pendingGestureProgress);
return;}

if(this.state.transitionQueue.length){
var queuedTransition=this.state.transitionQueue.shift();
this._enableScene(queuedTransition.destIndex);
this._transitionTo(
queuedTransition.destIndex,
queuedTransition.velocity,
null,
queuedTransition.cb);}},




_emitDidFocus:function(route){
this.navigationContext.emit('didfocus',{route:route});

if(this.props.onDidFocus){
this.props.onDidFocus(route);}},



_emitWillFocus:function(route){
this.navigationContext.emit('willfocus',{route:route});

var navBar=this._navBar;
if(navBar && navBar.handleWillFocus){
navBar.handleWillFocus(route);}

if(this.props.onWillFocus){
this.props.onWillFocus(route);}},






_hideScenes:function(){
var gesturingToIndex=null;
if(this.state.activeGesture){
gesturingToIndex = this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);}

for(var i=0;i < this.state.routeStack.length;i++) {
if(i === this.state.presentedIndex || 
i === this.state.transitionFromIndex || 
i === gesturingToIndex){
continue;}

this._disableScene(i);}},






_disableScene:function(sceneIndex){
this.refs['scene_' + sceneIndex] && 
this.refs['scene_' + sceneIndex].setNativeProps(SCENE_DISABLED_NATIVE_PROPS);},





_enableScene:function(sceneIndex){

var sceneStyle=flattenStyle([styles.baseScene,this.props.sceneStyle]);

var enabledSceneNativeProps={
left:sceneStyle.left};

if(sceneIndex !== this.state.transitionFromIndex && 
sceneIndex !== this.state.presentedIndex){


enabledSceneNativeProps.opacity = 0;}

this.refs['scene_' + sceneIndex] && 
this.refs['scene_' + sceneIndex].setNativeProps(enabledSceneNativeProps);},


_onAnimationStart:function(){
var fromIndex=this.state.presentedIndex;
var toIndex=this.state.presentedIndex;
if(this.state.transitionFromIndex != null){
fromIndex = this.state.transitionFromIndex;}else 
if(this.state.activeGesture){
toIndex = this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);}

this._setRenderSceneToHarwareTextureAndroid(fromIndex,true);
this._setRenderSceneToHarwareTextureAndroid(toIndex,true);
var navBar=this._navBar;
if(navBar && navBar.onAnimationStart){
navBar.onAnimationStart(fromIndex,toIndex);}},



_onAnimationEnd:function(){
var max=this.state.routeStack.length - 1;
for(var index=0;index <= max;index++) {
this._setRenderSceneToHarwareTextureAndroid(index,false);}


var navBar=this._navBar;
if(navBar && navBar.onAnimationEnd){
navBar.onAnimationEnd();}},



_setRenderSceneToHarwareTextureAndroid:function(sceneIndex,shouldRenderToHardwareTexture){
var viewAtIndex=this.refs['scene_' + sceneIndex];
if(viewAtIndex === null || viewAtIndex === undefined){
return;}

viewAtIndex.setNativeProps({renderToHardwareTextureAndroid:shouldRenderToHardwareTexture});},


_handleTouchStart:function(){
this._eligibleGestures = GESTURE_ACTIONS;},


_handleMoveShouldSetPanResponder:function(e,gestureState){
var sceneConfig=this.state.sceneConfigStack[this.state.presentedIndex];
this._expectingGestureGrant = this._matchGestureAction(this._eligibleGestures,sceneConfig.gestures,gestureState);
return !!this._expectingGestureGrant;},


_doesGestureOverswipe:function(gestureName){
var wouldOverswipeBack=this.state.presentedIndex <= 0 && (
gestureName === 'pop' || gestureName === 'jumpBack');
var wouldOverswipeForward=this.state.presentedIndex >= this.state.routeStack.length - 1 && 
gestureName === 'jumpForward';
return wouldOverswipeForward || wouldOverswipeBack;},


_handlePanResponderGrant:function(e,gestureState){
invariant(
this._expectingGestureGrant,
'Responder granted unexpectedly.');

this._attachGesture(this._expectingGestureGrant);
this._onAnimationStart();
this._expectingGestureGrant = null;},


_deltaForGestureAction:function(gestureAction){
switch(gestureAction){
case 'pop':
case 'jumpBack':
return -1;
case 'jumpForward':
return 1;
default:
invariant(false,'Unsupported gesture action ' + gestureAction);
return;}},



_handlePanResponderRelease:function(e,gestureState){var _this4=this;
var sceneConfig=this.state.sceneConfigStack[this.state.presentedIndex];
var releaseGestureAction=this.state.activeGesture;
if(!releaseGestureAction){

return;}

var releaseGesture=sceneConfig.gestures[releaseGestureAction];
var destIndex=this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);
if(this.spring.getCurrentValue() === 0){

this.spring.setCurrentValue(0).setAtRest();
this._completeTransition();
return;}

var isTravelVertical=releaseGesture.direction === 'top-to-bottom' || releaseGesture.direction === 'bottom-to-top';
var isTravelInverted=releaseGesture.direction === 'right-to-left' || releaseGesture.direction === 'bottom-to-top';
var velocity,gestureDistance;
if(isTravelVertical){
velocity = isTravelInverted?-gestureState.vy:gestureState.vy;
gestureDistance = isTravelInverted?-gestureState.dy:gestureState.dy;}else 
{
velocity = isTravelInverted?-gestureState.vx:gestureState.vx;
gestureDistance = isTravelInverted?-gestureState.dx:gestureState.dx;}

var transitionVelocity=clamp(-10,velocity,10);
if(Math.abs(velocity) < releaseGesture.notMoving){

var hasGesturedEnoughToComplete=gestureDistance > releaseGesture.fullDistance * releaseGesture.stillCompletionRatio;
transitionVelocity = hasGesturedEnoughToComplete?releaseGesture.snapVelocity:-releaseGesture.snapVelocity;}

if(transitionVelocity < 0 || this._doesGestureOverswipe(releaseGestureAction)){


if(this.state.transitionFromIndex == null){

var transitionBackToPresentedIndex=this.state.presentedIndex;

this.state.presentedIndex = destIndex;
this._transitionTo(
transitionBackToPresentedIndex,
-transitionVelocity,
1 - this.spring.getCurrentValue());}}else 


{

this._transitionTo(
destIndex,
transitionVelocity,
null,
function(){
if(releaseGestureAction === 'pop'){
_this4._cleanScenesPastIndex(destIndex);}});}




this._detachGesture();},


_handlePanResponderTerminate:function(e,gestureState){
var destIndex=this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);
this._detachGesture();
var transitionBackToPresentedIndex=this.state.presentedIndex;

this.state.presentedIndex = destIndex;
this._transitionTo(
transitionBackToPresentedIndex,
null,
1 - this.spring.getCurrentValue());},



_attachGesture:function(gestureId){
this.state.activeGesture = gestureId;
var gesturingToIndex=this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);
this._enableScene(gesturingToIndex);},


_detachGesture:function(){
this.state.activeGesture = null;
this.state.pendingGestureProgress = null;
this._hideScenes();},


_handlePanResponderMove:function(e,gestureState){
var sceneConfig=this.state.sceneConfigStack[this.state.presentedIndex];
if(this.state.activeGesture){
var gesture=sceneConfig.gestures[this.state.activeGesture];
return this._moveAttachedGesture(gesture,gestureState);}

var matchedGesture=this._matchGestureAction(GESTURE_ACTIONS,sceneConfig.gestures,gestureState);
if(matchedGesture){
this._attachGesture(matchedGesture);}},



_moveAttachedGesture:function(gesture,gestureState){
var isTravelVertical=gesture.direction === 'top-to-bottom' || gesture.direction === 'bottom-to-top';
var isTravelInverted=gesture.direction === 'right-to-left' || gesture.direction === 'bottom-to-top';
var distance=isTravelVertical?gestureState.dy:gestureState.dx;
distance = isTravelInverted?-distance:distance;
var gestureDetectMovement=gesture.gestureDetectMovement;
var nextProgress=(distance - gestureDetectMovement) / (
gesture.fullDistance - gestureDetectMovement);
if(nextProgress < 0 && gesture.isDetachable){
var gesturingToIndex=this.state.presentedIndex + this._deltaForGestureAction(this.state.activeGesture);
this._transitionBetween(this.state.presentedIndex,gesturingToIndex,0);
this._detachGesture();
if(this.state.pendingGestureProgress != null){
this.spring.setCurrentValue(0);}

return;}

if(this._doesGestureOverswipe(this.state.activeGesture)){
var frictionConstant=gesture.overswipe.frictionConstant;
var frictionByDistance=gesture.overswipe.frictionByDistance;
var frictionRatio=1 / (frictionConstant + Math.abs(nextProgress) * frictionByDistance);
nextProgress *= frictionRatio;}

nextProgress = clamp(0,nextProgress,1);
if(this.state.transitionFromIndex != null){
this.state.pendingGestureProgress = nextProgress;}else 
if(this.state.pendingGestureProgress){
this.spring.setEndValue(nextProgress);}else 
{
this.spring.setCurrentValue(nextProgress);}},



_matchGestureAction:function(eligibleGestures,gestures,gestureState){var _this5=this;
if(!gestures){
return null;}

var matchedGesture=null;
eligibleGestures.some(function(gestureName,gestureIndex){
var gesture=gestures[gestureName];
if(!gesture){
return;}

if(gesture.overswipe == null && _this5._doesGestureOverswipe(gestureName)){

return false;}

var isTravelVertical=gesture.direction === 'top-to-bottom' || gesture.direction === 'bottom-to-top';
var isTravelInverted=gesture.direction === 'right-to-left' || gesture.direction === 'bottom-to-top';
var currentLoc=isTravelVertical?gestureState.moveY:gestureState.moveX;
var travelDist=isTravelVertical?gestureState.dy:gestureState.dx;
var oppositeAxisTravelDist=
isTravelVertical?gestureState.dx:gestureState.dy;
var edgeHitWidth=gesture.edgeHitWidth;
if(isTravelInverted){
currentLoc = -currentLoc;
travelDist = -travelDist;
oppositeAxisTravelDist = -oppositeAxisTravelDist;
edgeHitWidth = isTravelVertical?
-(SCREEN_HEIGHT - edgeHitWidth):
-(SCREEN_WIDTH - edgeHitWidth);}

var moveStartedInRegion=gesture.edgeHitWidth == null || 
currentLoc < edgeHitWidth;
if(!moveStartedInRegion){
return false;}

var moveTravelledFarEnough=travelDist >= gesture.gestureDetectMovement;
if(!moveTravelledFarEnough){
return false;}

var directionIsCorrect=Math.abs(travelDist) > Math.abs(oppositeAxisTravelDist) * gesture.directionRatio;
if(directionIsCorrect){
matchedGesture = gestureName;
return true;}else 
{
_this5._eligibleGestures = _this5._eligibleGestures.slice().splice(gestureIndex,1);}});


return matchedGesture;},


_transitionSceneStyle:function(fromIndex,toIndex,progress,index){
var viewAtIndex=this.refs['scene_' + index];
if(viewAtIndex === null || viewAtIndex === undefined){
return;}


var sceneConfigIndex=fromIndex < toIndex?toIndex:fromIndex;
var sceneConfig=this.state.sceneConfigStack[sceneConfigIndex];

if(!sceneConfig){
sceneConfig = this.state.sceneConfigStack[sceneConfigIndex - 1];}

var styleToUse={};
var useFn=index < fromIndex || index < toIndex?
sceneConfig.animationInterpolators.out:
sceneConfig.animationInterpolators.into;
var directionAdjustedProgress=fromIndex < toIndex?progress:1 - progress;
var didChange=useFn(styleToUse,directionAdjustedProgress);
if(didChange){
viewAtIndex.setNativeProps({style:styleToUse});}},



_transitionBetween:function(fromIndex,toIndex,progress){
this._transitionSceneStyle(fromIndex,toIndex,progress,fromIndex);
this._transitionSceneStyle(fromIndex,toIndex,progress,toIndex);
var navBar=this._navBar;
if(navBar && navBar.updateProgress && toIndex >= 0 && fromIndex >= 0){
navBar.updateProgress(progress,fromIndex,toIndex);}},



_handleResponderTerminationRequest:function(){
return false;},


_resetUpdatingRange:function(){
this.state.updatingRangeStart = 0;
this.state.updatingRangeLength = this.state.routeStack.length;},


_getDestIndexWithinBounds:function(n){
var currentIndex=this.state.presentedIndex;
var destIndex=currentIndex + n;
invariant(
destIndex >= 0,
'Cannot jump before the first route.');

var maxIndex=this.state.routeStack.length - 1;
invariant(
maxIndex >= destIndex,
'Cannot jump past the last route.');

return destIndex;},


_jumpN:function(n){var _this6=this;
var destIndex=this._getDestIndexWithinBounds(n);
var requestTransitionAndResetUpdatingRange=function(){
_this6._enableScene(destIndex);
_this6._transitionTo(destIndex);
_this6._resetUpdatingRange();};

this.setState({
updatingRangeStart:destIndex,
updatingRangeLength:1},
requestTransitionAndResetUpdatingRange);},


jumpTo:function(route){
var destIndex=this.state.routeStack.indexOf(route);
invariant(
destIndex !== -1,
'Cannot jump to route that is not in the route stack');

this._jumpN(destIndex - this.state.presentedIndex);},


jumpForward:function(){
this._jumpN(1);},


jumpBack:function(){
this._jumpN(-1);},


push:function(route){var _this7=this;
invariant(!!route,'Must supply route to push');
var activeLength=this.state.presentedIndex + 1;
var activeStack=this.state.routeStack.slice(0,activeLength);
var activeIDStack=this.state.idStack.slice(0,activeLength);
var activeAnimationConfigStack=this.state.sceneConfigStack.slice(0,activeLength);
var nextStack=activeStack.concat([route]);
var destIndex=nextStack.length - 1;
var nextIDStack=activeIDStack.concat([getuid()]);
var nextAnimationConfigStack=activeAnimationConfigStack.concat([
this.props.configureScene(route)]);

var requestTransitionAndResetUpdatingRange=function(){
_this7._enableScene(destIndex);
_this7._transitionTo(destIndex);
_this7._resetUpdatingRange();};

this.setState({
idStack:nextIDStack,
routeStack:nextStack,
sceneConfigStack:nextAnimationConfigStack,
updatingRangeStart:nextStack.length - 1,
updatingRangeLength:1},
requestTransitionAndResetUpdatingRange);},


_popN:function(n){var _this8=this;
if(n === 0){
return;}

invariant(
this.state.presentedIndex - n >= 0,
'Cannot pop below zero');

var popIndex=this.state.presentedIndex - n;
this._enableScene(popIndex);
this._transitionTo(
popIndex,
null,
null,
function(){
_this8._cleanScenesPastIndex(popIndex);});},




pop:function(){
this._popN(1);},








replaceAtIndex:function(route,index,cb){var _this9=this;
invariant(!!route,'Must supply route to replace');
if(index < 0){
index += this.state.routeStack.length;}


if(this.state.routeStack.length <= index){
return;}




var nextIDStack=this.state.idStack.slice();
var nextRouteStack=this.state.routeStack.slice();
var nextAnimationModeStack=this.state.sceneConfigStack.slice();
nextIDStack[index] = getuid();
nextRouteStack[index] = route;
nextAnimationModeStack[index] = this.props.configureScene(route);

this.setState({
idStack:nextIDStack,
routeStack:nextRouteStack,
sceneConfigStack:nextAnimationModeStack,
updatingRangeStart:index,
updatingRangeLength:1},
function(){
_this9._resetUpdatingRange();
if(index === _this9.state.presentedIndex){
_this9._emitWillFocus(route);
_this9._emitDidFocus(route);}

cb && cb();});},






replace:function(route){
this.replaceAtIndex(route,this.state.presentedIndex);},





replacePrevious:function(route){
this.replaceAtIndex(route,this.state.presentedIndex - 1);},


popToTop:function(){
this.popToRoute(this.state.routeStack[0]);},


popToRoute:function(route){
var indexOfRoute=this.state.routeStack.indexOf(route);
invariant(
indexOfRoute !== -1,
'Calling popToRoute for a route that doesn\'t exist!');

var numToPop=this.state.presentedIndex - indexOfRoute;
this._popN(numToPop);},


replacePreviousAndPop:function(route){
if(this.state.routeStack.length < 2){
return;}

this.replacePrevious(route);
this.pop();},


resetTo:function(route){var _this10=this;
invariant(!!route,'Must supply route to push');
this.replaceAtIndex(route,0,function(){


if(_this10.state.presentedIndex > 0){
_this10._popN(_this10.state.presentedIndex);}});},




getCurrentRoutes:function(){
return this.state.routeStack;},


_handleItemRef:function(itemId,route,ref){
this._itemRefs[itemId] = ref;
var itemIndex=this.state.idStack.indexOf(itemId);
if(itemIndex === -1){
return;}

this.props.onItemRef && this.props.onItemRef(ref,itemIndex,route);},


_cleanScenesPastIndex:function(index){var _this11=this;
var newStackLength=index + 1;

if(newStackLength < this.state.routeStack.length){
var updatingRangeStart=newStackLength;
var updatingRangeLength=this.state.routeStack.length - newStackLength + 1;
this.state.idStack.slice(newStackLength).map(function(removingId){
_this11._itemRefs[removingId] = null;});

this.setState({
updatingRangeStart:updatingRangeStart,
updatingRangeLength:updatingRangeLength,
sceneConfigStack:this.state.sceneConfigStack.slice(0,newStackLength),
idStack:this.state.idStack.slice(0,newStackLength),
routeStack:this.state.routeStack.slice(0,newStackLength)},
this._resetUpdatingRange);}},



_renderOptimizedScenes:function(){







var shouldRenderScenes=this.state.updatingRangeLength !== 0;
if(shouldRenderScenes){
return (
React.createElement(StaticContainer,{shouldUpdate:true},
React.createElement(View,_extends({
style:styles.transitioner},
this.panGesture.panHandlers,{
onTouchStart:this._handleTouchStart,
onResponderTerminationRequest:
this._handleResponderTerminationRequest}),

this.state.routeStack.map(this._renderOptimizedScene))));}









return (
React.createElement(StaticContainer,{shouldUpdate:false}));},



_renderOptimizedScene:function(route,i){
var shouldRenderScene=
i >= this.state.updatingRangeStart && 
i <= this.state.updatingRangeStart + this.state.updatingRangeLength;
var scene=shouldRenderScene?this._renderScene(route,i):null;
return (
React.createElement(StaticContainer,{
key:'nav' + i,
shouldUpdate:shouldRenderScene},
scene));},




_renderScene:function(route,i){var _this12=this;
var child=this.props.renderScene(
route,
this);

var disabledSceneStyle=null;
if(i !== this.state.presentedIndex){
disabledSceneStyle = styles.disabledScene;}

var originalRef=child.ref;
if(originalRef != null && typeof originalRef !== 'function'){
console.warn(
'String refs are not supported for navigator scenes. Use a callback ' + 
'ref instead. Ignoring ref: ' + originalRef);

originalRef = null;}

return (
React.createElement(View,{
key:this.state.idStack[i],
ref:'scene_' + i,
onStartShouldSetResponderCapture:function(){
return _this12.state.transitionFromIndex != null || _this12.state.transitionFromIndex != null;},

style:[styles.baseScene,this.props.sceneStyle,disabledSceneStyle]},
React.cloneElement(child,{
ref:function(component){
_this12._handleItemRef(_this12.state.idStack[i],route,component);
if(originalRef){
originalRef(component);}}})));},







_renderNavigationBar:function(){var _this13=this;
if(!this.props.navigationBar){
return null;}

return React.cloneElement(this.props.navigationBar,{
ref:function(navBar){_this13._navBar = navBar;},
navigator:this,
navState:this.state});},



render:function(){
return (
React.createElement(View,{style:[styles.container,this.props.style]},
this._renderOptimizedScenes(),
this._renderNavigationBar()));},




_getNavigationContext:function(){
if(!this._navigationContext){
this._navigationContext = new NavigationContext();}

return this._navigationContext;}});



module.exports = Navigator;
});
__d('InteractionMixin',["InteractionManager"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';







var InteractionManager=require('InteractionManager');






var InteractionMixin={
componentWillUnmount:function(){
while(this._interactionMixinHandles.length) {
InteractionManager.clearInteractionHandle(
this._interactionMixinHandles.pop());}},




_interactionMixinHandles:[],

createInteractionHandle:function(){
var handle=InteractionManager.createInteractionHandle();
this._interactionMixinHandles.push(handle);
return handle;},


clearInteractionHandle:function(clearHandle){
InteractionManager.clearInteractionHandle(clearHandle);
this._interactionMixinHandles = this._interactionMixinHandles.filter(
function(handle){return handle !== clearHandle;});},








runAfterInteractions:function(callback){
InteractionManager.runAfterInteractions(callback);}};



module.exports = InteractionMixin;
});
__d('NavigationContext',["NavigationEvent","EventSubscription","NavigationEventEmitter","emptyFunction","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  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');}}

























'use strict';

var NavigationEventEmitter=require('NavigationEventEmitter');

var emptyFunction=require('emptyFunction');
var invariant=require('invariant');var 







NavigationContext=(function(){



function NavigationContext(){_classCallCheck(this,NavigationContext);
this._eventEmitter = new NavigationEventEmitter(this);
this._currentRoute = null;
this.addListener('willfocus',this._onFocus,this);
this.addListener('didfocus',this._onFocus,this);}_createClass(NavigationContext,[{key:'addListener',value:








function addListener(
eventType,
listener,
context)
{
var emitter=this._eventEmitter;
if(emitter){
return emitter.addListener(eventType,listener,context);}else 
{
return {remove:emptyFunction};}}},{key:'emit',value:



function emit(eventType,data){
var emitter=this._eventEmitter;
if(emitter){
emitter.emit(eventType,data);}}},{key:'dispose',value:



function dispose(){
var emitter=this._eventEmitter;
if(emitter){

emitter.removeAllListeners();
this._eventEmitter = null;
this._currentRoute = null;}}},{key:'_onFocus',value:



function _onFocus(event){
invariant(
event.data && event.data.hasOwnProperty('route'),
'didfocus event should provide route');

this._currentRoute = event.data.route;}},{key:'currentRoute',get:function(){return this._currentRoute;}}]);return NavigationContext;})();



module.exports = NavigationContext;
});
__d('NavigationEvent',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}var 







NavigationEvent=




function NavigationEvent(type,target,data){_classCallCheck(this,NavigationEvent);
this.type = type;
this.target = target;
this.data = data;};



module.exports = NavigationEvent;
});
__d('NavigationEventEmitter',["EventEmitter","NavigationEvent"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}




























var EventEmitter=require('EventEmitter');
var NavigationEvent=require('NavigationEvent');var 






NavigationEventEmitter=(function(_EventEmitter){_inherits(NavigationEventEmitter,_EventEmitter);




function NavigationEventEmitter(target){_classCallCheck(this,NavigationEventEmitter);
_get(Object.getPrototypeOf(NavigationEventEmitter.prototype),'constructor',this).call(this);
this._emitting = false;
this._emitQueue = [];
this._target = target;}_createClass(NavigationEventEmitter,[{key:'emit',value:


function emit(eventType,data){
if(this._emitting){


this._emitQueue.push({eventType:eventType,data:data});
return;}


this._emitting = true;
var event=new NavigationEvent(eventType,this._target,data);
_get(Object.getPrototypeOf(NavigationEventEmitter.prototype),'emit',this).call(this,eventType,event);
this._emitting = false;

while(this._emitQueue.length) {
var arg=this._emitQueue.shift();
this.emit(arg.eventType,arg.data);}}}]);return NavigationEventEmitter;})(EventEmitter);




module.exports = NavigationEventEmitter;
});
__d('NavigatorBreadcrumbNavigationBar',["NavigatorBreadcrumbNavigationBarStyles","NavigatorNavigationBarStyles","React","StaticContainer.react","StyleSheet","View","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



























var NavigatorBreadcrumbNavigationBarStyles=require('NavigatorBreadcrumbNavigationBarStyles');
var NavigatorNavigationBarStyles=require('NavigatorNavigationBarStyles');
var React=require('React');
var StaticContainer=require('StaticContainer.react');
var StyleSheet=require('StyleSheet');
var View=require('View');

var invariant=require('invariant');

var Interpolators=NavigatorBreadcrumbNavigationBarStyles.Interpolators;
var PropTypes=React.PropTypes;




var CRUMB_PROPS=Interpolators.map(function(){return {style:{}};});
var ICON_PROPS=Interpolators.map(function(){return {style:{}};});
var SEPARATOR_PROPS=Interpolators.map(function(){return {style:{}};});
var TITLE_PROPS=Interpolators.map(function(){return {style:{}};});
var RIGHT_BUTTON_PROPS=Interpolators.map(function(){return {style:{}};});


var navStatePresentedIndex=function(navState){
if(navState.presentedIndex !== undefined){
return navState.presentedIndex;}


return navState.observedTopOfStack;};










var initStyle=function(index,presentedIndex){
return index === presentedIndex?NavigatorBreadcrumbNavigationBarStyles.Center[index]:
index < presentedIndex?NavigatorBreadcrumbNavigationBarStyles.Left[index]:
NavigatorBreadcrumbNavigationBarStyles.Right[index];};


var NavigatorBreadcrumbNavigationBar=React.createClass({displayName:'NavigatorBreadcrumbNavigationBar',
propTypes:{
navigator:PropTypes.shape({
push:PropTypes.func,
pop:PropTypes.func,
replace:PropTypes.func,
popToRoute:PropTypes.func,
popToTop:PropTypes.func}),

routeMapper:PropTypes.shape({
rightContentForRoute:PropTypes.func,
titleContentForRoute:PropTypes.func,
iconForRoute:PropTypes.func}),

navState:React.PropTypes.shape({
routeStack:React.PropTypes.arrayOf(React.PropTypes.object),
idStack:React.PropTypes.arrayOf(React.PropTypes.number),
presentedIndex:React.PropTypes.number}),

style:View.propTypes.style},


statics:{
Styles:NavigatorBreadcrumbNavigationBarStyles},


_updateIndexProgress:function(progress,index,fromIndex,toIndex){
var amount=toIndex > fromIndex?progress:1 - progress;
var oldDistToCenter=index - fromIndex;
var newDistToCenter=index - toIndex;
var interpolate;
invariant(
Interpolators[index],
'Cannot find breadcrumb interpolators for ' + index);

if(oldDistToCenter > 0 && newDistToCenter === 0 || 
newDistToCenter > 0 && oldDistToCenter === 0){
interpolate = Interpolators[index].RightToCenter;}else 
if(oldDistToCenter < 0 && newDistToCenter === 0 || 
newDistToCenter < 0 && oldDistToCenter === 0){
interpolate = Interpolators[index].CenterToLeft;}else 
if(oldDistToCenter === newDistToCenter){
interpolate = Interpolators[index].RightToCenter;}else 
{
interpolate = Interpolators[index].RightToLeft;}


if(interpolate.Crumb(CRUMB_PROPS[index].style,amount)){
this.refs['crumb_' + index].setNativeProps(CRUMB_PROPS[index]);}

if(interpolate.Icon(ICON_PROPS[index].style,amount)){
this.refs['icon_' + index].setNativeProps(ICON_PROPS[index]);}

if(interpolate.Separator(SEPARATOR_PROPS[index].style,amount)){
this.refs['separator_' + index].setNativeProps(SEPARATOR_PROPS[index]);}

if(interpolate.Title(TITLE_PROPS[index].style,amount)){
this.refs['title_' + index].setNativeProps(TITLE_PROPS[index]);}

var right=this.refs['right_' + index];
if(right && 
interpolate.RightItem(RIGHT_BUTTON_PROPS[index].style,amount)){
right.setNativeProps(RIGHT_BUTTON_PROPS[index]);}},



updateProgress:function(progress,fromIndex,toIndex){
var max=Math.max(fromIndex,toIndex);
var min=Math.min(fromIndex,toIndex);
for(var index=min;index <= max;index++) {
this._updateIndexProgress(progress,index,fromIndex,toIndex);}},



onAnimationStart:function(fromIndex,toIndex){
var max=Math.max(fromIndex,toIndex);
var min=Math.min(fromIndex,toIndex);
for(var index=min;index <= max;index++) {
this._setRenderViewsToHardwareTextureAndroid(index,true);}},



onAnimationEnd:function(){
var max=this.props.navState.routeStack.length - 1;
for(var index=0;index <= max;index++) {
this._setRenderViewsToHardwareTextureAndroid(index,false);}},



_setRenderViewsToHardwareTextureAndroid:function(index,renderToHardwareTexture){
var props={
renderToHardwareTextureAndroid:renderToHardwareTexture};


this.refs['icon_' + index].setNativeProps(props);
this.refs['separator_' + index].setNativeProps(props);
this.refs['title_' + index].setNativeProps(props);
var right=this.refs['right_' + index];
if(right){
right.setNativeProps(props);}},



render:function(){
var navState=this.props.navState;
var icons=navState && navState.routeStack.map(this._renderOrReturnBreadcrumb);
var titles=navState.routeStack.map(this._renderOrReturnTitle);
var buttons=navState.routeStack.map(this._renderOrReturnRightButton);
return (
React.createElement(View,{style:[styles.breadCrumbContainer,this.props.style]},
titles,
icons,
buttons));},




_renderOrReturnBreadcrumb:function(route,index){
var uid=this.props.navState.idStack[index];
var navBarRouteMapper=this.props.routeMapper;
var navOps=this.props.navigator;
var alreadyRendered=this.refs['crumbContainer' + uid];
if(alreadyRendered){

return (
React.createElement(StaticContainer,{
ref:'crumbContainer' + uid,
key:'crumbContainer' + uid,
shouldUpdate:false}));}



var firstStyles=initStyle(index,navStatePresentedIndex(this.props.navState));
return (
React.createElement(StaticContainer,{
ref:'crumbContainer' + uid,
key:'crumbContainer' + uid,
shouldUpdate:false},
React.createElement(View,{ref:'crumb_' + index,style:firstStyles.Crumb},
React.createElement(View,{ref:'icon_' + index,style:firstStyles.Icon},
navBarRouteMapper.iconForRoute(route,navOps)),

React.createElement(View,{ref:'separator_' + index,style:firstStyles.Separator},
navBarRouteMapper.separatorForRoute(route,navOps)))));},






_renderOrReturnTitle:function(route,index){
var navState=this.props.navState;
var uid=navState.idStack[index];
var alreadyRendered=this.refs['titleContainer' + uid];
if(alreadyRendered){

return (
React.createElement(StaticContainer,{
ref:'titleContainer' + uid,
key:'titleContainer' + uid,
shouldUpdate:false}));}



var navBarRouteMapper=this.props.routeMapper;
var titleContent=navBarRouteMapper.titleContentForRoute(
navState.routeStack[index],
this.props.navigator);

var firstStyles=initStyle(index,navStatePresentedIndex(this.props.navState));
return (
React.createElement(StaticContainer,{
ref:'titleContainer' + uid,
key:'titleContainer' + uid,
shouldUpdate:false},
React.createElement(View,{ref:'title_' + index,style:firstStyles.Title},
titleContent)));},





_renderOrReturnRightButton:function(route,index){
var navState=this.props.navState;
var navBarRouteMapper=this.props.routeMapper;
var uid=navState.idStack[index];
var alreadyRendered=this.refs['rightContainer' + uid];
if(alreadyRendered){

return (
React.createElement(StaticContainer,{
ref:'rightContainer' + uid,
key:'rightContainer' + uid,
shouldUpdate:false}));}



var rightContent=navBarRouteMapper.rightContentForRoute(
navState.routeStack[index],
this.props.navigator);

if(!rightContent){
return null;}

var firstStyles=initStyle(index,navStatePresentedIndex(this.props.navState));
return (
React.createElement(StaticContainer,{
ref:'rightContainer' + uid,
key:'rightContainer' + uid,
shouldUpdate:false},
React.createElement(View,{ref:'right_' + index,style:firstStyles.RightItem},
rightContent)));}});






var styles=StyleSheet.create({
breadCrumbContainer:{
overflow:'hidden',
position:'absolute',
height:NavigatorNavigationBarStyles.General.TotalNavHeight,
top:0,
left:0,
right:0}});



module.exports = NavigatorBreadcrumbNavigationBar;
});
__d('NavigatorBreadcrumbNavigationBarStyles',["Dimensions","NavigatorNavigationBarStyles","buildStyleInterpolator","merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



























var Dimensions=require('Dimensions');
var NavigatorNavigationBarStyles=require('NavigatorNavigationBarStyles');

var buildStyleInterpolator=require('buildStyleInterpolator');
var merge=require('merge');

var SCREEN_WIDTH=Dimensions.get('window').width;
var STATUS_BAR_HEIGHT=NavigatorNavigationBarStyles.General.StatusBarHeight;
var NAV_BAR_HEIGHT=NavigatorNavigationBarStyles.General.NavBarHeight;

var SPACING=4;
var ICON_WIDTH=40;
var SEPARATOR_WIDTH=9;
var CRUMB_WIDTH=ICON_WIDTH + SEPARATOR_WIDTH;

var OPACITY_RATIO=100;
var ICON_INACTIVE_OPACITY=0.6;
var MAX_BREADCRUMBS=10;

var CRUMB_BASE={
position:'absolute',
flexDirection:'row',
top:STATUS_BAR_HEIGHT,
width:CRUMB_WIDTH,
height:NAV_BAR_HEIGHT,
backgroundColor:'transparent'};


var ICON_BASE={
width:ICON_WIDTH,
height:NAV_BAR_HEIGHT};


var SEPARATOR_BASE={
width:SEPARATOR_WIDTH,
height:NAV_BAR_HEIGHT};


var TITLE_BASE={
position:'absolute',
top:STATUS_BAR_HEIGHT,
height:NAV_BAR_HEIGHT,
backgroundColor:'transparent'};



var FIRST_TITLE_BASE=merge(TITLE_BASE,{
left:0,
right:0,
alignItems:'center',
height:NAV_BAR_HEIGHT});


var RIGHT_BUTTON_BASE={
position:'absolute',
top:STATUS_BAR_HEIGHT,
right:SPACING,
overflow:'hidden',
opacity:1,
height:NAV_BAR_HEIGHT,
backgroundColor:'transparent'};






var LEFT=[];
var CENTER=[];
var RIGHT=[];
for(var i=0;i < MAX_BREADCRUMBS;i++) {
var crumbLeft=CRUMB_WIDTH * i + SPACING;
LEFT[i] = {
Crumb:merge(CRUMB_BASE,{left:crumbLeft}),
Icon:merge(ICON_BASE,{opacity:ICON_INACTIVE_OPACITY}),
Separator:merge(SEPARATOR_BASE,{opacity:1}),
Title:merge(TITLE_BASE,{left:crumbLeft,opacity:0}),
RightItem:merge(RIGHT_BUTTON_BASE,{opacity:0})};

CENTER[i] = {
Crumb:merge(CRUMB_BASE,{left:crumbLeft}),
Icon:merge(ICON_BASE,{opacity:1}),
Separator:merge(SEPARATOR_BASE,{opacity:0}),
Title:merge(TITLE_BASE,{
left:crumbLeft + ICON_WIDTH,
opacity:1}),

RightItem:merge(RIGHT_BUTTON_BASE,{opacity:1})};

var crumbRight=SCREEN_WIDTH - 100;
RIGHT[i] = {
Crumb:merge(CRUMB_BASE,{left:crumbRight}),
Icon:merge(ICON_BASE,{opacity:0}),
Separator:merge(SEPARATOR_BASE,{opacity:0}),
Title:merge(TITLE_BASE,{
left:crumbRight + ICON_WIDTH,
opacity:0}),

RightItem:merge(RIGHT_BUTTON_BASE,{opacity:0})};}




CENTER[0] = {
Crumb:merge(CRUMB_BASE,{left:SCREEN_WIDTH / 4}),
Icon:merge(ICON_BASE,{opacity:0}),
Separator:merge(SEPARATOR_BASE,{opacity:0}),
Title:merge(FIRST_TITLE_BASE,{opacity:1}),
RightItem:CENTER[0].RightItem};

LEFT[0].Title = merge(FIRST_TITLE_BASE,{left:-SCREEN_WIDTH / 4,opacity:0});
RIGHT[0].Title = merge(FIRST_TITLE_BASE,{opacity:0});


var buildIndexSceneInterpolator=function(startStyles,endStyles){
return {
Crumb:buildStyleInterpolator({
left:{
type:'linear',
from:startStyles.Crumb.left,
to:endStyles.Crumb.left,
min:0,
max:1,
extrapolate:true}}),


Icon:buildStyleInterpolator({
opacity:{
type:'linear',
from:startStyles.Icon.opacity,
to:endStyles.Icon.opacity,
min:0,
max:1}}),


Separator:buildStyleInterpolator({
opacity:{
type:'linear',
from:startStyles.Separator.opacity,
to:endStyles.Separator.opacity,
min:0,
max:1}}),


Title:buildStyleInterpolator({
opacity:{
type:'linear',
from:startStyles.Title.opacity,
to:endStyles.Title.opacity,
min:0,
max:1},

left:{
type:'linear',
from:startStyles.Title.left,
to:endStyles.Title.left,
min:0,
max:1,
extrapolate:true}}),


RightItem:buildStyleInterpolator({
opacity:{
type:'linear',
from:startStyles.RightItem.opacity,
to:endStyles.RightItem.opacity,
min:0,
max:1,
round:OPACITY_RATIO}})};};





var Interpolators=CENTER.map(function(_,ii){
return {

RightToCenter:buildIndexSceneInterpolator(RIGHT[ii],CENTER[ii]),

CenterToLeft:buildIndexSceneInterpolator(CENTER[ii],LEFT[ii]),

RightToLeft:buildIndexSceneInterpolator(RIGHT[ii],LEFT[ii])};});







module.exports = {
Interpolators:Interpolators,
Left:LEFT,
Center:CENTER,
Right:RIGHT,
IconWidth:ICON_WIDTH,
IconHeight:NAV_BAR_HEIGHT,
SeparatorWidth:SEPARATOR_WIDTH,
SeparatorHeight:NAV_BAR_HEIGHT};
});
__d('NavigatorNavigationBarStyles',["Dimensions","buildStyleInterpolator","merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



























var Dimensions=require('Dimensions');

var buildStyleInterpolator=require('buildStyleInterpolator');
var merge=require('merge');

var SCREEN_WIDTH=Dimensions.get('window').width;
var NAV_BAR_HEIGHT=44;
var STATUS_BAR_HEIGHT=20;
var NAV_HEIGHT=NAV_BAR_HEIGHT + STATUS_BAR_HEIGHT;

var BASE_STYLES={
Title:{
position:'absolute',
top:STATUS_BAR_HEIGHT,
left:0,
alignItems:'center',
width:SCREEN_WIDTH,
height:NAV_BAR_HEIGHT,
backgroundColor:'transparent'},

LeftButton:{
position:'absolute',
top:STATUS_BAR_HEIGHT,
left:0,
overflow:'hidden',
opacity:1,
width:SCREEN_WIDTH / 3,
height:NAV_BAR_HEIGHT,
backgroundColor:'transparent'},

RightButton:{
position:'absolute',
top:STATUS_BAR_HEIGHT,
left:2 * SCREEN_WIDTH / 3,
overflow:'hidden',
opacity:1,
alignItems:'flex-end',
width:SCREEN_WIDTH / 3,
height:NAV_BAR_HEIGHT,
backgroundColor:'transparent'}};










var Stages={
Left:{
Title:merge(BASE_STYLES.Title,{left:-SCREEN_WIDTH / 2,opacity:0}),
LeftButton:merge(BASE_STYLES.LeftButton,{left:-SCREEN_WIDTH / 3,opacity:1}),
RightButton:merge(BASE_STYLES.RightButton,{left:SCREEN_WIDTH / 3,opacity:0})},

Center:{
Title:merge(BASE_STYLES.Title,{left:0,opacity:1}),
LeftButton:merge(BASE_STYLES.LeftButton,{left:0,opacity:1}),
RightButton:merge(BASE_STYLES.RightButton,{left:2 * SCREEN_WIDTH / 3 - 0,opacity:1})},

Right:{
Title:merge(BASE_STYLES.Title,{left:SCREEN_WIDTH / 2,opacity:0}),
LeftButton:merge(BASE_STYLES.LeftButton,{left:0,opacity:0}),
RightButton:merge(BASE_STYLES.RightButton,{left:SCREEN_WIDTH,opacity:0})}};




var opacityRatio=100;

function buildSceneInterpolators(startStyles,endStyles){
return {
Title:buildStyleInterpolator({
opacity:{
type:'linear',
from:startStyles.Title.opacity,
to:endStyles.Title.opacity,
min:0,
max:1},

left:{
type:'linear',
from:startStyles.Title.left,
to:endStyles.Title.left,
min:0,
max:1,
extrapolate:true}}),


LeftButton:buildStyleInterpolator({
opacity:{
type:'linear',
from:startStyles.LeftButton.opacity,
to:endStyles.LeftButton.opacity,
min:0,
max:1,
round:opacityRatio},

left:{
type:'linear',
from:startStyles.LeftButton.left,
to:endStyles.LeftButton.left,
min:0,
max:1}}),


RightButton:buildStyleInterpolator({
opacity:{
type:'linear',
from:startStyles.RightButton.opacity,
to:endStyles.RightButton.opacity,
min:0,
max:1,
round:opacityRatio},

left:{
type:'linear',
from:startStyles.RightButton.left,
to:endStyles.RightButton.left,
min:0,
max:1,
extrapolate:true}})};}





var Interpolators={

RightToCenter:buildSceneInterpolators(Stages.Right,Stages.Center),

CenterToLeft:buildSceneInterpolators(Stages.Center,Stages.Left),

RightToLeft:buildSceneInterpolators(Stages.Right,Stages.Left)};



module.exports = {
General:{
NavBarHeight:NAV_BAR_HEIGHT,
StatusBarHeight:STATUS_BAR_HEIGHT,
TotalNavHeight:NAV_HEIGHT},

Interpolators:Interpolators,
Stages:Stages};
});
__d('buildStyleInterpolator',["keyOf"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 










keyOf=require('keyOf');

var X_DIM=keyOf({x:null});
var Y_DIM=keyOf({y:null});
var Z_DIM=keyOf({z:null});
var W_DIM=keyOf({w:null});

var TRANSFORM_ROTATE_NAME=keyOf({transformRotateRadians:null});

var ShouldAllocateReusableOperationVars={
transformRotateRadians:true,
transformScale:true,
transformTranslate:true};


var InitialOperationField={
transformRotateRadians:[0,0,0,1],
transformTranslate:[0,0,0],
transformScale:[1,1,1]};



























































var ARGUMENT_NAMES_RE=/([^\s,]+)/g;



















var inline=function(func,replaceWithArgs){
var fnStr=func.toString();
var parameterNames=fnStr.slice(fnStr.indexOf('(') + 1,fnStr.indexOf(')')).
match(ARGUMENT_NAMES_RE) || 
[];
var replaceRegexStr=parameterNames.map(function(paramName){
return '\\b' + paramName + '\\b';}).
join('|');
var replaceRegex=new RegExp(replaceRegexStr,'g');
var fnBody=fnStr.substring(fnStr.indexOf('{') + 1,fnStr.lastIndexOf('}'));
var newFnBody=fnBody.replace(replaceRegex,function(parameterName){
var indexInParameterNames=parameterNames.indexOf(parameterName);
var replacementName=replaceWithArgs[indexInParameterNames];
return replacementName;});

return newFnBody.split('\n');};






var MatrixOps={
unroll:function(matVar,m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15){
m0 = matVar[0];
m1 = matVar[1];
m2 = matVar[2];
m3 = matVar[3];
m4 = matVar[4];
m5 = matVar[5];
m6 = matVar[6];
m7 = matVar[7];
m8 = matVar[8];
m9 = matVar[9];
m10 = matVar[10];
m11 = matVar[11];
m12 = matVar[12];
m13 = matVar[13];
m14 = matVar[14];
m15 = matVar[15];},


matrixDiffers:function(retVar,matVar,m0,m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15){
retVar = retVar || 
m0 !== matVar[0] || 
m1 !== matVar[1] || 
m2 !== matVar[2] || 
m3 !== matVar[3] || 
m4 !== matVar[4] || 
m5 !== matVar[5] || 
m6 !== matVar[6] || 
m7 !== matVar[7] || 
m8 !== matVar[8] || 
m9 !== matVar[9] || 
m10 !== matVar[10] || 
m11 !== matVar[11] || 
m12 !== matVar[12] || 
m13 !== matVar[13] || 
m14 !== matVar[14] || 
m15 !== matVar[15];},


transformScale:function(matVar,opVar){

var x=opVar[0];
var y=opVar[1];
var z=opVar[2];
matVar[0] = matVar[0] * x;
matVar[1] = matVar[1] * x;
matVar[2] = matVar[2] * x;
matVar[3] = matVar[3] * x;
matVar[4] = matVar[4] * y;
matVar[5] = matVar[5] * y;
matVar[6] = matVar[6] * y;
matVar[7] = matVar[7] * y;
matVar[8] = matVar[8] * z;
matVar[9] = matVar[9] * z;
matVar[10] = matVar[10] * z;
matVar[11] = matVar[11] * z;
matVar[12] = matVar[12];
matVar[13] = matVar[13];
matVar[14] = matVar[14];
matVar[15] = matVar[15];},






transformTranslate:function(matVar,opVar){

var x=opVar[0];
var y=opVar[1];
var z=opVar[2];
matVar[12] = matVar[0] * x + matVar[4] * y + matVar[8] * z + matVar[12];
matVar[13] = matVar[1] * x + matVar[5] * y + matVar[9] * z + matVar[13];
matVar[14] = matVar[2] * x + matVar[6] * y + matVar[10] * z + matVar[14];
matVar[15] = matVar[3] * x + matVar[7] * y + matVar[11] * z + matVar[15];},






transformRotateRadians:function(matVar,q){

var xQuat=q[0],yQuat=q[1],zQuat=q[2],wQuat=q[3];
var x2Quat=xQuat + xQuat;
var y2Quat=yQuat + yQuat;
var z2Quat=zQuat + zQuat;
var xxQuat=xQuat * x2Quat;
var xyQuat=xQuat * y2Quat;
var xzQuat=xQuat * z2Quat;
var yyQuat=yQuat * y2Quat;
var yzQuat=yQuat * z2Quat;
var zzQuat=zQuat * z2Quat;
var wxQuat=wQuat * x2Quat;
var wyQuat=wQuat * y2Quat;
var wzQuat=wQuat * z2Quat;

var quatMat0=1 - (yyQuat + zzQuat);
var quatMat1=xyQuat + wzQuat;
var quatMat2=xzQuat - wyQuat;
var quatMat4=xyQuat - wzQuat;
var quatMat5=1 - (xxQuat + zzQuat);
var quatMat6=yzQuat + wxQuat;
var quatMat8=xzQuat + wyQuat;
var quatMat9=yzQuat - wxQuat;
var quatMat10=1 - (xxQuat + yyQuat);



var a00=matVar[0];
var a01=matVar[1];
var a02=matVar[2];
var a03=matVar[3];
var a10=matVar[4];
var a11=matVar[5];
var a12=matVar[6];
var a13=matVar[7];
var a20=matVar[8];
var a21=matVar[9];
var a22=matVar[10];
var a23=matVar[11];

var b0=quatMat0,b1=quatMat1,b2=quatMat2;
matVar[0] = b0 * a00 + b1 * a10 + b2 * a20;
matVar[1] = b0 * a01 + b1 * a11 + b2 * a21;
matVar[2] = b0 * a02 + b1 * a12 + b2 * a22;
matVar[3] = b0 * a03 + b1 * a13 + b2 * a23;
b0 = quatMat4;b1 = quatMat5;b2 = quatMat6;
matVar[4] = b0 * a00 + b1 * a10 + b2 * a20;
matVar[5] = b0 * a01 + b1 * a11 + b2 * a21;
matVar[6] = b0 * a02 + b1 * a12 + b2 * a22;
matVar[7] = b0 * a03 + b1 * a13 + b2 * a23;
b0 = quatMat8;b1 = quatMat9;b2 = quatMat10;
matVar[8] = b0 * a00 + b1 * a10 + b2 * a20;
matVar[9] = b0 * a01 + b1 * a11 + b2 * a21;
matVar[10] = b0 * a02 + b1 * a12 + b2 * a22;
matVar[11] = b0 * a03 + b1 * a13 + b2 * a23;}};





var MatrixOpsInitial={
transformScale:function(matVar,opVar){

matVar[0] = opVar[0];
matVar[1] = 0;
matVar[2] = 0;
matVar[3] = 0;
matVar[4] = 0;
matVar[5] = opVar[1];
matVar[6] = 0;
matVar[7] = 0;
matVar[8] = 0;
matVar[9] = 0;
matVar[10] = opVar[2];
matVar[11] = 0;
matVar[12] = 0;
matVar[13] = 0;
matVar[14] = 0;
matVar[15] = 1;},


transformTranslate:function(matVar,opVar){

matVar[0] = 1;
matVar[1] = 0;
matVar[2] = 0;
matVar[3] = 0;
matVar[4] = 0;
matVar[5] = 1;
matVar[6] = 0;
matVar[7] = 0;
matVar[8] = 0;
matVar[9] = 0;
matVar[10] = 1;
matVar[11] = 0;
matVar[12] = opVar[0];
matVar[13] = opVar[1];
matVar[14] = opVar[2];
matVar[15] = 1;},







transformRotateRadians:function(matVar,q){


var xQuat=q[0],yQuat=q[1],zQuat=q[2],wQuat=q[3];
var x2Quat=xQuat + xQuat;
var y2Quat=yQuat + yQuat;
var z2Quat=zQuat + zQuat;
var xxQuat=xQuat * x2Quat;
var xyQuat=xQuat * y2Quat;
var xzQuat=xQuat * z2Quat;
var yyQuat=yQuat * y2Quat;
var yzQuat=yQuat * z2Quat;
var zzQuat=zQuat * z2Quat;
var wxQuat=wQuat * x2Quat;
var wyQuat=wQuat * y2Quat;
var wzQuat=wQuat * z2Quat;

var quatMat0=1 - (yyQuat + zzQuat);
var quatMat1=xyQuat + wzQuat;
var quatMat2=xzQuat - wyQuat;
var quatMat4=xyQuat - wzQuat;
var quatMat5=1 - (xxQuat + zzQuat);
var quatMat6=yzQuat + wxQuat;
var quatMat8=xzQuat + wyQuat;
var quatMat9=yzQuat - wxQuat;
var quatMat10=1 - (xxQuat + yyQuat);



var b0=quatMat0,b1=quatMat1,b2=quatMat2;
matVar[0] = b0;
matVar[1] = b1;
matVar[2] = b2;
matVar[3] = 0;
b0 = quatMat4;b1 = quatMat5;b2 = quatMat6;
matVar[4] = b0;
matVar[5] = b1;
matVar[6] = b2;
matVar[7] = 0;
b0 = quatMat8;b1 = quatMat9;b2 = quatMat10;
matVar[8] = b0;
matVar[9] = b1;
matVar[10] = b2;
matVar[11] = 0;
matVar[12] = 0;
matVar[13] = 0;
matVar[14] = 0;
matVar[15] = 1;}};




var setNextValAndDetectChange=function(name,tmpVarName){
return (
'  if (!didChange) {\n' + 
'    var prevVal = result.' + name + ';\n' + 
'    result.' + name + ' = ' + tmpVarName + ';\n' + 
'    didChange = didChange  || (' + tmpVarName + ' !== prevVal);\n' + 
'  } else {\n' + 
'    result.' + name + ' = ' + tmpVarName + ';\n' + 
'  }\n');};



var computeNextValLinear=function(anim,from,to,tmpVarName){
var hasRoundRatio=('round' in anim);
var roundRatio=anim.round;
var fn='  ratio = (value - ' + anim.min + ') / ' + (anim.max - anim.min) + ';\n';
if(!anim.extrapolate){
fn += '  ratio = ratio > 1 ? 1 : (ratio < 0 ? 0 : ratio);\n';}


var roundOpen=hasRoundRatio?'Math.round(' + roundRatio + ' * ':'';
var roundClose=hasRoundRatio?') / ' + roundRatio:'';
fn += 
'  ' + tmpVarName + ' = ' + 
roundOpen + 
'(' + from + ' * (1 - ratio) + ' + to + ' * ratio)' + 
roundClose + ';\n';
return fn;};


var computeNextValLinearScalar=function(anim){
return computeNextValLinear(anim,anim.from,anim.to,'nextScalarVal');};


var computeNextValConstant=function(anim){
var constantExpression=JSON.stringify(anim.value);
return '  nextScalarVal = ' + constantExpression + ';\n';};


var computeNextValStep=function(anim){
return (
'  nextScalarVal = value >= ' + (
anim.threshold + ' ? ' + anim.to + ' : ' + anim.from) + ';\n');};



var computeNextValIdentity=function(anim){
return '  nextScalarVal = value;\n';};


var operationVar=function(name){
return name + 'ReuseOp';};


var createReusableOperationVars=function(anims){
var ret='';
for(var name in anims) {
if(ShouldAllocateReusableOperationVars[name]){
ret += 'var ' + operationVar(name) + ' = [];\n';}}


return ret;};


var newlines=function(statements){
return '\n' + statements.join('\n') + '\n';};








var computeNextMatrixOperationField=function(anim,name,dimension,index){
var fieldAccess=operationVar(name) + '[' + index + ']';
if(anim.from[dimension] !== undefined && anim.to[dimension] !== undefined){
return '  ' + anim.from[dimension] !== anim.to[dimension]?
computeNextValLinear(anim,anim.from[dimension],anim.to[dimension],fieldAccess):
fieldAccess + ' = ' + anim.from[dimension] + ';';}else 
{
return '  ' + fieldAccess + ' = ' + InitialOperationField[name][index] + ';';}};



var unrolledVars=[];
for(var varIndex=0;varIndex < 16;varIndex++) {
unrolledVars.push('m' + varIndex);}

var setNextMatrixAndDetectChange=function(orderedMatrixOperations){
var fn=[
'  var transformMatrix = result.transformMatrix !== undefined ? ' + 
'result.transformMatrix : (result.transformMatrix = []);'];

fn.push.apply(
fn,
inline(MatrixOps.unroll,['transformMatrix'].concat(unrolledVars)));

for(var i=0;i < orderedMatrixOperations.length;i++) {
var opName=orderedMatrixOperations[i];
if(i === 0){
fn.push.apply(
fn,
inline(MatrixOpsInitial[opName],['transformMatrix',operationVar(opName)]));}else 

{
fn.push.apply(
fn,
inline(MatrixOps[opName],['transformMatrix',operationVar(opName)]));}}



fn.push.apply(
fn,
inline(MatrixOps.matrixDiffers,['didChange','transformMatrix'].concat(unrolledVars)));

return fn;};


var InterpolateMatrix={
transformTranslate:true,
transformRotateRadians:true,
transformScale:true};


var createFunctionString=function(anims){


var orderedMatrixOperations=[];



var fn='return (function() {\n';
fn += createReusableOperationVars(anims);
fn += 'return function(result, value) {\n';
fn += '  var didChange = false;\n';
fn += '  var nextScalarVal;\n';
fn += '  var ratio;\n';

for(var name in anims) {
var anim=anims[name];
if(anim.type === 'linear'){
if(InterpolateMatrix[name]){
orderedMatrixOperations.push(name);
var setOperations=[
computeNextMatrixOperationField(anim,name,X_DIM,0),
computeNextMatrixOperationField(anim,name,Y_DIM,1),
computeNextMatrixOperationField(anim,name,Z_DIM,2)];

if(name === TRANSFORM_ROTATE_NAME){
setOperations.push(computeNextMatrixOperationField(anim,name,W_DIM,3));}

fn += newlines(setOperations);}else 
{
fn += computeNextValLinearScalar(anim,'nextScalarVal');
fn += setNextValAndDetectChange(name,'nextScalarVal');}}else 

if(anim.type === 'constant'){
fn += computeNextValConstant(anim);
fn += setNextValAndDetectChange(name,'nextScalarVal');}else 
if(anim.type === 'step'){
fn += computeNextValStep(anim);
fn += setNextValAndDetectChange(name,'nextScalarVal');}else 
if(anim.type === 'identity'){
fn += computeNextValIdentity(anim);
fn += setNextValAndDetectChange(name,'nextScalarVal');}}


if(orderedMatrixOperations.length){
fn += newlines(setNextMatrixAndDetectChange(orderedMatrixOperations));}

fn += '  return didChange;\n';
fn += '};\n';
fn += '})()';
return fn;};







var buildStyleInterpolator=function(anims){
return Function(createFunctionString(anims))();};



module.exports = buildStyleInterpolator;
});
__d('StaticContainer.react',["React","onlyChild"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 

















React=require('React');

var onlyChild=require('onlyChild');
















var StaticContainer=React.createClass({displayName:'StaticContainer',

shouldComponentUpdate:function(nextProps){
return nextProps.shouldUpdate;},


render:function(){
return onlyChild(this.props.children);}});




module.exports = StaticContainer;
});
__d('NavigatorNavigationBar',["React","NavigatorNavigationBarStyles","StaticContainer.react","StyleSheet","View"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



























var React=require('React');
var NavigatorNavigationBarStyles=require('NavigatorNavigationBarStyles');
var StaticContainer=require('StaticContainer.react');
var StyleSheet=require('StyleSheet');
var View=require('View');

var COMPONENT_NAMES=['Title','LeftButton','RightButton'];

var navStatePresentedIndex=function(navState){
if(navState.presentedIndex !== undefined){
return navState.presentedIndex;}


return navState.observedTopOfStack;};


var NavigatorNavigationBar=React.createClass({displayName:'NavigatorNavigationBar',

propTypes:{
navigator:React.PropTypes.object,
routeMapper:React.PropTypes.shape({
Title:React.PropTypes.func.isRequired,
LeftButton:React.PropTypes.func.isRequired,
RightButton:React.PropTypes.func.isRequired}),

navState:React.PropTypes.shape({
routeStack:React.PropTypes.arrayOf(React.PropTypes.object),
idStack:React.PropTypes.arrayOf(React.PropTypes.number),
presentedIndex:React.PropTypes.number}),

style:View.propTypes.style},


statics:{
Styles:NavigatorNavigationBarStyles},


_getReusableProps:function(
componentName,
index)
{
if(!this._reusableProps){
this._reusableProps = {};}

var propStack=this._reusableProps[componentName];
if(!propStack){
propStack = this._reusableProps[componentName] = [];}

var props=propStack[index];
if(!props){
props = propStack[index] = {style:{}};}

return props;},


_updateIndexProgress:function(
progress,
index,
fromIndex,
toIndex)
{
var amount=toIndex > fromIndex?progress:1 - progress;
var oldDistToCenter=index - fromIndex;
var newDistToCenter=index - toIndex;
var interpolate;
if(oldDistToCenter > 0 && newDistToCenter === 0 || 
newDistToCenter > 0 && oldDistToCenter === 0){
interpolate = NavigatorNavigationBarStyles.Interpolators.RightToCenter;}else 
if(oldDistToCenter < 0 && newDistToCenter === 0 || 
newDistToCenter < 0 && oldDistToCenter === 0){
interpolate = NavigatorNavigationBarStyles.Interpolators.CenterToLeft;}else 
if(oldDistToCenter === newDistToCenter){
interpolate = NavigatorNavigationBarStyles.Interpolators.RightToCenter;}else 
{
interpolate = NavigatorNavigationBarStyles.Interpolators.RightToLeft;}


COMPONENT_NAMES.forEach(function(componentName){
var component=this.refs[componentName + index];
var props=this._getReusableProps(componentName,index);
if(component && interpolate[componentName](props.style,amount)){
component.setNativeProps(props);}},

this);},


updateProgress:function(
progress,
fromIndex,
toIndex)
{
var max=Math.max(fromIndex,toIndex);
var min=Math.min(fromIndex,toIndex);
for(var index=min;index <= max;index++) {
this._updateIndexProgress(progress,index,fromIndex,toIndex);}},



render:function(){
var navState=this.props.navState;
var components=COMPONENT_NAMES.map(function(componentName){
return navState.routeStack.map(
this._renderOrReturnComponent.bind(this,componentName));},

this);

return (
React.createElement(View,{style:[styles.navBarContainer,this.props.style]},
components));},




_renderOrReturnComponent:function(
componentName,
route,
index)
{
var navState=this.props.navState;
var uid=navState.idStack[index];
var containerRef=componentName + 'Container' + uid;
var alreadyRendered=this.refs[containerRef];
if(alreadyRendered){

return (
React.createElement(StaticContainer,{
ref:containerRef,
key:containerRef,
shouldUpdate:false}));}




var content=this.props.routeMapper[componentName](
navState.routeStack[index],
this.props.navigator,
index,
this.props.navState);

if(!content){
return null;}


var initialStage=index === navStatePresentedIndex(this.props.navState)?
NavigatorNavigationBarStyles.Stages.Center:NavigatorNavigationBarStyles.Stages.Left;
return (
React.createElement(StaticContainer,{
ref:containerRef,
key:containerRef,
shouldUpdate:false},
React.createElement(View,{ref:componentName + index,style:initialStage[componentName]},
content)));}});








var styles=StyleSheet.create({
navBarContainer:{
position:'absolute',
height:NavigatorNavigationBarStyles.General.TotalNavHeight,
top:0,
left:0,
right:0,
backgroundColor:'transparent'}});



module.exports = NavigatorNavigationBar;
});
__d('NavigatorSceneConfigs',["Dimensions","PixelRatio","buildStyleInterpolator"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};



























var Dimensions=require('Dimensions');
var PixelRatio=require('PixelRatio');

var buildStyleInterpolator=require('buildStyleInterpolator');

var SCREEN_WIDTH=Dimensions.get('window').width;
var SCREEN_HEIGHT=Dimensions.get('window').height;

var FadeToTheLeft={


transformTranslate:{
from:{x:0,y:0,z:0},
to:{x:-Math.round(Dimensions.get('window').width * 0.3),y:0,z:0},
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},












transformScale:{
from:{x:1,y:1,z:1},
to:{x:0.95,y:0.95,z:1},
min:0,
max:1,
type:'linear',
extrapolate:true},

opacity:{
from:1,
to:0.3,
min:0,
max:1,
type:'linear',
extrapolate:false,
round:100},

translateX:{
from:0,
to:-Math.round(Dimensions.get('window').width * 0.3),
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},

scaleX:{
from:1,
to:0.95,
min:0,
max:1,
type:'linear',
extrapolate:true},

scaleY:{
from:1,
to:0.95,
min:0,
max:1,
type:'linear',
extrapolate:true}};



var FadeToTheRight=_extends({},
FadeToTheLeft,{
transformTranslate:{
from:{x:0,y:0,z:0},
to:{x:Math.round(SCREEN_WIDTH * 0.3),y:0,z:0}},

translateX:{
from:0,
to:Math.round(SCREEN_WIDTH * 0.3)}});



var FadeIn={
opacity:{
from:0,
to:1,
min:0.5,
max:1,
type:'linear',
extrapolate:false,
round:100}};



var FadeOut={
opacity:{
from:1,
to:0,
min:0,
max:0.5,
type:'linear',
extrapolate:false,
round:100}};



var ToTheLeft={
transformTranslate:{
from:{x:0,y:0,z:0},
to:{x:-Dimensions.get('window').width,y:0,z:0},
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},

opacity:{
value:1.0,
type:'constant'},


translateX:{
from:0,
to:-Dimensions.get('window').width,
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()}};



var FromTheRight={
opacity:{
value:1.0,
type:'constant'},


transformTranslate:{
from:{x:Dimensions.get('window').width,y:0,z:0},
to:{x:0,y:0,z:0},
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},


translateX:{
from:Dimensions.get('window').width,
to:0,
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},


scaleX:{
value:1,
type:'constant'},

scaleY:{
value:1,
type:'constant'}};



var FromTheLeft=_extends({},
FromTheRight,{
transformTranslate:{
from:{x:-SCREEN_WIDTH,y:0,z:0},
to:{x:0,y:0,z:0},
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},

translateX:{
from:-SCREEN_WIDTH,
to:0,
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()}});



var ToTheBack={


transformTranslate:{
from:{x:0,y:0,z:0},
to:{x:0,y:0,z:0},
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},

transformScale:{
from:{x:1,y:1,z:1},
to:{x:0.95,y:0.95,z:1},
min:0,
max:1,
type:'linear',
extrapolate:true},

opacity:{
from:1,
to:0.3,
min:0,
max:1,
type:'linear',
extrapolate:false,
round:100},

scaleX:{
from:1,
to:0.95,
min:0,
max:1,
type:'linear',
extrapolate:true},

scaleY:{
from:1,
to:0.95,
min:0,
max:1,
type:'linear',
extrapolate:true}};



var FromTheFront={
opacity:{
value:1.0,
type:'constant'},


transformTranslate:{
from:{x:0,y:Dimensions.get('window').height,z:0},
to:{x:0,y:0,z:0},
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},

translateY:{
from:Dimensions.get('window').height,
to:0,
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},

scaleX:{
value:1,
type:'constant'},

scaleY:{
value:1,
type:'constant'}};



var ToTheBackAndroid={
opacity:{
value:1,
type:'constant'}};



var FromTheFrontAndroid={
opacity:{
from:0,
to:1,
min:0.5,
max:1,
type:'linear',
extrapolate:false,
round:100},

transformTranslate:{
from:{x:0,y:100,z:0},
to:{x:0,y:0,z:0},
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()},

translateY:{
from:100,
to:0,
min:0,
max:1,
type:'linear',
extrapolate:true,
round:PixelRatio.get()}};



var BaseOverswipeConfig={
frictionConstant:1,
frictionByDistance:1.5};


var BaseLeftToRightGesture={


isDetachable:false,


gestureDetectMovement:2,


notMoving:0.3,


directionRatio:0.66,


snapVelocity:2,


edgeHitWidth:30,


stillCompletionRatio:3 / 5,

fullDistance:SCREEN_WIDTH,

direction:'left-to-right'};



var BaseRightToLeftGesture=_extends({},
BaseLeftToRightGesture,{
direction:'right-to-left'});


var BaseConfig={

gestures:{
pop:BaseLeftToRightGesture},



springFriction:26,
springTension:200,


defaultTransitionVelocity:1.5,


animationInterpolators:{
into:buildStyleInterpolator(FromTheRight),
out:buildStyleInterpolator(FadeToTheLeft)}};



var NavigatorSceneConfigs={
PushFromRight:_extends({},
BaseConfig),


FloatFromRight:_extends({},
BaseConfig),


FloatFromLeft:_extends({},
BaseConfig,{
animationInterpolators:{
into:buildStyleInterpolator(FromTheLeft),
out:buildStyleInterpolator(FadeToTheRight)}}),


FloatFromBottom:_extends({},
BaseConfig,{
gestures:{
pop:_extends({},
BaseLeftToRightGesture,{
edgeHitWidth:150,
direction:'top-to-bottom',
fullDistance:SCREEN_HEIGHT})},


animationInterpolators:{
into:buildStyleInterpolator(FromTheFront),
out:buildStyleInterpolator(ToTheBack)}}),


FloatFromBottomAndroid:_extends({},
BaseConfig,{
gestures:null,
defaultTransitionVelocity:3,
springFriction:20,
animationInterpolators:{
into:buildStyleInterpolator(FromTheFrontAndroid),
out:buildStyleInterpolator(ToTheBackAndroid)}}),


FadeAndroid:_extends({},
BaseConfig,{
gestures:null,
animationInterpolators:{
into:buildStyleInterpolator(FadeIn),
out:buildStyleInterpolator(FadeOut)}}),


HorizontalSwipeJump:_extends({},
BaseConfig,{
gestures:{
jumpBack:_extends({},
BaseLeftToRightGesture,{
overswipe:BaseOverswipeConfig,
edgeHitWidth:null,
isDetachable:true}),

jumpForward:_extends({},
BaseRightToLeftGesture,{
overswipe:BaseOverswipeConfig,
edgeHitWidth:null,
isDetachable:true})},


animationInterpolators:{
into:buildStyleInterpolator(FromTheRight),
out:buildStyleInterpolator(ToTheLeft)}})};




module.exports = NavigatorSceneConfigs;
});
__d('PanResponder',["TouchHistoryMath"],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";





var TouchHistoryMath=require("TouchHistoryMath");

var currentCentroidXOfTouchesChangedAfter=
TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;
var currentCentroidYOfTouchesChangedAfter=
TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;
var previousCentroidXOfTouchesChangedAfter=
TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;
var previousCentroidYOfTouchesChangedAfter=
TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;
var currentCentroidX=TouchHistoryMath.currentCentroidX;
var currentCentroidY=TouchHistoryMath.currentCentroidY;















































































var PanResponder={
































































_initializeGestureState:function(gestureState){
gestureState.moveX = 0;
gestureState.moveY = 0;
gestureState.x0 = 0;
gestureState.y0 = 0;
gestureState.dx = 0;
gestureState.dy = 0;
gestureState.vx = 0;
gestureState.vy = 0;
gestureState.numberActiveTouches = 0;

gestureState._accountsForMovesUpTo = 0;},


























_updateGestureStateOnMove:function(gestureState,touchHistory){
gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
gestureState.moveX = currentCentroidXOfTouchesChangedAfter(
touchHistory,
gestureState._accountsForMovesUpTo);

gestureState.moveY = currentCentroidYOfTouchesChangedAfter(
touchHistory,
gestureState._accountsForMovesUpTo);

var movedAfter=gestureState._accountsForMovesUpTo;
var prevX=previousCentroidXOfTouchesChangedAfter(touchHistory,movedAfter);
var x=currentCentroidXOfTouchesChangedAfter(touchHistory,movedAfter);
var prevY=previousCentroidYOfTouchesChangedAfter(touchHistory,movedAfter);
var y=currentCentroidYOfTouchesChangedAfter(touchHistory,movedAfter);
var nextDX=gestureState.dx + (x - prevX);
var nextDY=gestureState.dy + (y - prevY);


var dt=
touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
gestureState.vx = (nextDX - gestureState.dx) / dt;
gestureState.vy = (nextDY - gestureState.dy) / dt;

gestureState.dx = nextDX;
gestureState.dy = nextDY;
gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;},


































create:function(config){
var gestureState={

stateID:Math.random()};

PanResponder._initializeGestureState(gestureState);
var panHandlers={
onStartShouldSetResponder:function(e){
return config.onStartShouldSetPanResponder === undefined?false:
config.onStartShouldSetPanResponder(e,gestureState);},

onMoveShouldSetResponder:function(e){
return config.onMoveShouldSetPanResponder === undefined?false:
config.onMoveShouldSetPanResponder(e,gestureState);},

onStartShouldSetResponderCapture:function(e){


if(e.nativeEvent.touches.length === 1){
PanResponder._initializeGestureState(gestureState);}

gestureState.numberActiveTouches = e.touchHistory.numberActiveTouches;
return config.onStartShouldSetPanResponderCapture !== undefined?
config.onStartShouldSetPanResponderCapture(e,gestureState):false;},


onMoveShouldSetResponderCapture:function(e){
var touchHistory=e.touchHistory;



if(gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp){
return false;}

PanResponder._updateGestureStateOnMove(gestureState,touchHistory);
return config.onMoveShouldSetResponderCapture?
config.onMoveShouldSetPanResponderCapture(e,gestureState):false;},


onResponderGrant:function(e){
gestureState.x0 = currentCentroidX(e.touchHistory);
gestureState.y0 = currentCentroidY(e.touchHistory);
gestureState.dx = 0;
gestureState.dy = 0;
config.onPanResponderGrant && config.onPanResponderGrant(e,gestureState);

return config.onShouldBlockNativeResponder === undefined?true:
config.onShouldBlockNativeResponder();},


onResponderReject:function(e){
config.onPanResponderReject && config.onPanResponderReject(e,gestureState);},


onResponderRelease:function(e){
config.onPanResponderRelease && config.onPanResponderRelease(e,gestureState);
PanResponder._initializeGestureState(gestureState);},


onResponderStart:function(e){
var touchHistory=e.touchHistory;
gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
config.onPanResponderStart && config.onPanResponderStart(e,gestureState);},


onResponderMove:function(e){
var touchHistory=e.touchHistory;


if(gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp){
return;}



PanResponder._updateGestureStateOnMove(gestureState,touchHistory);
config.onPanResponderMove && config.onPanResponderMove(e,gestureState);},


onResponderEnd:function(e){
var touchHistory=e.touchHistory;
gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
config.onPanResponderEnd && config.onPanResponderEnd(e,gestureState);},


onResponderTerminate:function(e){
config.onPanResponderTerminate && 
config.onPanResponderTerminate(e,gestureState);
PanResponder._initializeGestureState(gestureState);},


onResponderTerminationRequest:function(e){
return config.onPanResponderTerminationRequest === undefined?true:
config.onPanResponderTerminationRequest(e,gestureState);}};


return {panHandlers:panHandlers};}};



module.exports = PanResponder;
});
__d('TouchHistoryMath',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";





var TouchHistoryMath={
















centroidDimension:function(touchHistory,touchesChangedAfter,isXAxis,ofCurrent){
var touchBank=touchHistory.touchBank;
var total=0;
var count=0;

var oneTouchData=touchHistory.numberActiveTouches === 1?
touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch]:null;

if(oneTouchData !== null){
if(oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter){
total += ofCurrent && isXAxis?oneTouchData.currentPageX:
ofCurrent && !isXAxis?oneTouchData.currentPageY:
!ofCurrent && isXAxis?oneTouchData.previousPageX:
oneTouchData.previousPageY;
count = 1;}}else 

{
for(var i=0;i < touchBank.length;i++) {
var touchTrack=touchBank[i];
if(touchTrack !== null && 
touchTrack !== undefined && 
touchTrack.touchActive && 
touchTrack.currentTimeStamp >= touchesChangedAfter){
var toAdd;
if(ofCurrent && isXAxis){
toAdd = touchTrack.currentPageX;}else 
if(ofCurrent && !isXAxis){
toAdd = touchTrack.currentPageY;}else 
if(!ofCurrent && isXAxis){
toAdd = touchTrack.previousPageX;}else 
{
toAdd = touchTrack.previousPageY;}

total += toAdd;
count++;}}}



return count > 0?total / count:TouchHistoryMath.noCentroid;},


currentCentroidXOfTouchesChangedAfter:function(touchHistory,touchesChangedAfter){
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
true,
true);},



currentCentroidYOfTouchesChangedAfter:function(touchHistory,touchesChangedAfter){
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
false,
true);},



previousCentroidXOfTouchesChangedAfter:function(touchHistory,touchesChangedAfter){
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
true,
false);},



previousCentroidYOfTouchesChangedAfter:function(touchHistory,touchesChangedAfter){
return TouchHistoryMath.centroidDimension(
touchHistory,
touchesChangedAfter,
false,
false);},



currentCentroidX:function(touchHistory){
return TouchHistoryMath.centroidDimension(
touchHistory,
0,
true,
true);},



currentCentroidY:function(touchHistory){
return TouchHistoryMath.centroidDimension(
touchHistory,
0,
false,
true);},



noCentroid:-1};


module.exports = TouchHistoryMath;
});
__d('clamp',[],function(global, require, requireDynamic, requireLazy, module, exports) {  function 























clamp(min,value,max){
if(value < min){
return min;}

if(value > max){
return max;}

return value;}


module.exports = clamp;
});
__d('rebound/rebound.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  (


























































































































function(){
var rebound={};
var util=rebound.util = {};
var concat=Array.prototype.concat;
var slice=Array.prototype.slice;


util.bind = function bind(func,context){
var args=slice.call(arguments,2);
return function(){
func.apply(context,concat.call(args,slice.call(arguments)));};};




util.extend = function extend(target,source){
for(var key in source) {
if(source.hasOwnProperty(key)){
target[key] = source[key];}}};









var SpringSystem=rebound.SpringSystem = function SpringSystem(looper){
this._springRegistry = {};
this._activeSprings = [];
this.listeners = [];
this._idleSpringIndices = [];
this.looper = looper || new AnimationLooper();
this.looper.springSystem = this;};


util.extend(SpringSystem.prototype,{

_springRegistry:null,

_isIdle:true,

_lastTimeMillis:-1,

_activeSprings:null,

listeners:null,

_idleSpringIndices:null,






setLooper:function(looper){
this.looper = looper;
looper.springSystem = this;},






createSpring:function(tension,friction){
var springConfig;
if(tension === undefined || friction === undefined){
springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;}else 
{
springConfig = 
SpringConfig.fromOrigamiTensionAndFriction(tension,friction);}

return this.createSpringWithConfig(springConfig);},





createSpringWithBouncinessAndSpeed:function(bounciness,speed){
var springConfig;
if(bounciness === undefined || speed === undefined){
springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;}else 
{
springConfig = 
SpringConfig.fromBouncinessAndSpeed(bounciness,speed);}

return this.createSpringWithConfig(springConfig);},



createSpringWithConfig:function(springConfig){
var spring=new Spring(this);
this.registerSpring(spring);
spring.setSpringConfig(springConfig);
return spring;},






getIsIdle:function(){
return this._isIdle;},





getSpringById:function(id){
return this._springRegistry[id];},




getAllSprings:function(){
var vals=[];
for(var id in this._springRegistry) {
if(this._springRegistry.hasOwnProperty(id)){
vals.push(this._springRegistry[id]);}}


return vals;},






registerSpring:function(spring){
this._springRegistry[spring.getId()] = spring;},






deregisterSpring:function(spring){
removeFirst(this._activeSprings,spring);
delete this._springRegistry[spring.getId()];},


advance:function(time,deltaTime){
while(this._idleSpringIndices.length > 0) this._idleSpringIndices.pop();
for(var i=0,len=this._activeSprings.length;i < len;i++) {
var spring=this._activeSprings[i];
if(spring.systemShouldAdvance()){
spring.advance(time / 1000.0,deltaTime / 1000.0);}else 
{
this._idleSpringIndices.push(this._activeSprings.indexOf(spring));}}


while(this._idleSpringIndices.length > 0) {
var idx=this._idleSpringIndices.pop();
idx >= 0 && this._activeSprings.splice(idx,1);}},
















loop:function(currentTimeMillis){
var listener;
if(this._lastTimeMillis === -1){
this._lastTimeMillis = currentTimeMillis - 1;}

var ellapsedMillis=currentTimeMillis - this._lastTimeMillis;
this._lastTimeMillis = currentTimeMillis;

var i=0,len=this.listeners.length;
for(i = 0;i < len;i++) {
listener = this.listeners[i];
listener.onBeforeIntegrate && listener.onBeforeIntegrate(this);}


this.advance(currentTimeMillis,ellapsedMillis);
if(this._activeSprings.length === 0){
this._isIdle = true;
this._lastTimeMillis = -1;}


for(i = 0;i < len;i++) {
listener = this.listeners[i];
listener.onAfterIntegrate && listener.onAfterIntegrate(this);}


if(!this._isIdle){
this.looper.run();}},






activateSpring:function(springId){
var spring=this._springRegistry[springId];
if(this._activeSprings.indexOf(spring) == -1){
this._activeSprings.push(spring);}

if(this.getIsIdle()){
this._isIdle = false;
this.looper.run();}},






addListener:function(listener){
this.listeners.push(listener);},



removeListener:function(listener){
removeFirst(this.listeners,listener);},



removeAllListeners:function(){
this.listeners = [];}});


















var Spring=rebound.Spring = function Spring(springSystem){
this._id = 's' + Spring._ID++;
this._springSystem = springSystem;
this.listeners = [];
this._currentState = new PhysicsState();
this._previousState = new PhysicsState();
this._tempState = new PhysicsState();};


util.extend(Spring,{
_ID:0,

MAX_DELTA_TIME_SEC:0.064,

SOLVER_TIMESTEP_SEC:0.001});



util.extend(Spring.prototype,{

_id:0,

_springConfig:null,

_overshootClampingEnabled:false,

_currentState:null,

_previousState:null,

_tempState:null,

_startValue:0,

_endValue:0,

_wasAtRest:true,

_restSpeedThreshold:0.001,

_displacementFromRestThreshold:0.001,

listeners:null,

_timeAccumulator:0,

_springSystem:null,


destroy:function(){
this.listeners = [];
this.frames = [];
this._springSystem.deregisterSpring(this);},




getId:function(){
return this._id;},





setSpringConfig:function(springConfig){
this._springConfig = springConfig;
return this;},



getSpringConfig:function(){
return this._springConfig;},





























setCurrentValue:function(currentValue,skipSetAtRest){
this._startValue = currentValue;
this._currentState.position = currentValue;
if(!skipSetAtRest){
this.setAtRest();}

this.notifyPositionUpdated(false,false);
return this;},





getStartValue:function(){
return this._startValue;},



getCurrentValue:function(){
return this._currentState.position;},




getCurrentDisplacementDistance:function(){
return this.getDisplacementDistanceForState(this._currentState);},


getDisplacementDistanceForState:function(state){
return Math.abs(this._endValue - state.position);},








setEndValue:function(endValue){
if(this._endValue == endValue && this.isAtRest()){
return this;}

this._startValue = this.getCurrentValue();
this._endValue = endValue;
this._springSystem.activateSpring(this.getId());
for(var i=0,len=this.listeners.length;i < len;i++) {
var listener=this.listeners[i];
var onChange=listener.onSpringEndStateChange;
onChange && onChange(this);}

return this;},



getEndValue:function(){
return this._endValue;},









setVelocity:function(velocity){
if(velocity === this._currentState.velocity){
return this;}

this._currentState.velocity = velocity;
this._springSystem.activateSpring(this.getId());
return this;},



getVelocity:function(){
return this._currentState.velocity;},




setRestSpeedThreshold:function(restSpeedThreshold){
this._restSpeedThreshold = restSpeedThreshold;
return this;},



getRestSpeedThreshold:function(){
return this._restSpeedThreshold;},





setRestDisplacementThreshold:function(displacementFromRestThreshold){
this._displacementFromRestThreshold = displacementFromRestThreshold;},



getRestDisplacementThreshold:function(){
return this._displacementFromRestThreshold;},







setOvershootClampingEnabled:function(enabled){
this._overshootClampingEnabled = enabled;
return this;},



isOvershootClampingEnabled:function(){
return this._overshootClampingEnabled;},





isOvershooting:function(){
var start=this._startValue;
var end=this._endValue;
return this._springConfig.tension > 0 && (
start < end && this.getCurrentValue() > end || 
start > end && this.getCurrentValue() < end);},







advance:function(time,realDeltaTime){
var isAtRest=this.isAtRest();

if(isAtRest && this._wasAtRest){
return;}


var adjustedDeltaTime=realDeltaTime;
if(realDeltaTime > Spring.MAX_DELTA_TIME_SEC){
adjustedDeltaTime = Spring.MAX_DELTA_TIME_SEC;}


this._timeAccumulator += adjustedDeltaTime;

var tension=this._springConfig.tension,
friction=this._springConfig.friction,

position=this._currentState.position,
velocity=this._currentState.velocity,
tempPosition=this._tempState.position,
tempVelocity=this._tempState.velocity,

aVelocity,aAcceleration,
bVelocity,bAcceleration,
cVelocity,cAcceleration,
dVelocity,dAcceleration,

dxdt,dvdt;

while(this._timeAccumulator >= Spring.SOLVER_TIMESTEP_SEC) {

this._timeAccumulator -= Spring.SOLVER_TIMESTEP_SEC;

if(this._timeAccumulator < Spring.SOLVER_TIMESTEP_SEC){
this._previousState.position = position;
this._previousState.velocity = velocity;}


aVelocity = velocity;
aAcceleration = 
tension * (this._endValue - tempPosition) - friction * velocity;

tempPosition = position + aVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;
tempVelocity = 
velocity + aAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;
bVelocity = tempVelocity;
bAcceleration = 
tension * (this._endValue - tempPosition) - friction * tempVelocity;

tempPosition = position + bVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;
tempVelocity = 
velocity + bAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;
cVelocity = tempVelocity;
cAcceleration = 
tension * (this._endValue - tempPosition) - friction * tempVelocity;

tempPosition = position + cVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;
tempVelocity = 
velocity + cAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;
dVelocity = tempVelocity;
dAcceleration = 
tension * (this._endValue - tempPosition) - friction * tempVelocity;

dxdt = 
1.0 / 6.0 * (aVelocity + 2.0 * (bVelocity + cVelocity) + dVelocity);
dvdt = 1.0 / 6.0 * (
aAcceleration + 2.0 * (bAcceleration + cAcceleration) + dAcceleration);


position += dxdt * Spring.SOLVER_TIMESTEP_SEC;
velocity += dvdt * Spring.SOLVER_TIMESTEP_SEC;}


this._tempState.position = tempPosition;
this._tempState.velocity = tempVelocity;

this._currentState.position = position;
this._currentState.velocity = velocity;

if(this._timeAccumulator > 0){
this.interpolate(this._timeAccumulator / Spring.SOLVER_TIMESTEP_SEC);}


if(this.isAtRest() || 
this._overshootClampingEnabled && this.isOvershooting()){

if(this._springConfig.tension > 0){
this._startValue = this._endValue;
this._currentState.position = this._endValue;}else 
{
this._endValue = this._currentState.position;
this._startValue = this._endValue;}

this.setVelocity(0);
isAtRest = true;}


var notifyActivate=false;
if(this._wasAtRest){
this._wasAtRest = false;
notifyActivate = true;}


var notifyAtRest=false;
if(isAtRest){
this._wasAtRest = true;
notifyAtRest = true;}


this.notifyPositionUpdated(notifyActivate,notifyAtRest);},


notifyPositionUpdated:function(notifyActivate,notifyAtRest){
for(var i=0,len=this.listeners.length;i < len;i++) {
var listener=this.listeners[i];
if(notifyActivate && listener.onSpringActivate){
listener.onSpringActivate(this);}


if(listener.onSpringUpdate){
listener.onSpringUpdate(this);}


if(notifyAtRest && listener.onSpringAtRest){
listener.onSpringAtRest(this);}}},









systemShouldAdvance:function(){
return !this.isAtRest() || !this.wasAtRest();},


wasAtRest:function(){
return this._wasAtRest;},








isAtRest:function(){
return Math.abs(this._currentState.velocity) < this._restSpeedThreshold && (
this.getDisplacementDistanceForState(this._currentState) <= 
this._displacementFromRestThreshold || 
this._springConfig.tension === 0);},






setAtRest:function(){
this._endValue = this._currentState.position;
this._tempState.position = this._currentState.position;
this._currentState.velocity = 0;
return this;},


interpolate:function(alpha){
this._currentState.position = this._currentState.position * 
alpha + this._previousState.position * (1 - alpha);
this._currentState.velocity = this._currentState.velocity * 
alpha + this._previousState.velocity * (1 - alpha);},


getListeners:function(){
return this.listeners;},


addListener:function(newListener){
this.listeners.push(newListener);
return this;},


removeListener:function(listenerToRemove){
removeFirst(this.listeners,listenerToRemove);
return this;},


removeAllListeners:function(){
this.listeners = [];
return this;},


currentValueIsApproximately:function(value){
return Math.abs(this.getCurrentValue() - value) <= 
this.getRestDisplacementThreshold();}});









var PhysicsState=function PhysicsState(){};

util.extend(PhysicsState.prototype,{
position:0,
velocity:0});








var SpringConfig=rebound.SpringConfig = 
function SpringConfig(tension,friction){
this.tension = tension;
this.friction = friction;};







var AnimationLooper=rebound.AnimationLooper = function AnimationLooper(){
this.springSystem = null;
var _this=this;
var _run=function(){
_this.springSystem.loop(Date.now());};


this.run = function(){
util.onFrame(_run);};};









rebound.SimulationLooper = function SimulationLooper(timestep){
this.springSystem = null;
var time=0;
var running=false;
timestep = timestep || 16.667;

this.run = function(){
if(running){
return;}

running = true;
while(!this.springSystem.getIsIdle()) {
this.springSystem.loop(time += timestep);}

running = false;};};








rebound.SteppingSimulationLooper = function(timestep){
this.springSystem = null;
var time=0;



this.run = function(){};


this.step = function(timestep){
this.springSystem.loop(time += timestep);};};








var OrigamiValueConverter=rebound.OrigamiValueConverter = {
tensionFromOrigamiValue:function(oValue){
return (oValue - 30.0) * 3.62 + 194.0;},


origamiValueFromTension:function(tension){
return (tension - 194.0) / 3.62 + 30.0;},


frictionFromOrigamiValue:function(oValue){
return (oValue - 8.0) * 3.0 + 25.0;},


origamiFromFriction:function(friction){
return (friction - 25.0) / 3.0 + 8.0;}};










var BouncyConversion=rebound.BouncyConversion = function(bounciness,speed){
this.bounciness = bounciness;
this.speed = speed;
var b=this.normalize(bounciness / 1.7,0,20.0);
b = this.projectNormal(b,0.0,0.8);
var s=this.normalize(speed / 1.7,0,20.0);
this.bouncyTension = this.projectNormal(s,0.5,200);
this.bouncyFriction = this.quadraticOutInterpolation(
b,
this.b3Nobounce(this.bouncyTension),
0.01);};


util.extend(BouncyConversion.prototype,{

normalize:function(value,startValue,endValue){
return (value - startValue) / (endValue - startValue);},


projectNormal:function(n,start,end){
return start + n * (end - start);},


linearInterpolation:function(t,start,end){
return t * end + (1.0 - t) * start;},


quadraticOutInterpolation:function(t,start,end){
return this.linearInterpolation(2 * t - t * t,start,end);},


b3Friction1:function(x){
return 0.0007 * Math.pow(x,3) - 
0.031 * Math.pow(x,2) + 0.64 * x + 1.28;},


b3Friction2:function(x){
return 0.000044 * Math.pow(x,3) - 
0.006 * Math.pow(x,2) + 0.36 * x + 2;},


b3Friction3:function(x){
return 0.00000045 * Math.pow(x,3) - 
0.000332 * Math.pow(x,2) + 0.1078 * x + 5.84;},


b3Nobounce:function(tension){
var friction=0;
if(tension <= 18){
friction = this.b3Friction1(tension);}else 
if(tension > 18 && tension <= 44){
friction = this.b3Friction2(tension);}else 
{
friction = this.b3Friction3(tension);}

return friction;}});



util.extend(SpringConfig,{




fromOrigamiTensionAndFriction:function(tension,friction){
return new SpringConfig(
OrigamiValueConverter.tensionFromOrigamiValue(tension),
OrigamiValueConverter.frictionFromOrigamiValue(friction));},





fromBouncinessAndSpeed:function(bounciness,speed){
var bouncyConversion=new rebound.BouncyConversion(bounciness,speed);
return this.fromOrigamiTensionAndFriction(
bouncyConversion.bouncyTension,
bouncyConversion.bouncyFriction);},




coastingConfigWithOrigamiFriction:function(friction){
return new SpringConfig(
0,
OrigamiValueConverter.frictionFromOrigamiValue(friction));}});




SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG = 
SpringConfig.fromOrigamiTensionAndFriction(40,7);

util.extend(SpringConfig.prototype,{friction:0,tension:0});




var colorCache={};
util.hexToRGB = function(color){
if(colorCache[color]){
return colorCache[color];}

color = color.replace('#','');
if(color.length === 3){
color = color[0] + color[0] + color[1] + color[1] + color[2] + color[2];}

var parts=color.match(/.{2}/g);

var ret={
r:parseInt(parts[0],16),
g:parseInt(parts[1],16),
b:parseInt(parts[2],16)};


colorCache[color] = ret;
return ret;};


util.rgbToHex = function(r,g,b){
r = r.toString(16);
g = g.toString(16);
b = b.toString(16);
r = r.length < 2?'0' + r:r;
g = g.length < 2?'0' + g:g;
b = b.length < 2?'0' + b:b;
return '#' + r + g + b;};


var MathUtil=rebound.MathUtil = {








mapValueInRange:function(value,fromLow,fromHigh,toLow,toHigh){
var fromRangeSize=fromHigh - fromLow;
var toRangeSize=toHigh - toLow;
var valueScale=(value - fromLow) / fromRangeSize;
return toLow + valueScale * toRangeSize;},





interpolateColor:
function(val,startColor,endColor,fromLow,fromHigh,asRGB){
fromLow = fromLow === undefined?0:fromLow;
fromHigh = fromHigh === undefined?1:fromHigh;
startColor = util.hexToRGB(startColor);
endColor = util.hexToRGB(endColor);
var r=Math.floor(
util.mapValueInRange(val,fromLow,fromHigh,startColor.r,endColor.r));

var g=Math.floor(
util.mapValueInRange(val,fromLow,fromHigh,startColor.g,endColor.g));

var b=Math.floor(
util.mapValueInRange(val,fromLow,fromHigh,startColor.b,endColor.b));

if(asRGB){
return 'rgb(' + r + ',' + g + ',' + b + ')';}else 
{
return util.rgbToHex(r,g,b);}},



degreesToRadians:function(deg){
return deg * Math.PI / 180;},


radiansToDegrees:function(rad){
return rad * 180 / Math.PI;}};




util.extend(util,MathUtil);







function removeFirst(array,item){
var idx=array.indexOf(item);
idx != -1 && array.splice(idx,1);}


var _onFrame;
if(typeof window !== 'undefined'){
_onFrame = window.requestAnimationFrame || 
window.webkitRequestAnimationFrame || 
window.mozRequestAnimationFrame || 
window.msRequestAnimationFrame || 
window.oRequestAnimationFrame;}

if(!_onFrame && typeof process !== 'undefined' && process.title === 'node'){
_onFrame = setImmediate;}



util.onFrame = function onFrame(func){
return _onFrame(func);};




if(typeof exports != 'undefined'){
util.extend(exports,rebound);}else 
if(typeof window != 'undefined'){
window.rebound = rebound;}})();
});
__d('NavigatorIOS',["EventEmitter","Image","React","ReactNativeViewAttributes","NativeModules","StyleSheet","StaticContainer.react","View","createReactNativeComponentClass","invariant","logError","merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var EventEmitter=require('EventEmitter');
var Image=require('Image');
var React=require('React');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var RCTNavigatorManager=require('NativeModules').NavigatorManager;
var StyleSheet=require('StyleSheet');
var StaticContainer=require('StaticContainer.react');
var View=require('View');

var createReactNativeComponentClass=
require('createReactNativeComponentClass');
var invariant=require('invariant');
var logError=require('logError');
var merge=require('merge');

var TRANSITIONER_REF='transitionerRef';

var PropTypes=React.PropTypes;

var __uid=0;
function getuid(){
return __uid++;}


var RCTNavigator=createReactNativeComponentClass({
validAttributes:merge(ReactNativeViewAttributes.UIView,{
requestedTopOfStack:true}),

uiViewClassName:'RCTNavigator'});


var RCTNavigatorItem=createReactNativeComponentClass({
validAttributes:{


title:true,
barTintColor:true,
leftButtonIcon:true,
leftButtonTitle:true,
onNavLeftButtonTap:true,
rightButtonIcon:true,
rightButtonTitle:true,
onNavRightButtonTap:true,
backButtonIcon:true,
backButtonTitle:true,
tintColor:true,
navigationBarHidden:true,
titleTextColor:true,
style:true},

uiViewClassName:'RCTNavItem'});


var NavigatorTransitionerIOS=React.createClass({displayName:'NavigatorTransitionerIOS',
requestSchedulingNavigation:function(cb){
RCTNavigatorManager.requestSchedulingJavaScriptNavigation(
React.findNodeHandle(this),
logError,
cb);},



render:function(){
return (
React.createElement(RCTNavigator,this.props));}});

























































































































var NavigatorIOS=React.createClass({displayName:'NavigatorIOS',

propTypes:{






initialRoute:PropTypes.shape({



component:PropTypes.func.isRequired,




title:PropTypes.string.isRequired,





passProps:PropTypes.object,






backButtonIcon:Image.propTypes.source,






backButtonTitle:PropTypes.string,




leftButtonIcon:Image.propTypes.source,




leftButtonTitle:PropTypes.string,




onLeftButtonPress:PropTypes.func,




rightButtonIcon:Image.propTypes.source,




rightButtonTitle:PropTypes.string,




onRightButtonPress:PropTypes.func,




wrapperStyle:View.propTypes.style}).

isRequired,




navigationBarHidden:PropTypes.bool,





itemWrapperStyle:View.propTypes.style,




tintColor:PropTypes.string,




barTintColor:PropTypes.string,




titleTextColor:PropTypes.string},



navigator:undefined,

componentWillMount:function(){


this.navigator = {
push:this.push,
pop:this.pop,
popN:this.popN,
replace:this.replace,
replacePrevious:this.replacePrevious,
replacePreviousAndPop:this.replacePreviousAndPop,
resetTo:this.resetTo,
popToRoute:this.popToRoute,
popToTop:this.popToTop};},



getInitialState:function(){
return {
idStack:[getuid()],
routeStack:[this.props.initialRoute],

requestedTopOfStack:0,






observedTopOfStack:0,
progress:1,
fromIndex:0,
toIndex:0,


makingNavigatorRequest:false,



updatingAllIndicesAtOrBeyond:0};},



_toFocusOnNavigationComplete:undefined,

_handleFocusRequest:function(item){
if(this.state.makingNavigatorRequest){
this._toFocusOnNavigationComplete = item;}else 
{
this._getFocusEmitter().emit('focus',item);}},



_focusEmitter:undefined,

_getFocusEmitter:function(){

var focusEmitter=this._focusEmitter;
if(!focusEmitter){
focusEmitter = new EventEmitter();
this._focusEmitter = focusEmitter;}

return focusEmitter;},


getChildContext:function()


{
return {
onFocusRequested:this._handleFocusRequest,
focusEmitter:this._getFocusEmitter()};},



childContextTypes:{
onFocusRequested:React.PropTypes.func,
focusEmitter:React.PropTypes.instanceOf(EventEmitter)},


_tryLockNavigator:function(cb){
this.refs[TRANSITIONER_REF].requestSchedulingNavigation(
function(acquiredLock){return acquiredLock && cb();});},



_handleNavigatorStackChanged:function(e){
var newObservedTopOfStack=e.nativeEvent.stackLength - 1;
invariant(
newObservedTopOfStack <= this.state.requestedTopOfStack,
'No navigator item should be pushed without JS knowing about it %s %s',newObservedTopOfStack,this.state.requestedTopOfStack);

var wasWaitingForConfirmation=
this.state.requestedTopOfStack !== this.state.observedTopOfStack;
if(wasWaitingForConfirmation){
invariant(
newObservedTopOfStack === this.state.requestedTopOfStack,
'If waiting for observedTopOfStack to reach requestedTopOfStack, ' + 
'the only valid observedTopOfStack should be requestedTopOfStack.');}











var nextState={
observedTopOfStack:newObservedTopOfStack,
makingNavigatorRequest:false,
updatingAllIndicesAtOrBeyond:null,
progress:1,
toIndex:newObservedTopOfStack,
fromIndex:newObservedTopOfStack};

this.setState(nextState,this._eliminateUnneededChildren);},


_eliminateUnneededChildren:function(){



var updatingAllIndicesAtOrBeyond=
this.state.routeStack.length > this.state.observedTopOfStack + 1?
this.state.observedTopOfStack + 1:
null;
this.setState({
idStack:this.state.idStack.slice(0,this.state.observedTopOfStack + 1),
routeStack:this.state.routeStack.slice(0,this.state.observedTopOfStack + 1),

requestedTopOfStack:this.state.observedTopOfStack,
makingNavigatorRequest:true,
updatingAllIndicesAtOrBeyond:updatingAllIndicesAtOrBeyond});},



push:function(route){var _this=this;
invariant(!!route,'Must supply route to push');

if(this.state.requestedTopOfStack === this.state.observedTopOfStack){
this._tryLockNavigator(function(){
var nextStack=_this.state.routeStack.concat([route]);
var nextIDStack=_this.state.idStack.concat([getuid()]);
_this.setState({


idStack:nextIDStack,
routeStack:nextStack,
requestedTopOfStack:nextStack.length - 1,
makingNavigatorRequest:true,
updatingAllIndicesAtOrBeyond:nextStack.length - 1});});}},





popN:function(n){var _this2=this;
if(n === 0){
return;}


if(this.state.requestedTopOfStack === this.state.observedTopOfStack){
if(this.state.requestedTopOfStack > 0){
this._tryLockNavigator(function(){
invariant(
_this2.state.requestedTopOfStack - n >= 0,
'Cannot pop below 0');

_this2.setState({
requestedTopOfStack:_this2.state.requestedTopOfStack - n,
makingNavigatorRequest:true,


updatingAllIndicesAtOrBeyond:null});});}}},






pop:function(){
this.popN(1);},








replaceAtIndex:function(route,index){
invariant(!!route,'Must supply route to replace');
if(index < 0){
index += this.state.routeStack.length;}


if(this.state.routeStack.length <= index){
return;}




var nextIDStack=this.state.idStack.slice();
var nextRouteStack=this.state.routeStack.slice();
nextIDStack[index] = getuid();
nextRouteStack[index] = route;

this.setState({
idStack:nextIDStack,
routeStack:nextRouteStack,
makingNavigatorRequest:false,
updatingAllIndicesAtOrBeyond:index});},






replace:function(route){
this.replaceAtIndex(route,-1);},





replacePrevious:function(route){
this.replaceAtIndex(route,-2);},


popToTop:function(){
this.popToRoute(this.state.routeStack[0]);},


popToRoute:function(route){
var indexOfRoute=this.state.routeStack.indexOf(route);
invariant(
indexOfRoute !== -1,
'Calling pop to route for a route that doesn\'t exist!');

var numToPop=this.state.routeStack.length - indexOfRoute - 1;
this.popN(numToPop);},


replacePreviousAndPop:function(route){var _this3=this;

if(this.state.requestedTopOfStack !== this.state.observedTopOfStack){
return;}

if(this.state.routeStack.length < 2){
return;}

this._tryLockNavigator(function(){
_this3.replacePrevious(route);
_this3.setState({
requestedTopOfStack:_this3.state.requestedTopOfStack - 1,
makingNavigatorRequest:true});});},




resetTo:function(route){
invariant(!!route,'Must supply route to push');

if(this.state.requestedTopOfStack !== this.state.observedTopOfStack){
return;}

this.replaceAtIndex(route,0);
this.popToRoute(route);},


handleNavigationComplete:function(e){
if(this._toFocusOnNavigationComplete){
this._getFocusEmitter().emit('focus',this._toFocusOnNavigationComplete);
this._toFocusOnNavigationComplete = null;}

this._handleNavigatorStackChanged(e);},


_routeToStackItem:function(route,i){
var Component=route.component;
var shouldUpdateChild=this.state.updatingAllIndicesAtOrBeyond !== null && 
this.state.updatingAllIndicesAtOrBeyond >= i;

return (
React.createElement(StaticContainer,{key:'nav' + i,shouldUpdate:shouldUpdateChild},
React.createElement(RCTNavigatorItem,{
title:route.title,
style:[
styles.stackItem,
this.props.itemWrapperStyle,
route.wrapperStyle],

backButtonIcon:this._imageNameFromSource(route.backButtonIcon),
backButtonTitle:route.backButtonTitle,
leftButtonIcon:this._imageNameFromSource(route.leftButtonIcon),
leftButtonTitle:route.leftButtonTitle,
onNavLeftButtonTap:route.onLeftButtonPress,
rightButtonIcon:this._imageNameFromSource(route.rightButtonIcon),
rightButtonTitle:route.rightButtonTitle,
onNavRightButtonTap:route.onRightButtonPress,
navigationBarHidden:this.props.navigationBarHidden,
tintColor:this.props.tintColor,
barTintColor:this.props.barTintColor,
titleTextColor:this.props.titleTextColor},
React.createElement(Component,_extends({
navigator:this.navigator,
route:route},
route.passProps)))));},






_imageNameFromSource:function(source){
return source?source.uri:undefined;},


renderNavigationStackItems:function(){
var shouldRecurseToNavigator=
this.state.makingNavigatorRequest || 
this.state.updatingAllIndicesAtOrBeyond !== null;


var items=shouldRecurseToNavigator?
this.state.routeStack.map(this._routeToStackItem):null;
return (
React.createElement(StaticContainer,{shouldUpdate:shouldRecurseToNavigator},
React.createElement(NavigatorTransitionerIOS,{
ref:TRANSITIONER_REF,
style:styles.transitioner,
vertical:this.props.vertical,
requestedTopOfStack:this.state.requestedTopOfStack,
onNavigationComplete:this.handleNavigationComplete},
items)));},





render:function(){
return (
React.createElement(View,{style:this.props.style},
this.renderNavigationStackItems()));}});





var styles=StyleSheet.create({
stackItem:{
backgroundColor:'white',
overflow:'hidden',
position:'absolute',
top:0,
left:0,
right:0,
bottom:0},

transitioner:{
flex:1}});



module.exports = NavigatorIOS;
});
__d('PickerIOS',["NativeMethodsMixin","React","ReactChildren","ReactNativeViewAttributes","NativeModules","StyleSheet","View","requireNativeComponent","merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var NativeMethodsMixin=require('NativeMethodsMixin');
var React=require('React');
var ReactChildren=require('ReactChildren');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var RCTPickerIOSConsts=require('NativeModules').UIManager.RCTPicker.Constants;
var StyleSheet=require('StyleSheet');
var View=require('View');

var requireNativeComponent=require('requireNativeComponent');
var merge=require('merge');

var PICKER='picker';

var PickerIOS=React.createClass({displayName:'PickerIOS',
mixins:[NativeMethodsMixin],

propTypes:{
onValueChange:React.PropTypes.func,
selectedValue:React.PropTypes.any},


getInitialState:function(){
return this._stateFromProps(this.props);},


componentWillReceiveProps:function(nextProps){
this.setState(this._stateFromProps(nextProps));},



_stateFromProps:function(props){
var selectedIndex=0;
var items=[];
ReactChildren.forEach(props.children,function(child,index){
if(child.props.value === props.selectedValue){
selectedIndex = index;}

items.push({value:child.props.value,label:child.props.label});});

return {selectedIndex:selectedIndex,items:items};},


render:function(){
return (
React.createElement(View,{style:this.props.style},
React.createElement(RCTPickerIOS,{
ref:PICKER,
style:styles.pickerIOS,
items:this.state.items,
selectedIndex:this.state.selectedIndex,
onChange:this._onChange})));},





_onChange:function(event){
if(this.props.onChange){
this.props.onChange(event);}

if(this.props.onValueChange){
this.props.onValueChange(event.nativeEvent.newValue);}








if(this.state.selectedIndex !== event.nativeEvent.newIndex){
this.refs[PICKER].setNativeProps({
selectedIndex:this.state.selectedIndex});}}});





PickerIOS.Item = React.createClass({displayName:'Item',
propTypes:{
value:React.PropTypes.any,
label:React.PropTypes.string},


render:function(){

return null;}});



var styles=StyleSheet.create({
pickerIOS:{



height:RCTPickerIOSConsts.ComponentHeight}});



var RCTPickerIOS=requireNativeComponent('RCTPicker',null);

module.exports = PickerIOS;
});
__d('ProgressViewIOS',["Image","NativeMethodsMixin","NativeModules","ReactPropTypes","React","StyleSheet","requireNativeComponent","verifyPropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var Image=require('Image');
var NativeMethodsMixin=require('NativeMethodsMixin');
var NativeModules=require('NativeModules');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var StyleSheet=require('StyleSheet');

var requireNativeComponent=require('requireNativeComponent');
var verifyPropTypes=require('verifyPropTypes');




var ProgressViewIOS=React.createClass({displayName:'ProgressViewIOS',
mixins:[NativeMethodsMixin],

propTypes:{



progressViewStyle:PropTypes.oneOf(['default','bar']),




progress:PropTypes.number,




progressTintColor:PropTypes.string,




trackTintColor:PropTypes.string,




progressImage:Image.propTypes.source,




trackImage:Image.propTypes.source},


render:function(){
return (
React.createElement(RCTProgressView,_extends({},
this.props,{
style:[styles.progressView,this.props.style]})));}});





var styles=StyleSheet.create({
progressView:{
height:NativeModules.ProgressViewManager.ComponentHeight}});



var RCTProgressView=requireNativeComponent(
'RCTProgressView',
ProgressViewIOS);


module.exports = ProgressViewIOS;
});
__d('SegmentedControlIOS',["NativeMethodsMixin","NativeModules","ReactPropTypes","React","StyleSheet","requireNativeComponent","verifyPropTypes"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var NativeMethodsMixin=require('NativeMethodsMixin');
var NativeModules=require('NativeModules');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var StyleSheet=require('StyleSheet');

var requireNativeComponent=require('requireNativeComponent');
var verifyPropTypes=require('verifyPropTypes');






var SEGMENTED_CONTROL_REFERENCE='segmentedcontrol';






var SegmentedControlIOS=React.createClass({displayName:'SegmentedControlIOS',
mixins:[NativeMethodsMixin],

propTypes:{



values:PropTypes.arrayOf(PropTypes.string),




selectedIndex:PropTypes.number,





onValueChange:PropTypes.func,





onChange:PropTypes.func,





enabled:PropTypes.bool,




tintColor:PropTypes.string,





momentary:PropTypes.bool},


getDefaultProps:function(){
return {
values:[],
enabled:true};},



_onChange:function(event){
this.props.onChange && this.props.onChange(event);
this.props.onValueChange && this.props.onValueChange(event.nativeEvent.value);},


render:function(){
return (
React.createElement(RCTSegmentedControl,_extends({},
this.props,{
ref:SEGMENTED_CONTROL_REFERENCE,
style:[styles.segmentedControl,this.props.style],
onChange:this._onChange})));}});





var styles=StyleSheet.create({
segmentedControl:{
height:NativeModules.SegmentedControlManager.ComponentHeight}});



var RCTSegmentedControl=requireNativeComponent(
'RCTSegmentedControl',
SegmentedControlIOS);


module.exports = SegmentedControlIOS;
});
__d('SliderIOS',["NativeMethodsMixin","ReactPropTypes","React","StyleSheet","View","requireNativeComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeMethodsMixin=require('NativeMethodsMixin');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var StyleSheet=require('StyleSheet');
var View=require('View');

var requireNativeComponent=require('requireNativeComponent');



var SliderIOS=React.createClass({displayName:'SliderIOS',
mixins:[NativeMethodsMixin],

propTypes:{




style:View.propTypes.style,









value:PropTypes.number,




minimumValue:PropTypes.number,




maximumValue:PropTypes.number,





minimumTrackTintColor:PropTypes.string,





maximumTrackTintColor:PropTypes.string,




onValueChange:PropTypes.func,





onSlidingComplete:PropTypes.func},


_onValueChange:function(event){
this.props.onChange && this.props.onChange(event);
if(event.nativeEvent.continuous){
this.props.onValueChange && 
this.props.onValueChange(event.nativeEvent.value);}else 
{
this.props.onSlidingComplete && event.nativeEvent.value !== undefined && 
this.props.onSlidingComplete(event.nativeEvent.value);}},



render:function(){
return (
React.createElement(RCTSlider,{
style:[styles.slider,this.props.style],
value:this.props.value,
maximumValue:this.props.maximumValue,
minimumValue:this.props.minimumValue,
minimumTrackTintColor:this.props.minimumTrackTintColor,
maximumTrackTintColor:this.props.maximumTrackTintColor,
onChange:this._onValueChange}));}});





var styles=StyleSheet.create({
slider:{
height:40}});



var RCTSlider=requireNativeComponent('RCTSlider',SliderIOS);

module.exports = SliderIOS;
});
__d('SwitchIOS',["NativeMethodsMixin","ReactPropTypes","React","StyleSheet","requireNativeComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};














var NativeMethodsMixin=require('NativeMethodsMixin');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var StyleSheet=require('StyleSheet');

var requireNativeComponent=require('requireNativeComponent');

var SWITCH='switch';















var SwitchIOS=React.createClass({displayName:'SwitchIOS',
mixins:[NativeMethodsMixin],

propTypes:{




value:PropTypes.bool,





disabled:PropTypes.bool,




onValueChange:PropTypes.func,




onTintColor:PropTypes.string,




thumbTintColor:PropTypes.string,




tintColor:PropTypes.string},


getDefaultProps:function(){
return {
value:false,
disabled:false};},



_onChange:function(event){
this.props.onChange && this.props.onChange(event);
this.props.onValueChange && this.props.onValueChange(event.nativeEvent.value);



this.refs[SWITCH].setNativeProps({value:this.props.value});},


render:function(){
return (
React.createElement(RCTSwitch,_extends({},
this.props,{
ref:SWITCH,
onChange:this._onChange,
style:[styles.rkSwitch,this.props.style]})));}});





var styles=StyleSheet.create({
rkSwitch:{
height:31,
width:51}});



var RCTSwitch=requireNativeComponent('RCTSwitch',SwitchIOS);

module.exports = SwitchIOS;
});
__d('TabBarIOS',["React","StyleSheet","TabBarItemIOS","View","requireNativeComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var React=require('React');
var StyleSheet=require('StyleSheet');
var TabBarItemIOS=require('TabBarItemIOS');
var View=require('View');

var requireNativeComponent=require('requireNativeComponent');

var TabBarIOS=React.createClass({displayName:'TabBarIOS',
statics:{
Item:TabBarItemIOS},


propTypes:{
style:View.propTypes.style,



tintColor:React.PropTypes.string,



barTintColor:React.PropTypes.string},


render:function(){
return (
React.createElement(RCTTabBar,{
style:[styles.tabGroup,this.props.style],
tintColor:this.props.tintColor,
barTintColor:this.props.barTintColor},
this.props.children));}});





var styles=StyleSheet.create({
tabGroup:{
flex:1}});



var RCTTabBar=requireNativeComponent('RCTTabBar',TabBarIOS);

module.exports = TabBarIOS;
});
__d('TabBarItemIOS',["Image","React","StaticContainer.react","StyleSheet","View","requireNativeComponent"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var Image=require('Image');
var React=require('React');
var StaticContainer=require('StaticContainer.react');
var StyleSheet=require('StyleSheet');
var View=require('View');

var requireNativeComponent=require('requireNativeComponent');

var TabBarItemIOS=React.createClass({displayName:'TabBarItemIOS',
propTypes:{



badge:React.PropTypes.oneOfType([
React.PropTypes.string,
React.PropTypes.number]),






systemIcon:React.PropTypes.oneOf([
'bookmarks',
'contacts',
'downloads',
'favorites',
'featured',
'history',
'more',
'most-recent',
'most-viewed',
'recents',
'search',
'top-rated']),




icon:Image.propTypes.source,




selectedIcon:Image.propTypes.source,




onPress:React.PropTypes.func,




selected:React.PropTypes.bool,



style:View.propTypes.style,




title:React.PropTypes.string},


getInitialState:function(){
return {
hasBeenSelected:false};},



componentWillMount:function(){
if(this.props.selected){
this.setState({hasBeenSelected:true});}},



componentWillReceiveProps:function(nextProps){
if(this.state.hasBeenSelected || nextProps.selected){
this.setState({hasBeenSelected:true});}},



render:function(){
var tabContents=null;


if(this.state.hasBeenSelected){
tabContents = 
React.createElement(StaticContainer,{shouldUpdate:this.props.selected},
this.props.children);}else 

{
tabContents = React.createElement(View,null);}


var icon=this.props.systemIcon || 
this.props.icon && this.props.icon.uri;


var badge=typeof this.props.badge === 'number'?
'' + this.props.badge:
this.props.badge;

return (
React.createElement(RCTTabBarItem,{
icon:icon,
selectedIcon:this.props.selectedIcon && this.props.selectedIcon.uri,
onPress:this.props.onPress,
selected:this.props.selected,
badge:badge,
title:this.props.title,
style:[styles.tab,this.props.style]},
tabContents));}});





var styles=StyleSheet.create({
tab:{
position:'absolute',
top:0,
right:0,
bottom:0,
left:0}});



var RCTTabBarItem=requireNativeComponent('RCTTabBarItem',TabBarItemIOS);

module.exports = TabBarItemIOS;
});
__d('Text',["NativeMethodsMixin","Platform","React","ReactInstanceMap","ReactNativeViewAttributes","StyleSheetPropType","TextStylePropTypes","Touchable","createReactNativeComponentClass","merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeMethodsMixin=require('NativeMethodsMixin');
var Platform=require('Platform');
var React=require('React');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var StyleSheetPropType=require('StyleSheetPropType');
var TextStylePropTypes=require('TextStylePropTypes');
var Touchable=require('Touchable');

var createReactNativeComponentClass=
require('createReactNativeComponentClass');
var merge=require('merge');

var stylePropType=StyleSheetPropType(TextStylePropTypes);

var viewConfig={
validAttributes:merge(ReactNativeViewAttributes.UIView,{
isHighlighted:true,
numberOfLines:true}),

uiViewClassName:'RCTText'};



































var Text=React.createClass({displayName:'Text',

mixins:[Touchable.Mixin,NativeMethodsMixin],

propTypes:{





numberOfLines:React.PropTypes.number,





onPress:React.PropTypes.func,




suppressHighlighting:React.PropTypes.bool,
style:stylePropType,



testID:React.PropTypes.string,





onLayout:React.PropTypes.func},


viewConfig:viewConfig,

getInitialState:function(){
return merge(this.touchableGetInitialState(),{
isHighlighted:false});},



onStartShouldSetResponder:function(){
var shouldSetFromProps=this.props.onStartShouldSetResponder && 
this.props.onStartShouldSetResponder();
return shouldSetFromProps || !!this.props.onPress;},





handleResponderTerminationRequest:function(){


var allowTermination=this.touchableHandleResponderTerminationRequest();
if(allowTermination && this.props.onResponderTerminationRequest){
allowTermination = this.props.onResponderTerminationRequest();}

return allowTermination;},


handleResponderGrant:function(e,dispatchID){
this.touchableHandleResponderGrant(e,dispatchID);
this.props.onResponderGrant && 
this.props.onResponderGrant.apply(this,arguments);},


handleResponderMove:function(e){
this.touchableHandleResponderMove(e);
this.props.onResponderMove && 
this.props.onResponderMove.apply(this,arguments);},


handleResponderRelease:function(e){
this.touchableHandleResponderRelease(e);
this.props.onResponderRelease && 
this.props.onResponderRelease.apply(this,arguments);},


handleResponderTerminate:function(e){
this.touchableHandleResponderTerminate(e);
this.props.onResponderTerminate && 
this.props.onResponderTerminate.apply(this,arguments);},


touchableHandleActivePressIn:function(){
if(this.props.suppressHighlighting || !this.props.onPress){
return;}

this.setState({
isHighlighted:true});},



touchableHandleActivePressOut:function(){
if(this.props.suppressHighlighting || !this.props.onPress){
return;}

this.setState({
isHighlighted:false});},



touchableHandlePress:function(){
this.props.onPress && this.props.onPress();},


touchableGetPressRectOffset:function(){
return PRESS_RECT_OFFSET;},


getChildContext:function(){
return {isInAParentText:true};},


childContextTypes:{
isInAParentText:React.PropTypes.bool},


render:function(){
var props={};
for(var key in this.props) {
props[key] = this.props[key];}


if(props.accessible !== false){
props.accessible = true;}

props.isHighlighted = this.state.isHighlighted;
props.onStartShouldSetResponder = this.onStartShouldSetResponder;
props.onResponderTerminationRequest = 
this.handleResponderTerminationRequest;
props.onResponderGrant = this.handleResponderGrant;
props.onResponderMove = this.handleResponderMove;
props.onResponderRelease = this.handleResponderRelease;
props.onResponderTerminate = this.handleResponderTerminate;


var context=ReactInstanceMap.get(this)._context;
if(context.isInAParentText){
return React.createElement(RCTVirtualText,props);}else 
{
return React.createElement(RCTText,props);}}});











var PRESS_RECT_OFFSET={top:20,left:20,right:20,bottom:30};

var RCTText=createReactNativeComponentClass(viewConfig);
var RCTVirtualText=RCTText;

if(Platform.OS === 'android'){
RCTVirtualText = createReactNativeComponentClass({
validAttributes:merge(ReactNativeViewAttributes.UIView,{
isHighlighted:true}),

uiViewClassName:'RCTVirtualText'});}



module.exports = Text;
});
__d('Touchable',["BoundingDimensions","Position","TouchEventUtils","keyMirror","queryLayoutByID"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';





var BoundingDimensions=require('BoundingDimensions');
var Position=require('Position');
var TouchEventUtils=require('TouchEventUtils');

var keyMirror=require('keyMirror');
var queryLayoutByID=require('queryLayoutByID');

























































































var States=keyMirror({
NOT_RESPONDER:null,
RESPONDER_INACTIVE_PRESS_IN:null,
RESPONDER_INACTIVE_PRESS_OUT:null,
RESPONDER_ACTIVE_PRESS_IN:null,
RESPONDER_ACTIVE_PRESS_OUT:null,
RESPONDER_ACTIVE_LONG_PRESS_IN:null,
RESPONDER_ACTIVE_LONG_PRESS_OUT:null,
ERROR:null});





var IsActive={
RESPONDER_ACTIVE_PRESS_OUT:true,
RESPONDER_ACTIVE_PRESS_IN:true};






var IsPressingIn={
RESPONDER_INACTIVE_PRESS_IN:true,
RESPONDER_ACTIVE_PRESS_IN:true,
RESPONDER_ACTIVE_LONG_PRESS_IN:true};


var IsLongPressingIn={
RESPONDER_ACTIVE_LONG_PRESS_IN:true};





var Signals=keyMirror({
DELAY:null,
RESPONDER_GRANT:null,
RESPONDER_RELEASE:null,
RESPONDER_TERMINATED:null,
ENTER_PRESS_RECT:null,
LEAVE_PRESS_RECT:null,
LONG_PRESS_DETECTED:null});





var Transitions={
NOT_RESPONDER:{
DELAY:States.ERROR,
RESPONDER_GRANT:States.RESPONDER_INACTIVE_PRESS_IN,
RESPONDER_RELEASE:States.ERROR,
RESPONDER_TERMINATED:States.ERROR,
ENTER_PRESS_RECT:States.ERROR,
LEAVE_PRESS_RECT:States.ERROR,
LONG_PRESS_DETECTED:States.ERROR},

RESPONDER_INACTIVE_PRESS_IN:{
DELAY:States.RESPONDER_ACTIVE_PRESS_IN,
RESPONDER_GRANT:States.ERROR,
RESPONDER_RELEASE:States.NOT_RESPONDER,
RESPONDER_TERMINATED:States.NOT_RESPONDER,
ENTER_PRESS_RECT:States.RESPONDER_INACTIVE_PRESS_IN,
LEAVE_PRESS_RECT:States.RESPONDER_INACTIVE_PRESS_OUT,
LONG_PRESS_DETECTED:States.ERROR},

RESPONDER_INACTIVE_PRESS_OUT:{
DELAY:States.RESPONDER_ACTIVE_PRESS_OUT,
RESPONDER_GRANT:States.ERROR,
RESPONDER_RELEASE:States.NOT_RESPONDER,
RESPONDER_TERMINATED:States.NOT_RESPONDER,
ENTER_PRESS_RECT:States.RESPONDER_INACTIVE_PRESS_IN,
LEAVE_PRESS_RECT:States.RESPONDER_INACTIVE_PRESS_OUT,
LONG_PRESS_DETECTED:States.ERROR},

RESPONDER_ACTIVE_PRESS_IN:{
DELAY:States.ERROR,
RESPONDER_GRANT:States.ERROR,
RESPONDER_RELEASE:States.NOT_RESPONDER,
RESPONDER_TERMINATED:States.NOT_RESPONDER,
ENTER_PRESS_RECT:States.RESPONDER_ACTIVE_PRESS_IN,
LEAVE_PRESS_RECT:States.RESPONDER_ACTIVE_PRESS_OUT,
LONG_PRESS_DETECTED:States.RESPONDER_ACTIVE_LONG_PRESS_IN},

RESPONDER_ACTIVE_PRESS_OUT:{
DELAY:States.ERROR,
RESPONDER_GRANT:States.ERROR,
RESPONDER_RELEASE:States.NOT_RESPONDER,
RESPONDER_TERMINATED:States.NOT_RESPONDER,
ENTER_PRESS_RECT:States.RESPONDER_ACTIVE_PRESS_IN,
LEAVE_PRESS_RECT:States.RESPONDER_ACTIVE_PRESS_OUT,
LONG_PRESS_DETECTED:States.ERROR},

RESPONDER_ACTIVE_LONG_PRESS_IN:{
DELAY:States.ERROR,
RESPONDER_GRANT:States.ERROR,
RESPONDER_RELEASE:States.NOT_RESPONDER,
RESPONDER_TERMINATED:States.NOT_RESPONDER,
ENTER_PRESS_RECT:States.RESPONDER_ACTIVE_LONG_PRESS_IN,
LEAVE_PRESS_RECT:States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
LONG_PRESS_DETECTED:States.RESPONDER_ACTIVE_LONG_PRESS_IN},

RESPONDER_ACTIVE_LONG_PRESS_OUT:{
DELAY:States.ERROR,
RESPONDER_GRANT:States.ERROR,
RESPONDER_RELEASE:States.NOT_RESPONDER,
RESPONDER_TERMINATED:States.NOT_RESPONDER,
ENTER_PRESS_RECT:States.RESPONDER_ACTIVE_LONG_PRESS_IN,
LEAVE_PRESS_RECT:States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
LONG_PRESS_DETECTED:States.ERROR},

error:{
DELAY:States.NOT_RESPONDER,
RESPONDER_GRANT:States.RESPONDER_INACTIVE_PRESS_IN,
RESPONDER_RELEASE:States.NOT_RESPONDER,
RESPONDER_TERMINATED:States.NOT_RESPONDER,
ENTER_PRESS_RECT:States.NOT_RESPONDER,
LEAVE_PRESS_RECT:States.NOT_RESPONDER,
LONG_PRESS_DETECTED:States.NOT_RESPONDER}};






var HIGHLIGHT_DELAY_MS=130;

var PRESS_EXPAND_PX=20;

var LONG_PRESS_THRESHOLD=500;

var LONG_PRESS_DELAY_MS=LONG_PRESS_THRESHOLD - HIGHLIGHT_DELAY_MS;

var LONG_PRESS_ALLOWED_MOVEMENT=10;



































































var TouchableMixin={







touchableGetInitialState:function(){
return {
touchable:{touchState:undefined,responderID:null}};},







touchableHandleResponderTerminationRequest:function(){
return !this.props.rejectResponderTermination;},





touchableHandleStartShouldSetResponder:function(){
return true;},





touchableLongPressCancelsPress:function(){
return true;},








touchableHandleResponderGrant:function(e,dispatchID){



e.persist();

this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
this.pressOutDelayTimeout = null;

this.state.touchable.touchState = States.NOT_RESPONDER;
this.state.touchable.responderID = dispatchID;
this._receiveSignal(Signals.RESPONDER_GRANT,e);
var delayMS=
this.touchableGetHighlightDelayMS !== undefined?
Math.max(this.touchableGetHighlightDelayMS(),0):HIGHLIGHT_DELAY_MS;
delayMS = isNaN(delayMS)?HIGHLIGHT_DELAY_MS:delayMS;
if(delayMS !== 0){
this.touchableDelayTimeout = setTimeout(
this._handleDelay.bind(this,e),
delayMS);}else 

{
this._handleDelay(e);}


var longDelayMS=
this.touchableGetLongPressDelayMS !== undefined?
Math.max(this.touchableGetLongPressDelayMS(),10):LONG_PRESS_DELAY_MS;
longDelayMS = isNaN(longDelayMS)?LONG_PRESS_DELAY_MS:longDelayMS;
this.longPressDelayTimeout = setTimeout(
this._handleLongDelay.bind(this,e),
longDelayMS + delayMS);},






touchableHandleResponderRelease:function(e){
this._receiveSignal(Signals.RESPONDER_RELEASE,e);},





touchableHandleResponderTerminate:function(e){
this._receiveSignal(Signals.RESPONDER_TERMINATED,e);},





touchableHandleResponderMove:function(e){


if(this.state.touchable.touchState === States.RESPONDER_INACTIVE_PRESS_IN){
return;}



if(!this.state.touchable.positionOnActivate){
return;}


var positionOnActivate=this.state.touchable.positionOnActivate;
var dimensionsOnActivate=this.state.touchable.dimensionsOnActivate;
var pressRectOffset=this.touchableGetPressRectOffset?
this.touchableGetPressRectOffset():null;
var pressExpandLeft=
pressRectOffset.left != null?pressRectOffset.left:PRESS_EXPAND_PX;
var pressExpandTop=
pressRectOffset.top != null?pressRectOffset.top:PRESS_EXPAND_PX;
var pressExpandRight=
pressRectOffset.right != null?pressRectOffset.right:PRESS_EXPAND_PX;
var pressExpandBottom=
pressRectOffset.bottom != null?pressRectOffset.bottom:PRESS_EXPAND_PX;

var touch=TouchEventUtils.extractSingleTouch(e.nativeEvent);
var pageX=touch && touch.pageX;
var pageY=touch && touch.pageY;

if(this.pressInLocation){
var movedDistance=this._getDistanceBetweenPoints(pageX,pageY,this.pressInLocation.pageX,this.pressInLocation.pageY);
if(movedDistance > LONG_PRESS_ALLOWED_MOVEMENT){
this._cancelLongPressDelayTimeout();}}



var isTouchWithinActive=
pageX > positionOnActivate.left - pressExpandLeft && 
pageY > positionOnActivate.top - pressExpandTop && 
pageX < 
positionOnActivate.left + 
dimensionsOnActivate.width + 
pressExpandRight && 
pageY < 
positionOnActivate.top + 
dimensionsOnActivate.height + 
pressExpandBottom;
if(isTouchWithinActive){
this._receiveSignal(Signals.ENTER_PRESS_RECT,e);}else 
{
this._cancelLongPressDelayTimeout();
this._receiveSignal(Signals.LEAVE_PRESS_RECT,e);}},

















































































_remeasureMetricsOnActivation:function(){
queryLayoutByID(
this.state.touchable.responderID,
null,
this._handleQueryLayout);},



_handleQueryLayout:function(l,t,w,h,globalX,globalY){
this.state.touchable.positionOnActivate && 
Position.release(this.state.touchable.positionOnActivate);
this.state.touchable.dimensionsOnActivate && 
BoundingDimensions.release(this.state.touchable.dimensionsOnActivate);
this.state.touchable.positionOnActivate = Position.getPooled(globalX,globalY);
this.state.touchable.dimensionsOnActivate = BoundingDimensions.getPooled(w,h);},


_handleDelay:function(e){
this.touchableDelayTimeout = null;
this._receiveSignal(Signals.DELAY,e);},


_handleLongDelay:function(e){
this.longPressDelayTimeout = null;
this._receiveSignal(Signals.LONG_PRESS_DETECTED,e);},










_receiveSignal:function(signal,e){
var curState=this.state.touchable.touchState;
if(!(Transitions[curState] && Transitions[curState][signal])){
throw new Error(
'Unrecognized signal `' + signal + '` or state `' + curState + 
'` for Touchable responder `' + this.state.touchable.responderID + '`');}


var nextState=Transitions[curState][signal];
if(nextState === States.ERROR){
throw new Error(
'Touchable cannot transition from `' + curState + '` to `' + signal + 
'` for responder `' + this.state.touchable.responderID + '`');}


if(curState !== nextState){
this._performSideEffectsForTransition(curState,nextState,signal,e);
this.state.touchable.touchState = nextState;}},



_cancelLongPressDelayTimeout:function(){
this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
this.longPressDelayTimeout = null;},


_isHighlight:function(state){
return state === States.RESPONDER_ACTIVE_PRESS_IN || 
state === States.RESPONDER_ACTIVE_LONG_PRESS_IN;},


_savePressInLocation:function(e){
var touch=TouchEventUtils.extractSingleTouch(e.nativeEvent);
var pageX=touch && touch.pageX;
var pageY=touch && touch.pageY;
this.pressInLocation = {pageX:pageX,pageY:pageY};},


_getDistanceBetweenPoints:function(aX,aY,bX,bY){
var deltaX=aX - bX;
var deltaY=aY - bY;
return Math.sqrt(deltaX * deltaX + deltaY * deltaY);},













_performSideEffectsForTransition:function(curState,nextState,signal,e){
var curIsHighlight=this._isHighlight(curState);
var newIsHighlight=this._isHighlight(nextState);

var isFinalSignal=
signal === Signals.RESPONDER_TERMINATED || 
signal === Signals.RESPONDER_RELEASE;

if(isFinalSignal){
this._cancelLongPressDelayTimeout();}


if(!IsActive[curState] && IsActive[nextState]){
this._remeasureMetricsOnActivation();}


if(IsPressingIn[curState] && signal === Signals.LONG_PRESS_DETECTED){
this.touchableHandleLongPress && this.touchableHandleLongPress();}


if(newIsHighlight && !curIsHighlight){
this._savePressInLocation(e);
this.touchableHandleActivePressIn && this.touchableHandleActivePressIn();}else 
if(!newIsHighlight && curIsHighlight && this.touchableHandleActivePressOut){
if(this.touchableGetPressOutDelayMS && this.touchableGetPressOutDelayMS()){
this.pressOutDelayTimeout = this.setTimeout(function(){
this.touchableHandleActivePressOut();},
this.touchableGetPressOutDelayMS());}else 
{
this.touchableHandleActivePressOut();}}



if(IsPressingIn[curState] && signal === Signals.RESPONDER_RELEASE){
var hasLongPressHandler=!!this.props.onLongPress;
var pressIsLongButStillCallOnPress=
IsLongPressingIn[curState] && (
!hasLongPressHandler || 
!this.touchableLongPressCancelsPress());


var shouldInvokePress=!IsLongPressingIn[curState] || pressIsLongButStillCallOnPress;
if(shouldInvokePress && this.touchableHandlePress){
this.touchableHandlePress(e);}}



this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
this.touchableDelayTimeout = null;}};




var Touchable={
Mixin:TouchableMixin};


module.exports = Touchable;
});
__d('BoundingDimensions',["PooledClass"],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";





var PooledClass=require("PooledClass");

var twoArgumentPooler=PooledClass.twoArgumentPooler;








function BoundingDimensions(width,height){
this.width = width;
this.height = height;}






BoundingDimensions.getPooledFromElement = function(element){
return BoundingDimensions.getPooled(
element.offsetWidth,
element.offsetHeight);};



PooledClass.addPoolingTo(BoundingDimensions,twoArgumentPooler);

module.exports = BoundingDimensions;
});
__d('Position',["PooledClass"],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";





var PooledClass=require("PooledClass");

var twoArgumentPooler=PooledClass.twoArgumentPooler;









function Position(left,top){
this.left = left;
this.top = top;}


PooledClass.addPoolingTo(Position,twoArgumentPooler);

module.exports = Position;
});
__d('TouchEventUtils',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var 










TouchEventUtils={










extractSingleTouch:function(nativeEvent){
var touches=nativeEvent.touches;
var changedTouches=nativeEvent.changedTouches;
var hasTouches=touches && touches.length > 0;
var hasChangedTouches=changedTouches && changedTouches.length > 0;

return !hasTouches && hasChangedTouches?changedTouches[0]:
hasTouches?touches[0]:
nativeEvent;}};



module.exports = TouchEventUtils;
});
__d('queryLayoutByID',["ReactNativeTagHandles","NativeModules"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactNativeTagHandles=require('ReactNativeTagHandles');
var RCTUIManager=require('NativeModules').UIManager;
































var queryLayoutByID=function(
rootNodeID,
onError,
onSuccess)
{

RCTUIManager.measure(
ReactNativeTagHandles.rootNodeIDToTag[rootNodeID],
onSuccess);};



module.exports = queryLayoutByID;
});
__d('TextInput',["DocumentSelectionState","EventEmitter","NativeMethodsMixin","NativeModules","Platform","ReactPropTypes","React","ReactChildren","StyleSheet","Text","TextInputState","TouchableWithoutFeedback","createReactNativeComponentClass","emptyFunction","invariant","requireNativeComponent","react-timer-mixin/TimerMixin.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var DocumentSelectionState=require('DocumentSelectionState');
var EventEmitter=require('EventEmitter');
var NativeMethodsMixin=require('NativeMethodsMixin');
var RCTUIManager=require('NativeModules').UIManager;
var Platform=require('Platform');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var ReactChildren=require('ReactChildren');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var TextInputState=require('TextInputState');
var TimerMixin=require('react-timer-mixin/TimerMixin.js');
var TouchableWithoutFeedback=require('TouchableWithoutFeedback');

var createReactNativeComponentClass=require('createReactNativeComponentClass');
var emptyFunction=require('emptyFunction');
var invariant=require('invariant');
var requireNativeComponent=require('requireNativeComponent');

var onlyMultiline={
onSelectionChange:true,
onTextInput:true,
children:true};


var notMultiline={
onSubmitEditing:true};


var AndroidTextInputAttributes={
autoCapitalize:true,
autoCorrect:true,
autoFocus:true,
textAlign:true,
textAlignVertical:true,
keyboardType:true,
multiline:true,
password:true,
placeholder:true,
placeholderTextColor:true,
text:true,
testID:true,
underlineColorAndroid:true};


var viewConfigAndroid={
uiViewClassName:'AndroidTextInput',
validAttributes:AndroidTextInputAttributes};


var RCTTextView=requireNativeComponent('RCTTextView',null);
var RCTTextField=requireNativeComponent('RCTTextField',null);








































var TextInput=React.createClass({displayName:'TextInput',
propTypes:{








autoCapitalize:PropTypes.oneOf([
'none',
'sentences',
'words',
'characters']),




autoCorrect:PropTypes.bool,



autoFocus:PropTypes.bool,



textAlign:PropTypes.oneOf([
'start',
'center',
'end']),

textAlignVertical:PropTypes.oneOf([
'top',
'center',
'bottom']),




editable:PropTypes.bool,



keyboardType:PropTypes.oneOf([

'default',
'numeric',
'email-address',

'ascii-capable',
'numbers-and-punctuation',
'url',
'number-pad',
'phone-pad',
'name-phone-pad',
'decimal-pad',
'twitter',
'web-search']),




returnKeyType:PropTypes.oneOf([
'default',
'go',
'google',
'join',
'next',
'route',
'search',
'send',
'yahoo',
'done',
'emergency-call']),





enablesReturnKeyAutomatically:PropTypes.bool,



multiline:PropTypes.bool,



onBlur:PropTypes.func,



onFocus:PropTypes.func,



onChange:PropTypes.func,




onChangeText:PropTypes.func,



onEndEditing:PropTypes.func,



onSubmitEditing:PropTypes.func,



onLayout:PropTypes.func,




password:PropTypes.bool,



placeholder:PropTypes.string,



placeholderTextColor:PropTypes.string,




selectionState:PropTypes.instanceOf(DocumentSelectionState),



value:PropTypes.string,






bufferDelay:PropTypes.number,





controlled:PropTypes.bool,



clearButtonMode:PropTypes.oneOf([
'never',
'while-editing',
'unless-editing',
'always']),




clearTextOnFocus:PropTypes.bool,



selectTextOnFocus:PropTypes.bool,



style:Text.propTypes.style,



testID:PropTypes.string,



underlineColorAndroid:PropTypes.string},






mixins:[NativeMethodsMixin,TimerMixin],

viewConfig:Platform.OS === 'ios'?RCTTextField.viewConfig:
Platform.OS === 'android'?viewConfigAndroid:{},

isFocused:function(){
return TextInputState.currentlyFocusedField() === 
React.findNodeHandle(this.refs.input);},


getDefaultProps:function(){
return {
bufferDelay:100};},



getInitialState:function(){
return {
mostRecentEventCounter:0,
bufferedValue:this.props.value};},



contextTypes:{
onFocusRequested:React.PropTypes.func,
focusEmitter:React.PropTypes.instanceOf(EventEmitter)},


_focusSubscription:undefined,

componentDidMount:function(){var _this=this;
if(!this.context.focusEmitter){
if(this.props.autoFocus){
this.requestAnimationFrame(this.focus);}

return;}

this._focusSubscription = this.context.focusEmitter.addListener(
'focus',
function(el){
if(_this === el){
_this.requestAnimationFrame(_this.focus);}else 
if(_this.isFocused()){
_this.blur();}});



if(this.props.autoFocus){
this.context.onFocusRequested(this);}},



componentWillUnmount:function(){
this._focusSubscription && this._focusSubscription.remove();
if(this.isFocused()){
this.blur();}},



_bufferTimeout:undefined,

componentWillReceiveProps:function(newProps){var _this2=this;
if(newProps.value !== this.props.value){
if(!this.isFocused()){


this.setState({bufferedValue:newProps.value});}else 
{




























this.clearTimeout(this._bufferTimeout);
this._bufferTimeout = this.setTimeout(
function(){return _this2.setState({bufferedValue:newProps.value});},
this.props.bufferDelay);}}},





getChildContext:function(){
return {isInAParentText:true};},


childContextTypes:{
isInAParentText:React.PropTypes.bool},


render:function(){
if(Platform.OS === 'ios'){
return this._renderIOS();}else 
if(Platform.OS === 'android'){
return this._renderAndroid();}},



_renderIOS:function(){
var textContainer;

var props=this.props;
props.style = [styles.input,this.props.style];

if(!props.multiline){
for(var propKey in onlyMultiline) {
if(props[propKey]){
throw new Error(
'TextInput prop `' + propKey + '` is only supported with multiline.');}}



textContainer = 
React.createElement(RCTTextField,_extends({
ref:'input'},
props,{
onFocus:this._onFocus,
onBlur:this._onBlur,
onChange:this._onChange,
onSelectionChangeShouldSetResponder:function(){return true;},
text:this.state.bufferedValue}));}else 

{
for(var propKey in notMultiline) {
if(props[propKey]){
throw new Error(
'TextInput prop `' + propKey + '` cannot be used with multiline.');}}




var children=props.children;
var childCount=0;
ReactChildren.forEach(children,function(){return ++childCount;});
invariant(
!(props.value && childCount),
'Cannot specify both value and children.');

if(childCount > 1){
children = React.createElement(Text,null,children);}

if(props.inputView){
children = [children,props.inputView];}

textContainer = 
React.createElement(RCTTextView,_extends({
ref:'input'},
props,{
children:children,
mostRecentEventCounter:this.state.mostRecentEventCounter,
onFocus:this._onFocus,
onBlur:this._onBlur,
onChange:this._onChange,
onSelectionChange:this._onSelectionChange,
onTextInput:this._onTextInput,
onSelectionChangeShouldSetResponder:emptyFunction.thatReturnsTrue,
text:this.state.bufferedValue}));}



return (
React.createElement(TouchableWithoutFeedback,{
onPress:this._onPress,
rejectResponderTermination:true,
testID:props.testID},
textContainer));},




_renderAndroid:function(){
var autoCapitalize=RCTUIManager.UIText.AutocapitalizationType[this.props.autoCapitalize];
var textAlign=
RCTUIManager.AndroidTextInput.Constants.TextAlign[this.props.textAlign];
var textAlignVertical=
RCTUIManager.AndroidTextInput.Constants.TextAlignVertical[this.props.textAlignVertical];
var children=this.props.children;
var childCount=0;
ReactChildren.forEach(children,function(){return ++childCount;});
invariant(
!(this.props.value && childCount),
'Cannot specify both value and children.');

if(childCount > 1){
children = React.createElement(Text,null,children);}

var textContainer=
React.createElement(AndroidTextInput,{
ref:'input',
style:[this.props.style],
autoCapitalize:autoCapitalize,
autoCorrect:this.props.autoCorrect,
textAlign:textAlign,
textAlignVertical:textAlignVertical,
keyboardType:this.props.keyboardType,
multiline:this.props.multiline,
onFocus:this._onFocus,
onBlur:this._onBlur,
onChange:this._onChange,
onTextInput:this._onTextInput,
onEndEditing:this.props.onEndEditing,
onSubmitEditing:this.props.onSubmitEditing,
onLayout:this.props.onLayout,
password:this.props.password || this.props.secureTextEntry,
placeholder:this.props.placeholder,
placeholderTextColor:this.props.placeholderTextColor,
text:this.state.bufferedValue,
underlineColorAndroid:this.props.underlineColorAndroid,
children:children});


return (
React.createElement(TouchableWithoutFeedback,{
onPress:this._onPress,
testID:this.props.testID},
textContainer));},




_onFocus:function(event){
if(this.props.onFocus){
this.props.onFocus(event);}},



_onPress:function(event){
this.focus();},


_onChange:function(event){
if(this.props.controlled && event.nativeEvent.text !== this.props.value){
this.refs.input.setNativeProps({text:this.props.value});}

this.props.onChange && this.props.onChange(event);
this.props.onChangeText && this.props.onChangeText(event.nativeEvent.text);},


_onBlur:function(event){
this.blur();
if(this.props.onBlur){
this.props.onBlur(event);}},



_onSelectionChange:function(event){
if(this.props.selectionState){
var selection=event.nativeEvent.selection;
this.props.selectionState.update(selection.start,selection.end);}

this.props.onSelectionChange && this.props.onSelectionChange(event);},


_onTextInput:function(event){
this.props.onTextInput && this.props.onTextInput(event);
var counter=event.nativeEvent.eventCounter;
if(counter > this.state.mostRecentEventCounter){
this.setState({mostRecentEventCounter:counter});}}});




var styles=StyleSheet.create({
input:{
alignSelf:'stretch'}});



var AndroidTextInput=createReactNativeComponentClass({
validAttributes:AndroidTextInputAttributes,
uiViewClassName:'AndroidTextInput'});


module.exports = TextInput;
});
__d('DocumentSelectionState',["mixInEventEmitter"],function(global, require, requireDynamic, requireLazy, module, exports) {  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');}}

















var mixInEventEmitter=require('mixInEventEmitter');var 










DocumentSelectionState=(function(){




function DocumentSelectionState(anchor,focus){_classCallCheck(this,DocumentSelectionState);
this._anchorOffset = anchor;
this._focusOffset = focus;
this._hasFocus = false;}_createClass(DocumentSelectionState,[{key:'update',value:









function update(anchor,focus){
if(this._anchorOffset !== anchor || this._focusOffset !== focus){
this._anchorOffset = anchor;
this._focusOffset = focus;
this.emit('update');}}},{key:'constrainLength',value:









function constrainLength(maxLength){
this.update(
Math.min(this._anchorOffset,maxLength),
Math.min(this._focusOffset,maxLength));}},{key:'focus',value:



function focus(){
if(!this._hasFocus){
this._hasFocus = true;
this.emit('focus');}}},{key:'blur',value:



function blur(){
if(this._hasFocus){
this._hasFocus = false;
this.emit('blur');}}},{key:'hasFocus',value:






function hasFocus(){
return this._hasFocus;}},{key:'isCollapsed',value:





function isCollapsed(){
return this._anchorOffset === this._focusOffset;}},{key:'isBackward',value:





function isBackward(){
return this._anchorOffset > this._focusOffset;}},{key:'getAnchorOffset',value:





function getAnchorOffset(){
return this._hasFocus?this._anchorOffset:null;}},{key:'getFocusOffset',value:





function getFocusOffset(){
return this._hasFocus?this._focusOffset:null;}},{key:'getStartOffset',value:





function getStartOffset(){
return (
this._hasFocus?Math.min(this._anchorOffset,this._focusOffset):null);}},{key:'getEndOffset',value:






function getEndOffset(){
return (
this._hasFocus?Math.max(this._anchorOffset,this._focusOffset):null);}},{key:'overlaps',value:








function overlaps(start,end){
return (
this.hasFocus() && 
this.getStartOffset() <= end && start <= this.getEndOffset());}}]);return DocumentSelectionState;})();




mixInEventEmitter(DocumentSelectionState,{
'blur':true,
'focus':true,
'update':true});


module.exports = DocumentSelectionState;
});
__d('mixInEventEmitter',["EventEmitter","EventEmitterWithHolding","EventHolder","EventValidator","copyProperties","invariant","keyOf"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 
















EventEmitter=require('EventEmitter');
var EventEmitterWithHolding=require('EventEmitterWithHolding');
var EventHolder=require('EventHolder');
var EventValidator=require('EventValidator');

var copyProperties=require('copyProperties');
var invariant=require('invariant');
var keyOf=require('keyOf');

var TYPES_KEY=keyOf({__types:true});






















function mixInEventEmitter(klass,types){
invariant(types,'Must supply set of valid event types');
invariant(!this.__eventEmitter,'An active emitter is already mixed in');



var target=klass.prototype || klass;

var ctor=klass.constructor;
if(ctor){
invariant(
ctor === Object || ctor === Function,
'Mix EventEmitter into a class, not an instance');}





if(target.hasOwnProperty(TYPES_KEY)){
copyProperties(target.__types,types);}else 
if(target.__types){
target.__types = copyProperties({},target.__types,types);}else 
{
target.__types = types;}

copyProperties(target,EventEmitterMixin);}


var EventEmitterMixin={
emit:function(eventType,a,b,c,d,e,_){
return this.__getEventEmitter().emit(eventType,a,b,c,d,e,_);},


emitAndHold:function(eventType,a,b,c,d,e,_){
return this.__getEventEmitter().emitAndHold(eventType,a,b,c,d,e,_);},


addListener:function(eventType,listener,context){
return this.__getEventEmitter().addListener(eventType,listener,context);},


once:function(eventType,listener,context){
return this.__getEventEmitter().once(eventType,listener,context);},


addRetroactiveListener:function(eventType,listener,context){
return this.__getEventEmitter().addRetroactiveListener(
eventType,
listener,
context);},



addListenerMap:function(listenerMap,context){
return this.__getEventEmitter().addListenerMap(listenerMap,context);},


addRetroactiveListenerMap:function(listenerMap,context){
return this.__getEventEmitter().addListenerMap(listenerMap,context);},


removeAllListeners:function(){
this.__getEventEmitter().removeAllListeners();},


removeCurrentListener:function(){
this.__getEventEmitter().removeCurrentListener();},


releaseHeldEventType:function(eventType){
this.__getEventEmitter().releaseHeldEventType(eventType);},


__getEventEmitter:function(){
if(!this.__eventEmitter){
var emitter=new EventEmitter();
emitter = EventValidator.addValidation(emitter,this.__types);

var holder=new EventHolder();
this.__eventEmitter = new EventEmitterWithHolding(emitter,holder);}

return this.__eventEmitter;}};



module.exports = mixInEventEmitter;
});
__d('EventEmitterWithHolding',[],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}var 






























EventEmitterWithHolding=(function(){







function EventEmitterWithHolding(emitter,holder){_classCallCheck(this,EventEmitterWithHolding);
this._emitter = emitter;
this._eventHolder = holder;
this._currentEventToken = null;
this._emittingHeldEvents = false;}_createClass(EventEmitterWithHolding,[{key:'addListener',value:





function addListener(eventType,listener,context){
return this._emitter.addListener(eventType,listener,context);}},{key:'once',value:





function once(eventType,listener,context){
return this._emitter.once(eventType,listener,context);}},{key:'addRetroactiveListener',value:






















function addRetroactiveListener(
eventType,listener,context){
var subscription=this._emitter.addListener(eventType,listener,context);

this._emittingHeldEvents = true;
this._eventHolder.emitToListener(eventType,listener,context);
this._emittingHeldEvents = false;

return subscription;}},{key:'removeAllListeners',value:





function removeAllListeners(eventType){
this._emitter.removeAllListeners(eventType);}},{key:'removeCurrentListener',value:





function removeCurrentListener(){
this._emitter.removeCurrentListener();}},{key:'listeners',value:





function listeners(eventType){
return this._emitter.listeners(eventType);}},{key:'emit',value:





function emit(eventType,a,b,c,d,e,_){
this._emitter.emit(eventType,a,b,c,d,e,_);}},{key:'emitAndHold',value:

















function emitAndHold(eventType,a,b,c,d,e,_){
this._currentEventToken = this._eventHolder.holdEvent(
eventType,
a,b,c,d,e,_);

this._emitter.emit(eventType,a,b,c,d,e,_);
this._currentEventToken = null;}},{key:'releaseCurrentEvent',value:





function releaseCurrentEvent(){
if(this._currentEventToken !== null){
this._eventHolder.releaseEvent(this._currentEventToken);}else 
if(this._emittingHeldEvents){
this._eventHolder.releaseCurrentEvent();}}},{key:'releaseHeldEventType',value:







function releaseHeldEventType(eventType){
this._eventHolder.releaseEventType(eventType);}}]);return EventEmitterWithHolding;})();



module.exports = EventEmitterWithHolding;
});
__d('EventHolder',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}


















var invariant=require('invariant');var 

EventHolder=(function(){
function EventHolder(){_classCallCheck(this,EventHolder);
this._heldEvents = {};
this._currentEventKey = null;}_createClass(EventHolder,[{key:'holdEvent',value:























function holdEvent(eventType,a,b,c,d,e,_){
this._heldEvents[eventType] = this._heldEvents[eventType] || [];
var eventsOfType=this._heldEvents[eventType];
var key={
eventType:eventType,
index:eventsOfType.length};

eventsOfType.push([a,b,c,d,e,_]);
return key;}},{key:'emitToListener',value:










function emitToListener(eventType,listener,context){var _this=this;
var eventsOfType=this._heldEvents[eventType];
if(!eventsOfType){
return;}

var origEventKey=this._currentEventKey;
eventsOfType.forEach(function(eventHeld,index){
if(!eventHeld){
return;}

_this._currentEventKey = {
eventType:eventType,
index:index};

listener.apply(context,eventHeld);});

this._currentEventKey = origEventKey;}},{key:'releaseCurrentEvent',value:










function releaseCurrentEvent(){
invariant(
this._currentEventKey !== null,
'Not in an emitting cycle; there is no current event');

this.releaseEvent(this._currentEventKey);}},{key:'releaseEvent',value:








function releaseEvent(token){
delete this._heldEvents[token.eventType][token.index];}},{key:'releaseEventType',value:







function releaseEventType(type){
this._heldEvents[type] = [];}}]);return EventHolder;})();



module.exports = EventHolder;
});
__d('EventValidator',["copyProperties"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

















var copyProperties=require('copyProperties');










var EventValidator={










addValidation:function(emitter,types){
var eventTypes=Object.keys(types);
var emitterWithValidation=Object.create(emitter);

copyProperties(emitterWithValidation,{
emit:function emit(type,a,b,c,d,e,_){
assertAllowsEventType(type,eventTypes);
return emitter.emit.call(this,type,a,b,c,d,e,_);}});



return emitterWithValidation;}};



function assertAllowsEventType(type,allowedTypes){
if(allowedTypes.indexOf(type) === -1){
throw new TypeError(errorMessageFor(type,allowedTypes));}}



function errorMessageFor(type,allowedTypes){
var message='Unknown event type "' + type + '". ';
if(__DEV__){
message += recommendationFor(type,allowedTypes);}

message += 'Known event types: ' + allowedTypes.join(', ') + '.';
return message;}



if(__DEV__){
var recommendationFor=function(type,allowedTypes){
var closestTypeRecommendation=closestTypeFor(type,allowedTypes);
if(isCloseEnough(closestTypeRecommendation,type)){
return 'Did you mean "' + closestTypeRecommendation.type + '"? ';}else 
{
return '';}};



var closestTypeFor=function(type,allowedTypes){
var typeRecommendations=allowedTypes.map(
typeRecommendationFor.bind(this,type));

return typeRecommendations.sort(recommendationSort)[0];};


var typeRecommendationFor=function(type,recomendedType){
return {
type:recomendedType,
distance:damerauLevenshteinDistance(type,recomendedType)};};



var recommendationSort=function(recommendationA,recommendationB){
if(recommendationA.distance < recommendationB.distance){
return -1;}else 
if(recommendationA.distance > recommendationB.distance){
return 1;}else 
{
return 0;}};



var isCloseEnough=function(closestType,actualType){
return closestType.distance / actualType.length < 0.334;};


var damerauLevenshteinDistance=function(a,b){
var i,j;
var d=[];

for(i = 0;i <= a.length;i++) {
d[i] = [i];}


for(j = 1;j <= b.length;j++) {
d[0][j] = j;}


for(i = 1;i <= a.length;i++) {
for(j = 1;j <= b.length;j++) {
var cost=a.charAt(i - 1) === b.charAt(j - 1)?0:1;

d[i][j] = Math.min(
d[i - 1][j] + 1,
d[i][j - 1] + 1,
d[i - 1][j - 1] + cost);


if(i > 1 && j > 1 && 
a.charAt(i - 1) == b.charAt(j - 2) && 
a.charAt(i - 2) == b.charAt(j - 1)){
d[i][j] = Math.min(d[i][j],d[i - 2][j - 2] + cost);}}}




return d[a.length][b.length];};}



module.exports = EventValidator;
});
__d('copyProperties',[],function(global, require, requireDynamic, requireLazy, module, exports) {  function 























copyProperties(obj,a,b,c,d,e,f){
obj = obj || {};

if(__DEV__){
if(f){
throw new Error('Too many arguments passed to copyProperties');}}



var args=[a,b,c,d,e];
var ii=0,v;
while(args[ii]) {
v = args[ii++];
for(var k in v) {
obj[k] = v[k];}




if(v.hasOwnProperty && v.hasOwnProperty('toString') && 
typeof v.toString != 'undefined' && obj.toString !== v.toString){
obj.toString = v.toString;}}



return obj;}


module.exports = copyProperties;
});
__d('TouchableWithoutFeedback',["React","Touchable","ensurePositiveDelayProps","onlyChild","react-timer-mixin/TimerMixin.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var React=require('React');
var TimerMixin=require('react-timer-mixin/TimerMixin.js');
var Touchable=require('Touchable');
var ensurePositiveDelayProps=require('ensurePositiveDelayProps');
var onlyChild=require('onlyChild');







var PRESS_RECT_OFFSET={top:20,left:20,right:20,bottom:30};








var TouchableWithoutFeedback=React.createClass({displayName:'TouchableWithoutFeedback',
mixins:[TimerMixin,Touchable.Mixin],

propTypes:{




accessible:React.PropTypes.bool,
onPress:React.PropTypes.func,
onPressIn:React.PropTypes.func,
onPressOut:React.PropTypes.func,
onLongPress:React.PropTypes.func,



delayPressIn:React.PropTypes.number,



delayPressOut:React.PropTypes.number,



delayLongPress:React.PropTypes.number},


getInitialState:function(){
return this.touchableGetInitialState();},


componentDidMount:function(){
ensurePositiveDelayProps(this.props);},


componentWillReceiveProps:function(nextProps){
ensurePositiveDelayProps(nextProps);},






touchableHandlePress:function(e){
this.props.onPress && this.props.onPress(e);},


touchableHandleActivePressIn:function(){
this.props.onPressIn && this.props.onPressIn();},


touchableHandleActivePressOut:function(){
this.props.onPressOut && this.props.onPressOut();},


touchableHandleLongPress:function(){
this.props.onLongPress && this.props.onLongPress();},


touchableGetPressRectOffset:function(){
return PRESS_RECT_OFFSET;},


touchableGetHighlightDelayMS:function(){
return this.props.delayPressIn || 0;},


touchableGetLongPressDelayMS:function(){
return this.props.delayLongPress === 0?0:
this.props.delayLongPress || 500;},


touchableGetPressOutDelayMS:function(){
return this.props.delayPressOut || 0;},


render:function(){

return React.cloneElement(onlyChild(this.props.children),{
accessible:this.props.accessible !== false,
testID:this.props.testID,
onStartShouldSetResponder:this.touchableHandleStartShouldSetResponder,
onResponderTerminationRequest:this.touchableHandleResponderTerminationRequest,
onResponderGrant:this.touchableHandleResponderGrant,
onResponderMove:this.touchableHandleResponderMove,
onResponderRelease:this.touchableHandleResponderRelease,
onResponderTerminate:this.touchableHandleResponderTerminate});}});




module.exports = TouchableWithoutFeedback;
});
__d('ensurePositiveDelayProps',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');

var ensurePositiveDelayProps=function(props){
invariant(
!(props.delayPressIn < 0 || props.delayPressOut < 0 || 
props.delayLongPress < 0),
'Touchable components cannot have negative delay properties');};



module.exports = ensurePositiveDelayProps;
});
__d('TouchableHighlight',["NativeMethodsMixin","React","ReactNativeViewAttributes","StyleSheet","Touchable","TouchableWithoutFeedback","View","cloneWithProps","ensureComponentIsNative","ensurePositiveDelayProps","keyOf","merge","onlyChild","react-timer-mixin/TimerMixin.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};













var NativeMethodsMixin=require('NativeMethodsMixin');
var React=require('React');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var StyleSheet=require('StyleSheet');
var TimerMixin=require('react-timer-mixin/TimerMixin.js');
var Touchable=require('Touchable');
var TouchableWithoutFeedback=require('TouchableWithoutFeedback');
var View=require('View');

var cloneWithProps=require('cloneWithProps');
var ensureComponentIsNative=require('ensureComponentIsNative');
var ensurePositiveDelayProps=require('ensurePositiveDelayProps');
var keyOf=require('keyOf');
var merge=require('merge');
var onlyChild=require('onlyChild');

var DEFAULT_PROPS={
activeOpacity:0.8,
underlayColor:'black'};


























var TouchableHighlight=React.createClass({displayName:'TouchableHighlight',
propTypes:_extends({},
TouchableWithoutFeedback.propTypes,{




activeOpacity:React.PropTypes.number,




underlayColor:React.PropTypes.string,
style:View.propTypes.style,



onShowUnderlay:React.PropTypes.func,



onHideUnderlay:React.PropTypes.func}),


mixins:[NativeMethodsMixin,TimerMixin,Touchable.Mixin],

getDefaultProps:function(){return DEFAULT_PROPS;},


computeSyntheticState:function(props){
return {
activeProps:{
style:{
opacity:props.activeOpacity}},


activeUnderlayProps:{
style:{
backgroundColor:props.underlayColor}},


underlayStyle:[
INACTIVE_UNDERLAY_PROPS.style,
props.style]};},




getInitialState:function(){
return merge(
this.touchableGetInitialState(),this.computeSyntheticState(this.props));},



componentDidMount:function(){
ensurePositiveDelayProps(this.props);
ensureComponentIsNative(this.refs[CHILD_REF]);},


componentDidUpdate:function(){
ensureComponentIsNative(this.refs[CHILD_REF]);},


componentWillReceiveProps:function(nextProps){
ensurePositiveDelayProps(nextProps);
if(nextProps.activeOpacity !== this.props.activeOpacity || 
nextProps.underlayColor !== this.props.underlayColor || 
nextProps.style !== this.props.style){
this.setState(this.computeSyntheticState(nextProps));}},



viewConfig:{
uiViewClassName:'RCTView',
validAttributes:ReactNativeViewAttributes.RCTView},






touchableHandleActivePressIn:function(){
this.clearTimeout(this._hideTimeout);
this._hideTimeout = null;
this._showUnderlay();
this.props.onPressIn && this.props.onPressIn();},


touchableHandleActivePressOut:function(){
if(!this._hideTimeout){
this._hideUnderlay();}

this.props.onPressOut && this.props.onPressOut();},


touchableHandlePress:function(){
this.clearTimeout(this._hideTimeout);
this._showUnderlay();
this._hideTimeout = this.setTimeout(this._hideUnderlay,
this.props.delayPressOut || 100);
this.props.onPress && this.props.onPress();},


touchableHandleLongPress:function(){
this.props.onLongPress && this.props.onLongPress();},


touchableGetPressRectOffset:function(){
return PRESS_RECT_OFFSET;},


touchableGetHighlightDelayMS:function(){
return this.props.delayPressIn;},


touchableGetLongPressDelayMS:function(){
return this.props.delayLongPress;},


touchableGetPressOutDelayMS:function(){
return this.props.delayPressOut;},


_showUnderlay:function(){
this.refs[UNDERLAY_REF].setNativeProps(this.state.activeUnderlayProps);
this.refs[CHILD_REF].setNativeProps(this.state.activeProps);
this.props.onShowUnderlay && this.props.onShowUnderlay();},


_hideUnderlay:function(){
this.clearTimeout(this._hideTimeout);
this._hideTimeout = null;
if(this.refs[UNDERLAY_REF]){
this.refs[CHILD_REF].setNativeProps(INACTIVE_CHILD_PROPS);
this.refs[UNDERLAY_REF].setNativeProps(_extends({},
INACTIVE_UNDERLAY_PROPS,{
style:this.state.underlayStyle}));

this.props.onHideUnderlay && this.props.onHideUnderlay();}},



render:function(){
return (
React.createElement(View,{
ref:UNDERLAY_REF,
style:this.state.underlayStyle,
onStartShouldSetResponder:this.touchableHandleStartShouldSetResponder,
onResponderTerminationRequest:this.touchableHandleResponderTerminationRequest,
onResponderGrant:this.touchableHandleResponderGrant,
onResponderMove:this.touchableHandleResponderMove,
onResponderRelease:this.touchableHandleResponderRelease,
onResponderTerminate:this.touchableHandleResponderTerminate},
cloneWithProps(
onlyChild(this.props.children),
{
ref:CHILD_REF,
accessible:true,
testID:this.props.testID})));}});







var PRESS_RECT_OFFSET={top:20,left:20,right:20,bottom:30};
var CHILD_REF=keyOf({childRef:null});
var UNDERLAY_REF=keyOf({underlayRef:null});
var INACTIVE_CHILD_PROPS={
style:StyleSheet.create({x:{opacity:1.0}}).x};

var INACTIVE_UNDERLAY_PROPS={
style:StyleSheet.create({x:{backgroundColor:'transparent'}}).x};


module.exports = TouchableHighlight;
});
__d('cloneWithProps',["ReactElement","ReactPropTransferer","keyOf","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactElement=require('ReactElement');
var ReactPropTransferer=require('ReactPropTransferer');

var keyOf=require('keyOf');
var warning=require('warning');

var CHILDREN_PROP=keyOf({children:null});










function cloneWithProps(child,props){
if(__DEV__){
warning(
!child.ref,
'You are calling cloneWithProps() on a child with a ref. This is ' + 
'dangerous because you\'re creating a new child which will not be ' + 
'added as a ref to its parent.');}



var newProps=ReactPropTransferer.mergeProps(props,child.props);


if(!newProps.hasOwnProperty(CHILDREN_PROP) && 
child.props.hasOwnProperty(CHILDREN_PROP)){
newProps.children = child.props.children;}




return ReactElement.createElement(child.type,newProps);}


module.exports = cloneWithProps;
});
__d('ReactPropTransferer',["Object.assign","emptyFunction","joinClasses"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var assign=require('Object.assign');
var emptyFunction=require('emptyFunction');
var joinClasses=require('joinClasses');








function createTransferStrategy(mergeStrategy){
return function(props,key,value){
if(!props.hasOwnProperty(key)){
props[key] = value;}else 
{
props[key] = mergeStrategy(props[key],value);}};}




var transferStrategyMerge=createTransferStrategy(function(a,b){



return assign({},b,a);});







var TransferStrategies={



children:emptyFunction,



className:createTransferStrategy(joinClasses),



style:transferStrategyMerge};










function transferInto(props,newProps){
for(var thisKey in newProps) {
if(!newProps.hasOwnProperty(thisKey)){
continue;}


var transferStrategy=TransferStrategies[thisKey];

if(transferStrategy && TransferStrategies.hasOwnProperty(thisKey)){
transferStrategy(props,thisKey,newProps[thisKey]);}else 
if(!props.hasOwnProperty(thisKey)){
props[thisKey] = newProps[thisKey];}}


return props;}








var ReactPropTransferer={








mergeProps:function(oldProps,newProps){
return transferInto(assign({},oldProps),newProps);}};




module.exports = ReactPropTransferer;
});
__d('joinClasses',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




















function joinClasses(className){
if(!className){
className = '';}

var nextClass;
var argLength=arguments.length;
if(argLength > 1){
for(var ii=1;ii < argLength;ii++) {
nextClass = arguments[ii];
if(nextClass){
className = (className?className + ' ':'') + nextClass;}}}



return className;}


module.exports = joinClasses;
});
__d('ensureComponentIsNative',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');

var ensureComponentIsNative=function(component){
invariant(
component && typeof component.setNativeProps === 'function',
'Touchable child must either be native or forward setNativeProps to a ' + 
'native component');};



module.exports = ensureComponentIsNative;
});
__d('TouchableOpacity',["NativeMethodsMixin","POPAnimationMixin","React","Touchable","TouchableWithoutFeedback","cloneWithProps","ensureComponentIsNative","ensurePositiveDelayProps","flattenStyle","keyOf","onlyChild","react-timer-mixin/TimerMixin.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};













var NativeMethodsMixin=require('NativeMethodsMixin');
var POPAnimationMixin=require('POPAnimationMixin');
var React=require('React');
var TimerMixin=require('react-timer-mixin/TimerMixin.js');
var Touchable=require('Touchable');
var TouchableWithoutFeedback=require('TouchableWithoutFeedback');

var cloneWithProps=require('cloneWithProps');
var ensureComponentIsNative=require('ensureComponentIsNative');
var ensurePositiveDelayProps=require('ensurePositiveDelayProps');
var flattenStyle=require('flattenStyle');
var keyOf=require('keyOf');
var onlyChild=require('onlyChild');


























var TouchableOpacity=React.createClass({displayName:'TouchableOpacity',
mixins:[TimerMixin,Touchable.Mixin,NativeMethodsMixin,POPAnimationMixin],

propTypes:_extends({},
TouchableWithoutFeedback.propTypes,{




activeOpacity:React.PropTypes.number}),


getDefaultProps:function(){
return {
activeOpacity:0.2};},



getInitialState:function(){
return this.touchableGetInitialState();},


componentDidMount:function(){
ensurePositiveDelayProps(this.props);
ensureComponentIsNative(this.refs[CHILD_REF]);},


componentDidUpdate:function(){
ensureComponentIsNative(this.refs[CHILD_REF]);},


componentWillReceiveProps:function(nextProps){
ensurePositiveDelayProps(nextProps);},


setOpacityTo:function(value){
if(POPAnimationMixin){

this.stopAllAnimations();
var anim={
type:this.AnimationTypes.linear,
property:this.AnimationProperties.opacity,
duration:0.15,
toValue:value};

this.startAnimation(CHILD_REF,anim);}else 
{

this.refs[CHILD_REF].setNativeProps({
opacity:value});}},








touchableHandleActivePressIn:function(){
this.clearTimeout(this._hideTimeout);
this._hideTimeout = null;
this._opacityActive();
this.props.onPressIn && this.props.onPressIn();},


touchableHandleActivePressOut:function(){
if(!this._hideTimeout){
this._opacityInactive();}

this.props.onPressOut && this.props.onPressOut();},


touchableHandlePress:function(){
this.clearTimeout(this._hideTimeout);
this._opacityActive();
this._hideTimeout = this.setTimeout(
this._opacityInactive,
this.props.delayPressOut || 100);

this.props.onPress && this.props.onPress();},


touchableHandleLongPress:function(){
this.props.onLongPress && this.props.onLongPress();},


touchableGetPressRectOffset:function(){
return PRESS_RECT_OFFSET;},


touchableGetHighlightDelayMS:function(){
return this.props.delayPressIn || 0;},


touchableGetLongPressDelayMS:function(){
return this.props.delayLongPress === 0?0:
this.props.delayLongPress || 500;},


touchableGetPressOutDelayMS:function(){
return this.props.delayPressOut;},


_opacityActive:function(){
this.setOpacityTo(this.props.activeOpacity);},


_opacityInactive:function(){
this.clearTimeout(this._hideTimeout);
this._hideTimeout = null;
var child=onlyChild(this.props.children);
var childStyle=flattenStyle(child.props.style) || {};
this.setOpacityTo(
childStyle.opacity === undefined?1:childStyle.opacity);},



render:function(){
return cloneWithProps(onlyChild(this.props.children),{
ref:CHILD_REF,
accessible:true,
testID:this.props.testID,
onStartShouldSetResponder:this.touchableHandleStartShouldSetResponder,
onResponderTerminationRequest:this.touchableHandleResponderTerminationRequest,
onResponderGrant:this.touchableHandleResponderGrant,
onResponderMove:this.touchableHandleResponderMove,
onResponderRelease:this.touchableHandleResponderRelease,
onResponderTerminate:this.touchableHandleResponderTerminate});}});










var PRESS_RECT_OFFSET={top:20,left:20,right:20,bottom:30};

var CHILD_REF=keyOf({childRef:null});

module.exports = TouchableOpacity;
});
__d('POPAnimationMixin',["POPAnimation","React","invariant","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var POPAnimationOrNull=require('POPAnimation');
var React=require('React');

if(!POPAnimationOrNull){


module.exports = null;}else 
{



var POPAnimation=POPAnimationOrNull;

var invariant=require('invariant');
var warning=require('warning');

var POPAnimationMixin={




AnimationTypes:POPAnimation.Types,
AnimationProperties:POPAnimation.Properties,

getInitialState:function(){
return {
_currentAnimationsByNodeHandle:{}};},



_ensureBookkeepingSetup:function(nodeHandle){
if(!this.state._currentAnimationsByNodeHandle[nodeHandle]){
this.state._currentAnimationsByNodeHandle[nodeHandle] = [];}},

















startAnimation:function(
refKey,
anim,
doneCallback)
{
var animID=0;
if(typeof anim === 'number'){
animID = anim;}else 
{
invariant(
anim instanceof Object && 
anim.type !== undefined && 
anim.property !== undefined,
'Animation definitions must specify a type of animation and a ' + 
'property to animate.');

animID = POPAnimation.createAnimation(anim.type,anim);}

invariant(
this.refs[refKey],
'Invalid refKey ' + refKey + ' for anim:\n' + JSON.stringify(anim) + 
'\nvalid refs: ' + JSON.stringify(Object.keys(this.refs)));

var refNodeHandle=React.findNodeHandle(this.refs[refKey]);
this.startAnimationWithNodeHandle(refNodeHandle,animID,doneCallback);},








startAnimationWithNodeHandle:function(
nodeHandle,
animID,
doneCallback)
{var _this=this;
this._ensureBookkeepingSetup(nodeHandle);
var animations=this.state._currentAnimationsByNodeHandle[nodeHandle];
var animIndex=animations.length;
animations.push(animID);
var cleanupWrapper=function(finished){
if(!_this.isMounted()){
return;}

animations[animIndex] = 0;
var allDone=true;
for(var ii=0;ii < animations.length;ii++) {
if(animations[ii]){
allDone = false;
break;}}


if(allDone){
_this.state._currentAnimationsByNodeHandle[nodeHandle] = undefined;}

doneCallback && doneCallback(finished);};

POPAnimation.addAnimation(nodeHandle,animID,cleanupWrapper);},













startAnimations:function(
animations,
onSuccess,
onFailure)
{var _this2=this;
var numReturned=0;
var numFinished=0;
var numAnimations=animations.length;
var metaCallback=function(finished){
if(finished){
++numFinished;}

if(++numReturned === numAnimations){
onSuccess && onSuccess(numFinished === numAnimations);}};


animations.forEach(function(anim){
warning(
anim.ref != null || anim.nodeHandle != null && 
!anim.ref !== !anim.nodeHandle,
'Animations must be specified with either ref xor nodeHandle');

if(anim.ref){
_this2.startAnimation(anim.ref,anim.anim,metaCallback);}else 
if(anim.nodeHandle){
_this2.startAnimationWithNodeHandle(anim.nodeHandle,anim.anim,metaCallback);}});},











stopNodeHandleAnimations:function(nodeHandle){
if(!this.state._currentAnimationsByNodeHandle[nodeHandle]){
return;}

var anims=this.state._currentAnimationsByNodeHandle[nodeHandle];
for(var i=0;i < anims.length;i++) {
var anim=anims[i];
if(anim){

POPAnimation.removeAnimation(+nodeHandle,anim);}}


this.state._currentAnimationsByNodeHandle[nodeHandle] = undefined;},







stopAnimations:function(refKey){
invariant(this.refs[refKey],'invalid ref');
this.stopNodeHandleAnimations(React.findNodeHandle(this.refs[refKey]));},






stopAllAnimations:function(){
for(var nodeHandle in this.state._currentAnimationsByNodeHandle) {
this.stopNodeHandleAnimations(nodeHandle);}},



















animateToFrame:function(
refKey,
frame,
type,
velocity,
doneCallback)
{
var animFrame={
x:frame.left + frame.width / 2,
y:frame.top + frame.height / 2,
w:frame.width,
h:frame.height};

var posAnim=POPAnimation.createAnimation(type,{
property:POPAnimation.Properties.position,
toValue:[animFrame.x,animFrame.y],
velocity:velocity || [0,0]});

var sizeAnim=POPAnimation.createAnimation(type,{
property:POPAnimation.Properties.size,
toValue:[animFrame.w,animFrame.h]});

this.startAnimation(refKey,posAnim,doneCallback);
this.startAnimation(refKey,sizeAnim);},



componentWillUnmount:function(){
this.stopAllAnimations();}};



module.exports = POPAnimationMixin;}
});
__d('POPAnimation',["NativeModules","ReactPropTypes","createStrictShapeTypeChecker","getObjectValues","invariant","merge"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';











var RCTPOPAnimationManager=require('NativeModules').POPAnimationManager;
if(!RCTPOPAnimationManager){




module.exports = null;}else 
{

var ReactPropTypes=require('ReactPropTypes');
var createStrictShapeTypeChecker=require('createStrictShapeTypeChecker');
var getObjectValues=require('getObjectValues');
var invariant=require('invariant');
var merge=require('merge');

var RCTTypes=RCTPOPAnimationManager.Types;
var RCTProperties=RCTPOPAnimationManager.Properties;

var Properties={
bounds:RCTProperties.bounds,
opacity:RCTProperties.opacity,
position:RCTProperties.position,
positionX:RCTProperties.positionX,
positionY:RCTProperties.positionY,
zPosition:RCTProperties.zPosition,
rotation:RCTProperties.rotation,
rotationX:RCTProperties.rotationX,
rotationY:RCTProperties.rotationY,
scaleX:RCTProperties.scaleX,
scaleXY:RCTProperties.scaleXY,
scaleY:RCTProperties.scaleY,
shadowColor:RCTProperties.shadowColor,
shadowOffset:RCTProperties.shadowOffset,
shadowOpacity:RCTProperties.shadowOpacity,
shadowRadius:RCTProperties.shadowRadius,
size:RCTProperties.size,
subscaleXY:RCTProperties.subscaleXY,
subtranslationX:RCTProperties.subtranslationX,
subtranslationXY:RCTProperties.subtranslationXY,
subtranslationY:RCTProperties.subtranslationY,
subtranslationZ:RCTProperties.subtranslationZ,
translationX:RCTProperties.translationX,
translationXY:RCTProperties.translationXY,
translationY:RCTProperties.translationY,
translationZ:RCTProperties.translationZ};


var Types={
decay:RCTTypes.decay,
easeIn:RCTTypes.easeIn,
easeInEaseOut:RCTTypes.easeInEaseOut,
easeOut:RCTTypes.easeOut,
linear:RCTTypes.linear,
spring:RCTTypes.spring};
















var POPAnimation={
Types:Types,
Properties:Properties,

attributeChecker:createStrictShapeTypeChecker({
type:ReactPropTypes.oneOf(getObjectValues(Types)),
property:ReactPropTypes.oneOf(getObjectValues(Properties)),
fromValue:ReactPropTypes.any,
toValue:ReactPropTypes.any,
duration:ReactPropTypes.any,
velocity:ReactPropTypes.any,
deceleration:ReactPropTypes.any,
springBounciness:ReactPropTypes.any,
dynamicsFriction:ReactPropTypes.any,
dynamicsMass:ReactPropTypes.any,
dynamicsTension:ReactPropTypes.any}),


lastUsedTag:0,
allocateTagForAnimation:function(){
return ++this.lastUsedTag;},


createAnimation:function(typeName,attrs){
var tag=this.allocateTagForAnimation();

if(__DEV__){
POPAnimation.attributeChecker(
{attrs:attrs},
'attrs',
'POPAnimation.createAnimation');

POPAnimation.attributeChecker(
{attrs:{type:typeName}},
'attrs',
'POPAnimation.createAnimation');}



RCTPOPAnimationManager.createAnimationInternal(tag,typeName,attrs);
return tag;},


createSpringAnimation:function(attrs){
return this.createAnimation(this.Types.spring,attrs);},


createDecayAnimation:function(attrs){
return this.createAnimation(this.Types.decay,attrs);},


createLinearAnimation:function(attrs){
return this.createAnimation(this.Types.linear,attrs);},


createEaseInAnimation:function(attrs){
return this.createAnimation(this.Types.easeIn,attrs);},


createEaseOutAnimation:function(attrs){
return this.createAnimation(this.Types.easeOut,attrs);},


createEaseInEaseOutAnimation:function(attrs){
return this.createAnimation(this.Types.easeInEaseOut,attrs);},


addAnimation:function(nodeHandle,anim,callback){
RCTPOPAnimationManager.addAnimation(nodeHandle,anim,callback);},


removeAnimation:function(nodeHandle,anim){
RCTPOPAnimationManager.removeAnimation(nodeHandle,anim);}};





if(__DEV__){
var allProperties=merge(
RCTPOPAnimationManager.Properties,
RCTPOPAnimationManager.Properties);

for(var key in allProperties) {
invariant(
POPAnimation.Properties[key] === RCTPOPAnimationManager.Properties[key],
'POPAnimation doesn\'t copy property ' + key + ' correctly');}



var allTypes=merge(
RCTPOPAnimationManager.Types,
RCTPOPAnimationManager.Types);

for(var key in allTypes) {
invariant(
POPAnimation.Types[key] === RCTPOPAnimationManager.Types[key],
'POPAnimation doesn\'t copy type ' + key + ' correctly');}}




module.exports = POPAnimation;}
});
__d('getObjectValues',[],function(global, require, requireDynamic, requireLazy, module, exports) {  function 


























getObjectValues(obj){
var values=[];
for(var key in obj) {
values.push(obj[key]);}

return values;}


module.exports = getObjectValues;
});
__d('WebView',["ActivityIndicatorIOS","EdgeInsetsPropType","React","StyleSheet","Text","View","invariant","keyMirror","requireNativeComponent","NativeModules"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ActivityIndicatorIOS=require('ActivityIndicatorIOS');
var EdgeInsetsPropType=require('EdgeInsetsPropType');
var React=require('React');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var View=require('View');

var invariant=require('invariant');
var keyMirror=require('keyMirror');
var requireNativeComponent=require('requireNativeComponent');

var PropTypes=React.PropTypes;
var RCTWebViewManager=require('NativeModules').WebViewManager;

var BGWASH='rgba(255,255,255,0.8)';
var RCT_WEBVIEW_REF='webview';

var WebViewState=keyMirror({
IDLE:null,
LOADING:null,
ERROR:null});


var NavigationType={
click:RCTWebViewManager.NavigationType.LinkClicked,
formsubmit:RCTWebViewManager.NavigationType.FormSubmitted,
backforward:RCTWebViewManager.NavigationType.BackForward,
reload:RCTWebViewManager.NavigationType.Reload,
formresubmit:RCTWebViewManager.NavigationType.FormResubmitted,
other:RCTWebViewManager.NavigationType.Other};










var defaultRenderLoading=function(){return (
React.createElement(View,{style:styles.loadingView},
React.createElement(ActivityIndicatorIOS,null)));};


var defaultRenderError=function(errorDomain,errorCode,errorDesc){return (
React.createElement(View,{style:styles.errorContainer},
React.createElement(Text,{style:styles.errorTextTitle},'Error loading page'),


React.createElement(Text,{style:styles.errorText},
'Domain: ' + errorDomain),

React.createElement(Text,{style:styles.errorText},
'Error Code: ' + errorCode),

React.createElement(Text,{style:styles.errorText},
'Description: ' + errorDesc)));};




var WebView=React.createClass({displayName:'WebView',
statics:{
NavigationType:NavigationType},


propTypes:{
url:PropTypes.string,
html:PropTypes.string,
renderError:PropTypes.func,
renderLoading:PropTypes.func,
bounces:PropTypes.bool,
scrollEnabled:PropTypes.bool,
automaticallyAdjustContentInsets:PropTypes.bool,
shouldInjectAJAXHandler:PropTypes.bool,
contentInset:EdgeInsetsPropType,
onNavigationStateChange:PropTypes.func,
startInLoadingState:PropTypes.bool,
style:View.propTypes.style,



javaScriptEnabledAndroid:PropTypes.bool,




scalesPageToFit:PropTypes.bool},


getInitialState:function(){
return {
viewState:WebViewState.IDLE,
lastErrorEvent:null,
startInLoadingState:true};},



componentWillMount:function(){
if(this.props.startInLoadingState){
this.setState({viewState:WebViewState.LOADING});}},



render:function(){
var otherView=null;

if(this.state.viewState === WebViewState.LOADING){
otherView = (this.props.renderLoading || defaultRenderLoading)();}else 
if(this.state.viewState === WebViewState.ERROR){
var errorEvent=this.state.lastErrorEvent;
invariant(
errorEvent != null,
'lastErrorEvent expected to be non-null');

otherView = (this.props.renderError || defaultRenderError)(
errorEvent.domain,
errorEvent.code,
errorEvent.description);}else 

if(this.state.viewState !== WebViewState.IDLE){
console.error(
'RCTWebView invalid state encountered: ' + this.state.loading);}



var webViewStyles=[styles.container,styles.webView,this.props.style];
if(this.state.viewState === WebViewState.LOADING || 
this.state.viewState === WebViewState.ERROR){

webViewStyles.push(styles.hidden);}


var webView=
React.createElement(RCTWebView,{
ref:RCT_WEBVIEW_REF,
key:'webViewKey',
style:webViewStyles,
url:this.props.url,
html:this.props.html,
bounces:this.props.bounces,
scrollEnabled:this.props.scrollEnabled,
shouldInjectAJAXHandler:this.props.shouldInjectAJAXHandler,
contentInset:this.props.contentInset,
automaticallyAdjustContentInsets:this.props.automaticallyAdjustContentInsets,
onLoadingStart:this.onLoadingStart,
onLoadingFinish:this.onLoadingFinish,
onLoadingError:this.onLoadingError,
scalesPageToFit:this.props.scalesPageToFit});


return (
React.createElement(View,{style:styles.container},
webView,
otherView));},




goForward:function(){
RCTWebViewManager.goForward(this.getWebWiewHandle());},


goBack:function(){
RCTWebViewManager.goBack(this.getWebWiewHandle());},


reload:function(){
RCTWebViewManager.reload(this.getWebWiewHandle());},






updateNavigationState:function(event){
if(this.props.onNavigationStateChange){
this.props.onNavigationStateChange(event.nativeEvent);}},



getWebWiewHandle:function(){
return React.findNodeHandle(this.refs[RCT_WEBVIEW_REF]);},


onLoadingStart:function(event){
this.updateNavigationState(event);},


onLoadingError:function(event){
event.persist();
console.error('Encountered an error loading page',event.nativeEvent);

this.setState({
lastErrorEvent:event.nativeEvent,
viewState:WebViewState.ERROR});},



onLoadingFinish:function(event){
this.setState({
viewState:WebViewState.IDLE});

this.updateNavigationState(event);}});



var RCTWebView=requireNativeComponent('RCTWebView',WebView);

var styles=StyleSheet.create({
container:{
flex:1},

errorContainer:{
flex:1,
justifyContent:'center',
alignItems:'center',
backgroundColor:BGWASH},

errorText:{
fontSize:14,
textAlign:'center',
marginBottom:2},

errorTextTitle:{
fontSize:15,
fontWeight:'500',
marginBottom:10},

hidden:{
height:0,
flex:0},

loadingView:{
backgroundColor:BGWASH,
flex:1,
justifyContent:'center',
alignItems:'center'},

webView:{
backgroundColor:'#ffffff'}});



module.exports = WebView;
});
__d('AlertIOS',["NativeModules","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var RCTAlertManager=require('NativeModules').AlertManager;
var invariant=require('invariant');

var DEFAULT_BUTTON_TEXT='OK';
var DEFAULT_BUTTON={
text:DEFAULT_BUTTON_TEXT,
onPress:null};var 
























AlertIOS=(function(){function AlertIOS(){_classCallCheck(this,AlertIOS);}_createClass(AlertIOS,null,[{key:'alert',value:
function alert(
title,
message,
buttons,



type)
{
var callbacks=[];
var buttonsSpec=[];
title = title || '';
message = message || '';
buttons = buttons || [DEFAULT_BUTTON];
type = type || '';

buttons.forEach(function(btn,index){
callbacks[index] = btn.onPress;
var btnDef={};
btnDef[index] = btn.text || DEFAULT_BUTTON_TEXT;
buttonsSpec.push(btnDef);});

RCTAlertManager.alertWithArgs({
title:title,
message:message,
buttons:buttonsSpec,
type:type},
function(id,value){
var cb=callbacks[id];
cb && cb(value);});}},{key:'prompt',value:



function prompt(
title,
value,
buttons,



callback)
{
if(arguments.length === 2){
if(typeof value === 'object'){
buttons = value;
value = undefined;}else 
if(typeof value === 'function'){
callback = value;
value = undefined;}}else 

if(arguments.length === 3 && typeof buttons === 'function'){
callback = buttons;
buttons = undefined;}


invariant(
!(callback && buttons) && (callback || buttons),
'Must provide either a button list or a callback, but not both');


if(!buttons){
buttons = [{
text:'Cancel'},
{
text:'OK',
onPress:callback}];}


this.alert(title,value,buttons,'plain-text');}}]);return AlertIOS;})();



module.exports = AlertIOS;
});
__d('AppRegistry',["invariant","renderApplication","RCTRenderingPerf"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var invariant=require('invariant');
var renderApplication=require('renderApplication');

if(__DEV__){


require('RCTRenderingPerf');}


var runnables={};


















var AppRegistry={
registerConfig:function(config){
for(var i=0;i < config.length;++i) {
var appConfig=config[i];
if(appConfig.run){
AppRegistry.registerRunnable(appConfig.appKey,appConfig.run);}else 
{
AppRegistry.registerComponent(appConfig.appKey,appConfig.component);}}},




registerComponent:function(appKey,getComponentFunc){
runnables[appKey] = {
run:function(appParameters){return (
renderApplication(getComponentFunc(),appParameters.initialProps,appParameters.rootTag));}};

return appKey;},


registerRunnable:function(appKey,func){
runnables[appKey] = {run:func};
return appKey;},


runApplication:function(appKey,appParameters){
console.log(
'Running application "' + appKey + '" with appParams: ' + 
JSON.stringify(appParameters) + '. ' + 
'__DEV__ === ' + String(__DEV__) + 
', development-level warning are ' + (__DEV__?'ON':'OFF') + 
', performance optimizations are ' + (__DEV__?'OFF':'ON'));

invariant(
runnables[appKey] && runnables[appKey].run,
'Application ' + appKey + ' has not been registered. This ' + 
'is either due to a require() error during initialization ' + 
'or failure to call AppRegistry.registerComponent.');

runnables[appKey].run(appParameters);}};



module.exports = AppRegistry;
});
__d('renderApplication',["Inspector","RCTDeviceEventEmitter","React","StyleSheet","Subscribable","View","WarningBox","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};











var Inspector=require('Inspector');
var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');
var React=require('React');
var StyleSheet=require('StyleSheet');
var Subscribable=require('Subscribable');
var View=require('View');
var WarningBox=require('WarningBox');

var invariant=require('invariant');

var AppContainer=React.createClass({displayName:'AppContainer',
mixins:[Subscribable.Mixin],

getInitialState:function(){
return {inspector:null};},


toggleElementInspector:function(){
var inspector=this.state.inspector?
null:
React.createElement(Inspector,{
rootTag:this.props.rootTag,
inspectedViewTag:React.findNodeHandle(this.refs.main)});

this.setState({inspector:inspector});},


componentDidMount:function(){
this.addListenerOn(
RCTDeviceEventEmitter,
'toggleElementInspector',
this.toggleElementInspector);},



render:function(){
var shouldRenderWarningBox=__DEV__ && console.yellowBoxEnabled;
var warningBox=shouldRenderWarningBox?React.createElement(WarningBox,null):null;
return (
React.createElement(View,{style:styles.appContainer},
React.createElement(View,{style:styles.appContainer,ref:'main'},
this.props.children),

warningBox,
this.state.inspector));}});





function renderApplication(
RootComponent,
initialProps,
rootTag)
{
invariant(
rootTag,
'Expect to have a valid rootTag, instead got ',rootTag);

React.render(
React.createElement(AppContainer,{rootTag:rootTag},
React.createElement(RootComponent,_extends({},
initialProps,{
rootTag:rootTag}))),


rootTag);}



var styles=StyleSheet.create({
appContainer:{
position:'absolute',
left:0,
top:0,
right:0,
bottom:0}});



module.exports = renderApplication;
});
__d('Inspector',["Dimensions","InspectorOverlay","InspectorPanel","InspectorUtils","React","StyleSheet","NativeModules","View"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var Dimensions=require('Dimensions');
var InspectorOverlay=require('InspectorOverlay');
var InspectorPanel=require('InspectorPanel');
var InspectorUtils=require('InspectorUtils');
var React=require('React');
var StyleSheet=require('StyleSheet');
var UIManager=require('NativeModules').UIManager;
var View=require('View');var 

Inspector=(function(_React$Component){_inherits(Inspector,_React$Component);
function Inspector(props){_classCallCheck(this,Inspector);
_get(Object.getPrototypeOf(Inspector.prototype),'constructor',this).call(this,props);
this.state = {
panelPos:'bottom',
inspecting:true,
perfing:false,
inspected:null};}_createClass(Inspector,[{key:'setSelection',value:



function setSelection(i){var _this=this;
var instance=this.state.hierarchy[i];
var publicInstance=instance.getPublicInstance();
UIManager.measure(React.findNodeHandle(instance),function(x,y,width,height,left,top){
_this.setState({
inspected:{
frame:{left:left,top:top,width:width,height:height},
style:publicInstance.props?publicInstance.props.style:{}},

selection:i});});}},{key:'onTouchInstance',value:




function onTouchInstance(instance,frame,pointerY){
var hierarchy=InspectorUtils.getOwnerHierarchy(instance);
var publicInstance=instance.getPublicInstance();
var props=publicInstance.props || {};
this.setState({
panelPos:pointerY > Dimensions.get('window').height / 2?'top':'bottom',
selection:hierarchy.length - 1,
hierarchy:hierarchy,
inspected:{
style:props.style || {},
frame:frame}});}},{key:'setPerfing',value:




function setPerfing(val){
this.setState({
perfing:val,
inspecting:false,
inspected:null});}},{key:'setInspecting',value:



function setInspecting(val){
this.setState({
inspecting:val,
inspected:null});}},{key:'render',value:



function render(){
var panelContainerStyle=this.state.panelPos === 'bottom'?{bottom:0}:{top:0};
return (
React.createElement(View,{style:styles.container,pointerEvents:'box-none'},
this.state.inspecting && 
React.createElement(InspectorOverlay,{
rootTag:this.props.rootTag,
inspected:this.state.inspected,
inspectedViewTag:this.props.inspectedViewTag,
onTouchInstance:this.onTouchInstance.bind(this)}),

React.createElement(View,{style:[styles.panelContainer,panelContainerStyle]},
React.createElement(InspectorPanel,{
inspecting:this.state.inspecting,
perfing:this.state.perfing,
setPerfing:this.setPerfing.bind(this),
setInspecting:this.setInspecting.bind(this),
inspected:this.state.inspected,
hierarchy:this.state.hierarchy,
selection:this.state.selection,
setSelection:this.setSelection.bind(this)}))));}}]);return Inspector;})(React.Component);







var styles=StyleSheet.create({
container:{
position:'absolute',
backgroundColor:'transparent',
top:0,
left:0,
right:0,
bottom:0},

panelContainer:{
position:'absolute',
left:0,
right:0}});



module.exports = Inspector;
});
__d('InspectorOverlay',["Dimensions","InspectorUtils","React","StyleSheet","NativeModules","View","ElementBox"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var Dimensions=require('Dimensions');
var InspectorUtils=require('InspectorUtils');
var React=require('React');
var StyleSheet=require('StyleSheet');
var UIManager=require('NativeModules').UIManager;
var View=require('View');
var ElementBox=require('ElementBox');

var PropTypes=React.PropTypes;





var InspectorOverlay=React.createClass({displayName:'InspectorOverlay',
propTypes:{
inspectedViewTag:PropTypes.object,
onTouchInstance:PropTypes.func.isRequired},


findViewForTouchEvent:function(e){var _this=this;var _e$nativeEvent$touches$0=
e.nativeEvent.touches[0];var locationX=_e$nativeEvent$touches$0.locationX;var locationY=_e$nativeEvent$touches$0.locationY;
UIManager.findSubviewIn(
this.props.inspectedViewTag,
[locationX,locationY],
function(nativeViewTag,left,top,width,height){
var instance=InspectorUtils.findInstanceByNativeTag(_this.props.rootTag,nativeViewTag);
if(!instance){
return;}

_this.props.onTouchInstance(instance,{left:left,top:top,width:width,height:height},locationY);});},




shouldSetResponser:function(e){
this.findViewForTouchEvent(e);
return true;},


render:function(){
var content=null;
if(this.props.inspected){
content = React.createElement(ElementBox,{frame:this.props.inspected.frame,style:this.props.inspected.style});}


return (
React.createElement(View,{
onStartShouldSetResponder:this.shouldSetResponser,
onResponderMove:this.findViewForTouchEvent,
style:[styles.inspector,{height:Dimensions.get('window').height}]},
content));}});





var styles=StyleSheet.create({
inspector:{
backgroundColor:'transparent',
position:'absolute',
left:0,
top:0,
right:0}});



module.exports = InspectorOverlay;
});
__d('ElementBox',["React","View","StyleSheet","BorderBox","resolveBoxStyle","flattenStyle"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var React=require('React');
var View=require('View');
var StyleSheet=require('StyleSheet');
var BorderBox=require('BorderBox');
var resolveBoxStyle=require('resolveBoxStyle');

var flattenStyle=require('flattenStyle');var 

ElementBox=(function(_React$Component){_inherits(ElementBox,_React$Component);function ElementBox(){_classCallCheck(this,ElementBox);_get(Object.getPrototypeOf(ElementBox.prototype),'constructor',this).apply(this,arguments);}_createClass(ElementBox,[{key:'render',value:
function render(){
var style=flattenStyle(this.props.style) || {};
var margin=resolveBoxStyle('margin',style);
var padding=resolveBoxStyle('padding',style);
var frameStyle=this.props.frame;
if(margin){
frameStyle = {
top:frameStyle.top - margin.top,
left:frameStyle.left - margin.left,
height:frameStyle.height + margin.top + margin.bottom,
width:frameStyle.width + margin.left + margin.right};}


var contentStyle={
width:this.props.frame.width,
height:this.props.frame.height};

if(padding){
contentStyle = {
width:contentStyle.width - padding.left - padding.right,
height:contentStyle.height - padding.top - padding.bottom};}


return (
React.createElement(View,{style:[styles.frame,frameStyle],pointerEvents:'none'},
React.createElement(BorderBox,{box:margin,style:styles.margin},
React.createElement(BorderBox,{box:padding,style:styles.padding},
React.createElement(View,{style:[styles.content,contentStyle]})))));}}]);return ElementBox;})(React.Component);







var styles=StyleSheet.create({
frame:{
position:'absolute'},

content:{
backgroundColor:'rgba(200, 230, 255, 0.8)'},

padding:{
borderColor:'rgba(77, 255, 0, 0.3)'},

margin:{
borderColor:'rgba(255, 132, 0, 0.3)'}});



module.exports = ElementBox;
});
__d('BorderBox',["React","View"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var React=require('React');
var View=require('View');var 

BorderBox=(function(_React$Component){_inherits(BorderBox,_React$Component);function BorderBox(){_classCallCheck(this,BorderBox);_get(Object.getPrototypeOf(BorderBox.prototype),'constructor',this).apply(this,arguments);}_createClass(BorderBox,[{key:'render',value:
function render(){
var box=this.props.box;
if(!box){
return this.props.children;}

var style={
borderTopWidth:box.top,
borderBottomWidth:box.bottom,
borderLeftWidth:box.left,
borderRightWidth:box.right};

return (
React.createElement(View,{style:[style,this.props.style]},
this.props.children));}}]);return BorderBox;})(React.Component);





module.exports = BorderBox;
});
__d('resolveBoxStyle',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';





















function resolveBoxStyle(prefix,style){
var res={};
var subs=['top','left','bottom','right'];
var set=false;
subs.forEach(function(sub){
res[sub] = style[prefix] || 0;});

if(style[prefix]){
set = true;}

if(style[prefix + 'Vertical']){
res.top = res.bottom = style[prefix + 'Vertical'];
set = true;}

if(style[prefix + 'Horizontal']){
res.left = res.right = style[prefix + 'Horizontal'];
set = true;}

subs.forEach(function(sub){
var val=style[prefix + capFirst(sub)];
if(val){
res[sub] = val;
set = true;}});


if(!set){
return;}

return res;}


function capFirst(text){
return text[0].toUpperCase() + text.slice(1);}


module.exports = resolveBoxStyle;
});
__d('InspectorPanel',["React","StyleSheet","Text","View","ElementProperties","PerformanceOverlay","TouchableHighlight"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var React=require('React');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var View=require('View');
var ElementProperties=require('ElementProperties');
var PerformanceOverlay=require('PerformanceOverlay');
var TouchableHighlight=require('TouchableHighlight');

var PropTypes=React.PropTypes;var 

InspectorPanel=(function(_React$Component){_inherits(InspectorPanel,_React$Component);function InspectorPanel(){_classCallCheck(this,InspectorPanel);_get(Object.getPrototypeOf(InspectorPanel.prototype),'constructor',this).apply(this,arguments);}_createClass(InspectorPanel,[{key:'renderWaiting',value:
function renderWaiting(){
if(this.props.inspecting){
return (
React.createElement(Text,{style:styles.waitingText},'Tap something to inspect it'));}




return React.createElement(Text,{style:styles.waitingText},'Nothing is inspected');}},{key:'render',value:


function render(){
var contents;
if(this.props.inspected){
contents = 
React.createElement(ElementProperties,{
style:this.props.inspected.style,
frame:this.props.inspected.frame,
hierarchy:this.props.hierarchy,
selection:this.props.selection,
setSelection:this.props.setSelection});}else 


if(this.props.perfing){
contents = 
React.createElement(PerformanceOverlay,null);}else 

{
contents = 
React.createElement(View,{style:styles.waiting},
this.renderWaiting());}



return (
React.createElement(View,{style:styles.container},
contents,
React.createElement(View,{style:styles.buttonRow},
React.createElement(Button,{
title:'Inspect',
pressed:this.props.inspecting,
onClick:this.props.setInspecting}),

React.createElement(Button,{title:'Perf',
pressed:this.props.perfing,
onClick:this.props.setPerfing}))));}}]);return InspectorPanel;})(React.Component);







InspectorPanel.propTypes = {
inspecting:PropTypes.bool,
setInspecting:PropTypes.func,
inspected:PropTypes.object,
perfing:PropTypes.bool,
setPerfing:PropTypes.func};var 


Button=(function(_React$Component2){_inherits(Button,_React$Component2);function Button(){_classCallCheck(this,Button);_get(Object.getPrototypeOf(Button.prototype),'constructor',this).apply(this,arguments);}_createClass(Button,[{key:'render',value:
function render(){var _this=this;
return (
React.createElement(TouchableHighlight,{onPress:function(){return _this.props.onClick(!_this.props.pressed);},style:[
styles.button,
this.props.pressed && styles.buttonPressed]},

React.createElement(Text,{style:styles.buttonText},this.props.title)));}}]);return Button;})(React.Component);





var styles=StyleSheet.create({
buttonRow:{
flexDirection:'row'},

button:{
backgroundColor:'rgba(0, 0, 0, 0.3)',
margin:2,
height:30,
justifyContent:'center',
alignItems:'center'},

buttonPressed:{
backgroundColor:'rgba(255, 255, 255, 0.3)'},

buttonText:{
textAlign:'center',
color:'white',
margin:5},

container:{
backgroundColor:'rgba(0, 0, 0, 0.7)'},

waiting:{
height:100},

waitingText:{
fontSize:20,
textAlign:'center',
marginVertical:20}});



module.exports = InspectorPanel;
});
__d('ElementProperties',["BoxInspector","ReactPropTypes","React","StyleInspector","StyleSheet","Text","TouchableHighlight","TouchableWithoutFeedback","View","flattenStyle","mapWithSeparator"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var BoxInspector=require('BoxInspector');
var PropTypes=require('ReactPropTypes');
var React=require('React');
var StyleInspector=require('StyleInspector');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var TouchableHighlight=require('TouchableHighlight');
var TouchableWithoutFeedback=require('TouchableWithoutFeedback');
var View=require('View');

var flattenStyle=require('flattenStyle');
var mapWithSeparator=require('mapWithSeparator');

var ElementProperties=React.createClass({displayName:'ElementProperties',
propTypes:{
hierarchy:PropTypes.array.isRequired,
style:PropTypes.array.isRequired},


render:function(){var _this=this;
var style=flattenStyle(this.props.style);
var selection=this.props.selection;


return (
React.createElement(TouchableWithoutFeedback,null,
React.createElement(View,{style:styles.info},
React.createElement(View,{style:styles.breadcrumb},
mapWithSeparator(
this.props.hierarchy,
function(item,i){return (
React.createElement(TouchableHighlight,{
style:[styles.breadItem,i === selection && styles.selected],
onPress:function(){return _this.props.setSelection(i);}},
React.createElement(Text,{style:styles.breadItemText},
item.getName?item.getName():'Unknown')));},



function(){return React.createElement(Text,{style:styles.breadSep},'▸');})),


React.createElement(View,{style:styles.row},
React.createElement(StyleInspector,{style:style}),
React.createElement(BoxInspector,{style:style,frame:this.props.frame})))));}});







var styles=StyleSheet.create({
breadSep:{
fontSize:8,
color:'white'},

breadcrumb:{
flexDirection:'row',
flexWrap:'wrap',
marginBottom:5},

selected:{
borderColor:'white',
borderRadius:5},

breadItem:{
borderWidth:1,
borderColor:'transparent',
marginHorizontal:2},

breadItemText:{
fontSize:10,
color:'white',
marginHorizontal:5},

row:{
flexDirection:'row',
alignItems:'center',
justifyContent:'space-between'},

info:{
padding:10},

path:{
color:'white',
fontSize:9}});



module.exports = ElementProperties;
});
__d('BoxInspector',["React","StyleSheet","Text","View","resolveBoxStyle"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var React=require('React');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var View=require('View');
var resolveBoxStyle=require('resolveBoxStyle');

var blank={
top:0,
left:0,
right:0,
bottom:0};var 


BoxInspector=(function(_React$Component){_inherits(BoxInspector,_React$Component);function BoxInspector(){_classCallCheck(this,BoxInspector);_get(Object.getPrototypeOf(BoxInspector.prototype),'constructor',this).apply(this,arguments);}_createClass(BoxInspector,[{key:'render',value:
function render(){
var frame=this.props.frame;
var style=this.props.style;
var margin=style && resolveBoxStyle('margin',style) || blank;
var padding=style && resolveBoxStyle('padding',style) || blank;
return (
React.createElement(BoxContainer,{title:'margin',titleStyle:styles.marginLabel,box:margin},
React.createElement(BoxContainer,{title:'padding',box:padding},
React.createElement(View,null,
React.createElement(Text,{style:styles.innerText},'(',
frame.left,', ',frame.top,')'),

React.createElement(Text,{style:styles.innerText},
frame.width,' × ',frame.height)))));}}]);return BoxInspector;})(React.Component);var 








BoxContainer=(function(_React$Component2){_inherits(BoxContainer,_React$Component2);function BoxContainer(){_classCallCheck(this,BoxContainer);_get(Object.getPrototypeOf(BoxContainer.prototype),'constructor',this).apply(this,arguments);}_createClass(BoxContainer,[{key:'render',value:
function render(){
var box=this.props.box;
return (
React.createElement(View,{style:styles.box},
React.createElement(View,{style:styles.row},
React.createElement(Text,{style:[this.props.titleStyle,styles.label]},this.props.title),
React.createElement(Text,{style:styles.boxText},box.top)),

React.createElement(View,{style:styles.row},
React.createElement(Text,{style:styles.boxText},box.left),
this.props.children,
React.createElement(Text,{style:styles.boxText},box.right)),

React.createElement(Text,{style:styles.boxText},box.bottom)));}}]);return BoxContainer;})(React.Component);





var styles=StyleSheet.create({
row:{
flexDirection:'row',
alignItems:'center',
justifyContent:'space-around'},

marginLabel:{
width:60},

label:{
fontSize:10,
color:'rgb(255,100,0)',
marginLeft:5,
flex:1,
textAlign:'left',
top:-3},

buffer:{
fontSize:10,
color:'yellow',
flex:1,
textAlign:'center'},

innerText:{
color:'yellow',
fontSize:12,
textAlign:'center',
width:70},

box:{
borderWidth:1,
borderColor:'grey'},

boxText:{
color:'white',
fontSize:12,
marginHorizontal:3,
marginVertical:2,
textAlign:'center'}});



module.exports = BoxInspector;
});
__d('StyleInspector',["React","StyleSheet","Text","View"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}












var React=require('React');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var View=require('View');var 

StyleInspector=(function(_React$Component){_inherits(StyleInspector,_React$Component);function StyleInspector(){_classCallCheck(this,StyleInspector);_get(Object.getPrototypeOf(StyleInspector.prototype),'constructor',this).apply(this,arguments);}_createClass(StyleInspector,[{key:'render',value:
function render(){var _this=this;
if(!this.props.style){
return React.createElement(Text,{style:styles.noStyle},'No style');}

var names=Object.keys(this.props.style);
return (
React.createElement(View,{style:styles.container},
React.createElement(View,null,
names.map(function(name){return React.createElement(Text,{style:styles.attr},name,':');})),

React.createElement(View,null,
names.map(function(name){return React.createElement(Text,{style:styles.value},_this.props.style[name]);}))));}}]);return StyleInspector;})(React.Component);






var styles=StyleSheet.create({
container:{
flexDirection:'row'},

row:{
flexDirection:'row',
alignItems:'center',
justifyContent:'space-around'},

attr:{
fontSize:10,
color:'#ccc'},

value:{
fontSize:10,
color:'white',
marginLeft:10},

noStyle:{
color:'white',
fontSize:10}});



module.exports = StyleInspector;
});
__d('mapWithSeparator',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






function mapWithSeparator(array,valueFunction,separatorFunction){
var results=[];
for(var i=0;i < array.length;i++) {
results.push(valueFunction(array[i],i,array));
if(i !== array.length - 1){
results.push(separatorFunction(i));}}


return results;}


module.exports = mapWithSeparator;
});
__d('PerformanceOverlay',["PerformanceLogger","React","StyleSheet","Text","View"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var PerformanceLogger=require('PerformanceLogger');
var React=require('React');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var View=require('View');

var PerformanceOverlay=React.createClass({displayName:'PerformanceOverlay',
render:function(){
var perfLogs=PerformanceLogger.getTimespans();
var items=[];

for(var key in perfLogs) {
if(perfLogs[key].totalTime){
items.push(
React.createElement(View,{style:styles.row},
React.createElement(Text,{style:[styles.text,styles.label]},key),
React.createElement(Text,{style:[styles.text,styles.totalTime]},
perfLogs[key].totalTime + 'ms')));}}






return (
React.createElement(View,{style:styles.container},
items));}});





var styles=StyleSheet.create({
container:{
height:100,
paddingTop:10},

label:{
flex:1},

row:{
flexDirection:'row',
paddingHorizontal:10},

text:{
color:'white',
fontSize:12},

totalTime:{
paddingRight:100}});



module.exports = PerformanceOverlay;
});
__d('WarningBox',["AsyncStorage","EventEmitter","Map","PanResponder","React","StyleSheet","Text","TouchableOpacity","View","invariant","stringifySafe","Dimensions","rebound/rebound.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};











var AsyncStorage=require('AsyncStorage');
var EventEmitter=require('EventEmitter');
var Map=require('Map');
var PanResponder=require('PanResponder');
var React=require('React');
var StyleSheet=require('StyleSheet');
var Text=require('Text');
var TouchableOpacity=require('TouchableOpacity');
var View=require('View');

var invariant=require('invariant');
var rebound=require('rebound/rebound.js');
var stringifySafe=require('stringifySafe');

var SCREEN_WIDTH=require('Dimensions').get('window').width;
var IGNORED_WARNINGS_KEY='__DEV_WARNINGS_IGNORED';

var consoleWarn=console.warn.bind(console);

var warningCounts=new Map();
var ignoredWarnings=[];
var totalWarningCount=0;
var warningCountEvents=new EventEmitter();























if(__DEV__){
console.warn = function(){
consoleWarn.apply(null,arguments);
if(!console.yellowBoxEnabled){
return;}

var warning=Array.prototype.map.call(arguments,stringifySafe).join(' ');
if(!console.yellowBoxResetIgnored && 
ignoredWarnings.indexOf(warning) !== -1){
return;}

var count=warningCounts.has(warning)?warningCounts.get(warning) + 1:1;
warningCounts.set(warning,count);
totalWarningCount += 1;
warningCountEvents.emit('count',totalWarningCount);};}



function saveIgnoredWarnings(){
AsyncStorage.setItem(
IGNORED_WARNINGS_KEY,
JSON.stringify(ignoredWarnings),
function(err){
if(err){
console.warn('Could not save ignored warnings.',err);}});}





AsyncStorage.getItem(IGNORED_WARNINGS_KEY,function(err,data){
if(!err && data && !console.yellowBoxResetIgnored){
ignoredWarnings = JSON.parse(data);}});



var WarningRow=React.createClass({displayName:'WarningRow',
componentWillMount:function(){var _this=this;
this.springSystem = new rebound.SpringSystem();
this.dismissalSpring = this.springSystem.createSpring();
this.dismissalSpring.setRestSpeedThreshold(0.05);
this.dismissalSpring.setCurrentValue(0);
this.dismissalSpring.addListener({
onSpringUpdate:function(){
var val=_this.dismissalSpring.getCurrentValue();
_this.text && _this.text.setNativeProps({
left:SCREEN_WIDTH * val});

_this.container && _this.container.setNativeProps({
opacity:1 - val});

_this.closeButton && _this.closeButton.setNativeProps({
opacity:1 - val * 5});},


onSpringAtRest:function(){
if(_this.dismissalSpring.getCurrentValue()){
_this.collapseSpring.setEndValue(1);}}});



this.collapseSpring = this.springSystem.createSpring();
this.collapseSpring.setRestSpeedThreshold(0.05);
this.collapseSpring.setCurrentValue(0);
this.collapseSpring.getSpringConfig().friction = 20;
this.collapseSpring.getSpringConfig().tension = 200;
this.collapseSpring.addListener({
onSpringUpdate:function(){
var val=_this.collapseSpring.getCurrentValue();
_this.container && _this.container.setNativeProps({
height:Math.abs(46 - val * 46)});},


onSpringAtRest:function(){
_this.props.onDismissed();}});


this.panGesture = PanResponder.create({
onStartShouldSetPanResponder:function(){
return !!_this.dismissalSpring.getCurrentValue();},

onMoveShouldSetPanResponder:function(){return true;},
onPanResponderGrant:function(){
_this.isResponderOnlyToBlockTouches = 
!!_this.dismissalSpring.getCurrentValue();},

onPanResponderMove:function(e,gestureState){
if(_this.isResponderOnlyToBlockTouches){
return;}

_this.dismissalSpring.setCurrentValue(gestureState.dx / SCREEN_WIDTH);},

onPanResponderRelease:function(e,gestureState){
if(_this.isResponderOnlyToBlockTouches){
return;}

var gestureCompletion=gestureState.dx / SCREEN_WIDTH;
var doesGestureRelease=gestureState.vx + gestureCompletion > 0.5;
_this.dismissalSpring.setEndValue(doesGestureRelease?1:0);}});},



render:function(){var _this2=this;
var countText;
if(warningCounts.get(this.props.warning) > 1){
countText = 
React.createElement(Text,{style:styles.bold},'(',
warningCounts.get(this.props.warning),')',' ');}



return (
React.createElement(View,_extends({
style:styles.warningBox,
ref:function(container){_this2.container = container;}},
this.panGesture.panHandlers),
React.createElement(TouchableOpacity,{
onPress:this.props.onOpened},
React.createElement(View,null,
React.createElement(Text,{
style:styles.warningText,
numberOfLines:2,
ref:function(text){_this2.text = text;}},
countText,
this.props.warning))),



React.createElement(View,{
ref:function(closeButton){_this2.closeButton = closeButton;},
style:styles.closeButton},
React.createElement(TouchableOpacity,{
onPress:function(){
_this2.dismissalSpring.setEndValue(1);}},

React.createElement(Text,{style:styles.closeButtonText},'✕')))));}});







var WarningBoxOpened=React.createClass({displayName:'WarningBoxOpened',
render:function(){
var countText;
if(warningCounts.get(this.props.warning) > 1){
countText = 
React.createElement(Text,{style:styles.bold},'(',
warningCounts.get(this.props.warning),')',' ');}



return (
React.createElement(TouchableOpacity,{
activeOpacity:0.9,
onPress:this.props.onClose},
React.createElement(View,{style:styles.yellowBox},
React.createElement(Text,{style:styles.yellowBoxText},
countText,
this.props.warning),

React.createElement(View,{style:styles.yellowBoxButtons},
React.createElement(View,{style:styles.yellowBoxButton},
React.createElement(TouchableOpacity,{
onPress:this.props.onDismissed},
React.createElement(Text,{style:styles.yellowBoxButtonText},'Dismiss'))),




React.createElement(View,{style:styles.yellowBoxButton},
React.createElement(TouchableOpacity,{
onPress:this.props.onIgnored},
React.createElement(Text,{style:styles.yellowBoxButtonText},'Ignore')))))));}});











var canMountWarningBox=true;

var WarningBox=React.createClass({displayName:'WarningBox',
getInitialState:function(){
return {
totalWarningCount:totalWarningCount,
openWarning:null};},


componentWillMount:function(){
if(console.yellowBoxResetIgnored){
AsyncStorage.setItem(IGNORED_WARNINGS_KEY,'[]',function(err){
if(err){
console.warn('Could not reset ignored warnings.',err);}});


ignoredWarnings = [];}},


componentDidMount:function(){
invariant(
canMountWarningBox,
'There can only be one WarningBox');

canMountWarningBox = false;
warningCountEvents.addListener(
'count',
this._onWarningCount);},


componentWillUnmount:function(){
warningCountEvents.removeAllListeners();
canMountWarningBox = true;},

_onWarningCount:function(totalWarningCount){var _this3=this;


setImmediate(function(){
_this3.setState({totalWarningCount:totalWarningCount});});},


_onDismiss:function(warning){
warningCounts.delete(warning);
this.setState({
openWarning:null});},


render:function(){var _this4=this;
if(warningCounts.size === 0){
return React.createElement(View,null);}

if(this.state.openWarning){
return (
React.createElement(WarningBoxOpened,{
warning:this.state.openWarning,
onClose:function(){
_this4.setState({openWarning:null});},

onDismissed:this._onDismiss.bind(this,this.state.openWarning),
onIgnored:function(){
ignoredWarnings.push(_this4.state.openWarning);
saveIgnoredWarnings();
_this4._onDismiss(_this4.state.openWarning);}}));}




var warningRows=[];
warningCounts.forEach(function(count,warning){
warningRows.push(
React.createElement(WarningRow,{
key:warning,
onOpened:function(){
_this4.setState({openWarning:warning});},

onDismissed:_this4._onDismiss.bind(_this4,warning),
warning:warning}));});



return (
React.createElement(View,{style:styles.warningContainer},
warningRows));}});





var styles=StyleSheet.create({
bold:{
fontWeight:'bold'},

closeButton:{
position:'absolute',
right:0,
height:46,
width:46},

closeButtonText:{
color:'white',
fontSize:32,
position:'relative',
left:8},

warningContainer:{
position:'absolute',
left:0,
right:0,
bottom:0},

warningBox:{
position:'relative',
backgroundColor:'rgba(171, 124, 36, 0.9)',
flex:1,
height:46},

warningText:{
color:'white',
position:'absolute',
left:0,
marginLeft:15,
marginRight:46,
top:7},

yellowBox:{
backgroundColor:'rgba(171, 124, 36, 0.9)',
position:'absolute',
left:0,
right:0,
top:0,
bottom:0,
padding:15,
paddingTop:35},

yellowBoxText:{
color:'white',
fontSize:20},

yellowBoxButtons:{
flexDirection:'row',
position:'absolute',
bottom:0},

yellowBoxButton:{
flex:1,
padding:25},

yellowBoxButtonText:{
color:'white',
fontSize:16}});



module.exports = WarningBox;
});
__d('AsyncStorage',["NativeModules"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var NativeModules=require('NativeModules');
var RCTAsyncLocalStorage=NativeModules.AsyncLocalStorage;
var RCTAsyncRocksDBStorage=NativeModules.AsyncRocksDBStorage;


var RCTAsyncStorage=RCTAsyncRocksDBStorage || RCTAsyncLocalStorage;













var AsyncStorage={




getItem:function(
key,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiGet([key],function(errors,result){

var value=result && result[0] && result[0][1]?result[0][1]:null;
callback && callback(errors && convertError(errors[0]) || null,value);
if(errors){
reject(convertError(errors[0]));}else 
{
resolve(value);}});});},









setItem:function(
key,
value,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiSet([[key,value]],function(errors){
callback && callback(errors && convertError(errors[0]) || null);
if(errors){
reject(convertError(errors[0]));}else 
{
resolve(null);}});});},







removeItem:function(
key,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiRemove([key],function(errors){
callback && callback(errors && convertError(errors[0]) || null);
if(errors){
reject(convertError(errors[0]));}else 
{
resolve(null);}});});},










mergeItem:function(
key,
value,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiMerge([[key,value]],function(errors){
callback && callback(errors && convertError(errors[0]) || null);
if(errors){
reject(convertError(errors[0]));}else 
{
resolve(null);}});});},










clear:function(callback){
return new Promise(function(resolve,reject){
RCTAsyncStorage.clear(function(error){
callback && callback(convertError(error));
if(error && convertError(error)){
reject(convertError(error));}else 
{
resolve(null);}});});},








getAllKeys:function(callback){
return new Promise(function(resolve,reject){
RCTAsyncStorage.getAllKeys(function(error,keys){
callback && callback(convertError(error),keys);
if(error){
reject(convertError(error));}else 
{
resolve(keys);}});});},





















multiGet:function(
keys,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiGet(keys,function(errors,result){
var error=errors && errors.map(function(error){return convertError(error);}) || null;
callback && callback(error,result);
if(errors){
reject(error);}else 
{
resolve(result);}});});},











multiSet:function(
keyValuePairs,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiSet(keyValuePairs,function(errors){
var error=errors && errors.map(function(error){return convertError(error);}) || null;
callback && callback(error);
if(errors){
reject(error);}else 
{
resolve(null);}});});},








multiRemove:function(
keys,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiRemove(keys,function(errors){
var error=errors && errors.map(function(error){return convertError(error);}) || null;
callback && callback(error);
if(errors){
reject(error);}else 
{
resolve(null);}});});},











multiMerge:function(
keyValuePairs,
callback)
{
return new Promise(function(resolve,reject){
RCTAsyncStorage.multiMerge(keyValuePairs,function(errors){
var error=errors && errors.map(function(error){return convertError(error);}) || null;
callback && callback(error);
if(errors){
reject(error);}else 
{
resolve(null);}});});}};







if(!RCTAsyncStorage.multiMerge){
delete AsyncStorage.mergeItem;
delete AsyncStorage.multiMerge;}


function convertError(error){
if(!error){
return null;}

var out=new Error(error.message);
out.key = error.key;
return out;}


module.exports = AsyncStorage;
});
__d('RCTRenderingPerf',["ReactDefaultPerf","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactDefaultPerf=require('ReactDefaultPerf');

var invariant=require('invariant');






var perfModules=[];
var enabled=false;

var RCTRenderingPerf={

toggle:function(){
console.log('Render perfomance measurements enabled');
enabled = true;},


start:function(){
if(!enabled){
return;}


ReactDefaultPerf.start();
perfModules.forEach(function(module){return module.start();});},


stop:function(){
if(!enabled){
return;}


ReactDefaultPerf.stop();
ReactDefaultPerf.printInclusive();
ReactDefaultPerf.printWasted();

var totalRender=0;
var totalTime=0;
var measurements=ReactDefaultPerf.getLastMeasurements();
for(var ii=0;ii < measurements.length;ii++) {
var render=measurements[ii].render;
for(var nodeName in render) {
totalRender += render[nodeName];}

totalTime += measurements[ii].totalTime;}

console.log('Total time spent in render(): ' + totalRender + 'ms');

perfModules.forEach(function(module){return module.stop();});},


register:function(module){
invariant(
typeof module.start === 'function',
'Perf module should have start() function');

invariant(
typeof module.stop === 'function',
'Perf module should have stop() function');

perfModules.push(module);}};



module.exports = RCTRenderingPerf;
});
__d('ReactDefaultPerf',["DOMProperty","ReactDefaultPerfAnalysis","ReactMount","ReactPerf","performanceNow"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var DOMProperty=require('DOMProperty');
var ReactDefaultPerfAnalysis=require('ReactDefaultPerfAnalysis');
var ReactMount=require('ReactMount');
var ReactPerf=require('ReactPerf');

var performanceNow=require('performanceNow');

function roundFloat(val){
return Math.floor(val * 100) / 100;}


function addValue(obj,key,val){
obj[key] = (obj[key] || 0) + val;}


var ReactDefaultPerf={
_allMeasurements:[],
_mountStack:[0],
_injected:false,

start:function(){
if(!ReactDefaultPerf._injected){
ReactPerf.injection.injectMeasure(ReactDefaultPerf.measure);}


ReactDefaultPerf._allMeasurements.length = 0;
ReactPerf.enableMeasure = true;},


stop:function(){
ReactPerf.enableMeasure = false;},


getLastMeasurements:function(){
return ReactDefaultPerf._allMeasurements;},


printExclusive:function(measurements){
measurements = measurements || ReactDefaultPerf._allMeasurements;
var summary=ReactDefaultPerfAnalysis.getExclusiveSummary(measurements);
console.table(summary.map(function(item){
return {
'Component class name':item.componentName,
'Total inclusive time (ms)':roundFloat(item.inclusive),
'Exclusive mount time (ms)':roundFloat(item.exclusive),
'Exclusive render time (ms)':roundFloat(item.render),
'Mount time per instance (ms)':roundFloat(item.exclusive / item.count),
'Render time per instance (ms)':roundFloat(item.render / item.count),
'Instances':item.count};}));},






printInclusive:function(measurements){
measurements = measurements || ReactDefaultPerf._allMeasurements;
var summary=ReactDefaultPerfAnalysis.getInclusiveSummary(measurements);
console.table(summary.map(function(item){
return {
'Owner > component':item.componentName,
'Inclusive time (ms)':roundFloat(item.time),
'Instances':item.count};}));


console.log(
'Total time:',
ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms');},



getMeasurementsSummaryMap:function(measurements){
var summary=ReactDefaultPerfAnalysis.getInclusiveSummary(
measurements,
true);

return summary.map(function(item){
return {
'Owner > component':item.componentName,
'Wasted time (ms)':item.time,
'Instances':item.count};});},




printWasted:function(measurements){
measurements = measurements || ReactDefaultPerf._allMeasurements;
console.table(ReactDefaultPerf.getMeasurementsSummaryMap(measurements));
console.log(
'Total time:',
ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms');},



printDOM:function(measurements){
measurements = measurements || ReactDefaultPerf._allMeasurements;
var summary=ReactDefaultPerfAnalysis.getDOMSummary(measurements);
console.table(summary.map(function(item){
var result={};
result[DOMProperty.ID_ATTRIBUTE_NAME] = item.id;
result['type'] = item.type;
result['args'] = JSON.stringify(item.args);
return result;}));

console.log(
'Total time:',
ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms');},



_recordWrite:function(id,fnName,totalTime,args){

var writes=
ReactDefaultPerf.
_allMeasurements[ReactDefaultPerf._allMeasurements.length - 1].
writes;
writes[id] = writes[id] || [];
writes[id].push({
type:fnName,
time:totalTime,
args:args});},



measure:function(moduleName,fnName,func){
return function(){for(var _len=arguments.length,args=Array(_len),_key=0;_key < _len;_key++) {args[_key] = arguments[_key];}
var totalTime;
var rv;
var start;

if(fnName === '_renderNewRootComponent' || 
fnName === 'flushBatchedUpdates'){




ReactDefaultPerf._allMeasurements.push({
exclusive:{},
inclusive:{},
render:{},
counts:{},
writes:{},
displayNames:{},
totalTime:0});

start = performanceNow();
rv = func.apply(this,args);
ReactDefaultPerf._allMeasurements[
ReactDefaultPerf._allMeasurements.length - 1].
totalTime = performanceNow() - start;
return rv;}else 
if(fnName === '_mountImageIntoNode' || 
moduleName === 'ReactDOMIDOperations'){
start = performanceNow();
rv = func.apply(this,args);
totalTime = performanceNow() - start;

if(fnName === '_mountImageIntoNode'){
var mountID=ReactMount.getID(args[1]);
ReactDefaultPerf._recordWrite(mountID,fnName,totalTime,args[0]);}else 
if(fnName === 'dangerouslyProcessChildrenUpdates'){

args[0].forEach(function(update){
var writeArgs={};
if(update.fromIndex !== null){
writeArgs.fromIndex = update.fromIndex;}

if(update.toIndex !== null){
writeArgs.toIndex = update.toIndex;}

if(update.textContent !== null){
writeArgs.textContent = update.textContent;}

if(update.markupIndex !== null){
writeArgs.markup = args[1][update.markupIndex];}

ReactDefaultPerf._recordWrite(
update.parentID,
update.type,
totalTime,
writeArgs);});}else 


{

ReactDefaultPerf._recordWrite(
args[0],
fnName,
totalTime,
Array.prototype.slice.call(args,1));}


return rv;}else 
if(moduleName === 'ReactCompositeComponent' && (
fnName === 'mountComponent' || 
fnName === 'updateComponent' || 
fnName === '_renderValidatedComponent')){

if(typeof this._currentElement.type === 'string'){
return func.apply(this,args);}


var rootNodeID=fnName === 'mountComponent'?
args[0]:
this._rootNodeID;
var isRender=fnName === '_renderValidatedComponent';
var isMount=fnName === 'mountComponent';

var mountStack=ReactDefaultPerf._mountStack;
var entry=ReactDefaultPerf._allMeasurements[
ReactDefaultPerf._allMeasurements.length - 1];


if(isRender){
addValue(entry.counts,rootNodeID,1);}else 
if(isMount){
mountStack.push(0);}


start = performanceNow();
rv = func.apply(this,args);
totalTime = performanceNow() - start;

if(isRender){
addValue(entry.render,rootNodeID,totalTime);}else 
if(isMount){
var subMountTime=mountStack.pop();
mountStack[mountStack.length - 1] += totalTime;
addValue(entry.exclusive,rootNodeID,totalTime - subMountTime);
addValue(entry.inclusive,rootNodeID,totalTime);}else 
{
addValue(entry.inclusive,rootNodeID,totalTime);}


entry.displayNames[rootNodeID] = {
current:this.getName(),
owner:this._currentElement._owner?
this._currentElement._owner.getName():
'<root>'};


return rv;}else 
{
return func.apply(this,args);}};}};





module.exports = ReactDefaultPerf;
});
__d('DOMProperty',["invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';















var invariant=require('invariant');

function checkMask(value,bitmask){
return (value & bitmask) === bitmask;}


var DOMPropertyInjection={




MUST_USE_ATTRIBUTE:0x1,
MUST_USE_PROPERTY:0x2,
HAS_SIDE_EFFECTS:0x4,
HAS_BOOLEAN_VALUE:0x8,
HAS_NUMERIC_VALUE:0x10,
HAS_POSITIVE_NUMERIC_VALUE:0x20 | 0x10,
HAS_OVERLOADED_BOOLEAN_VALUE:0x40,


























injectDOMPropertyConfig:function(domPropertyConfig){
var Properties=domPropertyConfig.Properties || {};
var DOMAttributeNames=domPropertyConfig.DOMAttributeNames || {};
var DOMPropertyNames=domPropertyConfig.DOMPropertyNames || {};
var DOMMutationMethods=domPropertyConfig.DOMMutationMethods || {};

if(domPropertyConfig.isCustomAttribute){
DOMProperty._isCustomAttributeFunctions.push(
domPropertyConfig.isCustomAttribute);}



for(var propName in Properties) {
invariant(
!DOMProperty.isStandardName.hasOwnProperty(propName),
'injectDOMPropertyConfig(...): You\'re trying to inject DOM property ' + 
'\'%s\' which has already been injected. You may be accidentally ' + 
'injecting the same DOM property config twice, or you may be ' + 
'injecting two configs that have conflicting property names.',
propName);


DOMProperty.isStandardName[propName] = true;

var lowerCased=propName.toLowerCase();
DOMProperty.getPossibleStandardName[lowerCased] = propName;

if(DOMAttributeNames.hasOwnProperty(propName)){
var attributeName=DOMAttributeNames[propName];
DOMProperty.getPossibleStandardName[attributeName] = propName;
DOMProperty.getAttributeName[propName] = attributeName;}else 
{
DOMProperty.getAttributeName[propName] = lowerCased;}


DOMProperty.getPropertyName[propName] = 
DOMPropertyNames.hasOwnProperty(propName)?
DOMPropertyNames[propName]:
propName;

if(DOMMutationMethods.hasOwnProperty(propName)){
DOMProperty.getMutationMethod[propName] = DOMMutationMethods[propName];}else 
{
DOMProperty.getMutationMethod[propName] = null;}


var propConfig=Properties[propName];
DOMProperty.mustUseAttribute[propName] = 
checkMask(propConfig,DOMPropertyInjection.MUST_USE_ATTRIBUTE);
DOMProperty.mustUseProperty[propName] = 
checkMask(propConfig,DOMPropertyInjection.MUST_USE_PROPERTY);
DOMProperty.hasSideEffects[propName] = 
checkMask(propConfig,DOMPropertyInjection.HAS_SIDE_EFFECTS);
DOMProperty.hasBooleanValue[propName] = 
checkMask(propConfig,DOMPropertyInjection.HAS_BOOLEAN_VALUE);
DOMProperty.hasNumericValue[propName] = 
checkMask(propConfig,DOMPropertyInjection.HAS_NUMERIC_VALUE);
DOMProperty.hasPositiveNumericValue[propName] = 
checkMask(propConfig,DOMPropertyInjection.HAS_POSITIVE_NUMERIC_VALUE);
DOMProperty.hasOverloadedBooleanValue[propName] = 
checkMask(propConfig,DOMPropertyInjection.HAS_OVERLOADED_BOOLEAN_VALUE);

invariant(
!DOMProperty.mustUseAttribute[propName] || 
!DOMProperty.mustUseProperty[propName],
'DOMProperty: Cannot require using both attribute and property: %s',
propName);

invariant(
DOMProperty.mustUseProperty[propName] || 
!DOMProperty.hasSideEffects[propName],
'DOMProperty: Properties that have side effects must use property: %s',
propName);

invariant(
!!DOMProperty.hasBooleanValue[propName] + 
!!DOMProperty.hasNumericValue[propName] + 
!!DOMProperty.hasOverloadedBooleanValue[propName] <= 1,
'DOMProperty: Value can be one of boolean, overloaded boolean, or ' + 
'numeric value, but not a combination: %s',
propName);}}};




var defaultValueCache={};














var DOMProperty={

ID_ATTRIBUTE_NAME:'data-reactid',





isStandardName:{},






getPossibleStandardName:{},






getAttributeName:{},






getPropertyName:{},






getMutationMethod:{},





mustUseAttribute:{},






mustUseProperty:{},







hasSideEffects:{},





hasBooleanValue:{},






hasNumericValue:{},






hasPositiveNumericValue:{},







hasOverloadedBooleanValue:{},




_isCustomAttributeFunctions:[],





isCustomAttribute:function(attributeName){
for(var i=0;i < DOMProperty._isCustomAttributeFunctions.length;i++) {
var isCustomAttributeFn=DOMProperty._isCustomAttributeFunctions[i];
if(isCustomAttributeFn(attributeName)){
return true;}}


return false;},










getDefaultValueForProperty:function(nodeName,prop){
var nodeDefaults=defaultValueCache[nodeName];
var testElement;
if(!nodeDefaults){
defaultValueCache[nodeName] = nodeDefaults = {};}

if(!(prop in nodeDefaults)){
testElement = document.createElement(nodeName);
nodeDefaults[prop] = testElement[prop];}

return nodeDefaults[prop];},


injection:DOMPropertyInjection};


module.exports = DOMProperty;
});
__d('ReactDefaultPerfAnalysis',["Object.assign"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 










assign=require('Object.assign');


var DONT_CARE_THRESHOLD=1.2;
var DOM_OPERATION_TYPES={
'_mountImageIntoNode':'set innerHTML',
INSERT_MARKUP:'set innerHTML',
MOVE_EXISTING:'move',
REMOVE_NODE:'remove',
TEXT_CONTENT:'set textContent',
'updatePropertyByID':'update attribute',
'deletePropertyByID':'delete attribute',
'updateStylesByID':'update styles',
'updateInnerHTMLByID':'set innerHTML',
'dangerouslyReplaceNodeWithMarkupByID':'replace'};


function getTotalTime(measurements){




var totalTime=0;
for(var i=0;i < measurements.length;i++) {
var measurement=measurements[i];
totalTime += measurement.totalTime;}

return totalTime;}


function getDOMSummary(measurements){
var items=[];
for(var i=0;i < measurements.length;i++) {
var measurement=measurements[i];
var id;

for(id in measurement.writes) {
measurement.writes[id].forEach(function(write){
items.push({
id:id,
type:DOM_OPERATION_TYPES[write.type] || write.type,
args:write.args});});}}




return items;}


function getExclusiveSummary(measurements){
var candidates={};
var displayName;

for(var i=0;i < measurements.length;i++) {
var measurement=measurements[i];
var allIDs=assign(
{},
measurement.exclusive,
measurement.inclusive);


for(var id in allIDs) {
displayName = measurement.displayNames[id].current;

candidates[displayName] = candidates[displayName] || {
componentName:displayName,
inclusive:0,
exclusive:0,
render:0,
count:0};

if(measurement.render[id]){
candidates[displayName].render += measurement.render[id];}

if(measurement.exclusive[id]){
candidates[displayName].exclusive += measurement.exclusive[id];}

if(measurement.inclusive[id]){
candidates[displayName].inclusive += measurement.inclusive[id];}

if(measurement.counts[id]){
candidates[displayName].count += measurement.counts[id];}}}





var arr=[];
for(displayName in candidates) {
if(candidates[displayName].exclusive >= DONT_CARE_THRESHOLD){
arr.push(candidates[displayName]);}}



arr.sort(function(a,b){
return b.exclusive - a.exclusive;});


return arr;}


function getInclusiveSummary(measurements,onlyClean){
var candidates={};
var inclusiveKey;

for(var i=0;i < measurements.length;i++) {
var measurement=measurements[i];
var allIDs=assign(
{},
measurement.exclusive,
measurement.inclusive);

var cleanComponents;

if(onlyClean){
cleanComponents = getUnchangedComponents(measurement);}


for(var id in allIDs) {
if(onlyClean && !cleanComponents[id]){
continue;}


var displayName=measurement.displayNames[id];




inclusiveKey = displayName.owner + ' > ' + displayName.current;

candidates[inclusiveKey] = candidates[inclusiveKey] || {
componentName:inclusiveKey,
time:0,
count:0};


if(measurement.inclusive[id]){
candidates[inclusiveKey].time += measurement.inclusive[id];}

if(measurement.counts[id]){
candidates[inclusiveKey].count += measurement.counts[id];}}}





var arr=[];
for(inclusiveKey in candidates) {
if(candidates[inclusiveKey].time >= DONT_CARE_THRESHOLD){
arr.push(candidates[inclusiveKey]);}}



arr.sort(function(a,b){
return b.time - a.time;});


return arr;}


function getUnchangedComponents(measurement){



var cleanComponents={};
var dirtyLeafIDs=Object.keys(measurement.writes);
var allIDs=assign({},measurement.exclusive,measurement.inclusive);

for(var id in allIDs) {
var isDirty=false;


for(var i=0;i < dirtyLeafIDs.length;i++) {
if(dirtyLeafIDs[i].indexOf(id) === 0){
isDirty = true;
break;}}


if(!isDirty && measurement.counts[id] > 0){
cleanComponents[id] = true;}}


return cleanComponents;}


var ReactDefaultPerfAnalysis={
getExclusiveSummary:getExclusiveSummary,
getInclusiveSummary:getInclusiveSummary,
getDOMSummary:getDOMSummary,
getTotalTime:getTotalTime};


module.exports = ReactDefaultPerfAnalysis;
});
__d('ReactMount',["DOMProperty","ReactBrowserEventEmitter","ReactCurrentOwner","ReactElement","ReactElementValidator","ReactEmptyComponent","ReactInstanceHandles","ReactInstanceMap","ReactMarkupChecksum","ReactPerf","ReactReconciler","ReactUpdateQueue","ReactUpdates","emptyObject","containsNode","getReactRootElementInContainer","instantiateReactComponent","invariant","setInnerHTML","shouldUpdateReactComponent","warning"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var DOMProperty=require('DOMProperty');
var ReactBrowserEventEmitter=require('ReactBrowserEventEmitter');
var ReactCurrentOwner=require('ReactCurrentOwner');
var ReactElement=require('ReactElement');
var ReactElementValidator=require('ReactElementValidator');
var ReactEmptyComponent=require('ReactEmptyComponent');
var ReactInstanceHandles=require('ReactInstanceHandles');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactMarkupChecksum=require('ReactMarkupChecksum');
var ReactPerf=require('ReactPerf');
var ReactReconciler=require('ReactReconciler');
var ReactUpdateQueue=require('ReactUpdateQueue');
var ReactUpdates=require('ReactUpdates');

var emptyObject=require('emptyObject');
var containsNode=require('containsNode');
var getReactRootElementInContainer=require('getReactRootElementInContainer');
var instantiateReactComponent=require('instantiateReactComponent');
var invariant=require('invariant');
var setInnerHTML=require('setInnerHTML');
var shouldUpdateReactComponent=require('shouldUpdateReactComponent');
var warning=require('warning');

var SEPARATOR=ReactInstanceHandles.SEPARATOR;

var ATTR_NAME=DOMProperty.ID_ATTRIBUTE_NAME;
var nodeCache={};

var ELEMENT_NODE_TYPE=1;
var DOC_NODE_TYPE=9;


var instancesByReactRootID={};


var containersByReactRootID={};

if(__DEV__){

var rootElementsByReactRootID={};}



var findComponentRootReusableArray=[];







function firstDifferenceIndex(string1,string2){
var minLen=Math.min(string1.length,string2.length);
for(var i=0;i < minLen;i++) {
if(string1.charAt(i) !== string2.charAt(i)){
return i;}}


return string1.length === string2.length?-1:minLen;}






function getReactRootID(container){
var rootElement=getReactRootElementInContainer(container);
return rootElement && ReactMount.getID(rootElement);}












function getID(node){
var id=internalGetID(node);
if(id){
if(nodeCache.hasOwnProperty(id)){
var cached=nodeCache[id];
if(cached !== node){
invariant(
!isValid(cached,id),
'ReactMount: Two valid but unequal nodes with the same `%s`: %s',
ATTR_NAME,id);


nodeCache[id] = node;}}else 

{
nodeCache[id] = node;}}



return id;}


function internalGetID(node){



return node && node.getAttribute && node.getAttribute(ATTR_NAME) || '';}








function setID(node,id){
var oldID=internalGetID(node);
if(oldID !== id){
delete nodeCache[oldID];}

node.setAttribute(ATTR_NAME,id);
nodeCache[id] = node;}









function getNode(id){
if(!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id],id)){
nodeCache[id] = ReactMount.findReactNodeByID(id);}

return nodeCache[id];}









function getNodeFromInstance(instance){
var id=ReactInstanceMap.get(instance)._rootNodeID;
if(ReactEmptyComponent.isNullComponentID(id)){
return null;}

if(!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id],id)){
nodeCache[id] = ReactMount.findReactNodeByID(id);}

return nodeCache[id];}












function isValid(node,id){
if(node){
invariant(
internalGetID(node) === id,
'ReactMount: Unexpected modification of `%s`',
ATTR_NAME);


var container=ReactMount.findReactContainerForID(id);
if(container && containsNode(container,node)){
return true;}}



return false;}







function purgeID(id){
delete nodeCache[id];}


var deepestNodeSoFar=null;
function findDeepestCachedAncestorImpl(ancestorID){
var ancestor=nodeCache[ancestorID];
if(ancestor && isValid(ancestor,ancestorID)){
deepestNodeSoFar = ancestor;}else 
{


return false;}}






function findDeepestCachedAncestor(targetID){
deepestNodeSoFar = null;
ReactInstanceHandles.traverseAncestors(
targetID,
findDeepestCachedAncestorImpl);


var foundNode=deepestNodeSoFar;
deepestNodeSoFar = null;
return foundNode;}











function mountComponentIntoNode(
componentInstance,
rootID,
container,
transaction,
shouldReuseMarkup){
var markup=ReactReconciler.mountComponent(
componentInstance,rootID,transaction,emptyObject);

componentInstance._isTopLevel = true;
ReactMount._mountImageIntoNode(markup,container,shouldReuseMarkup);}










function batchedMountComponentIntoNode(
componentInstance,
rootID,
container,
shouldReuseMarkup){
var transaction=ReactUpdates.ReactReconcileTransaction.getPooled();
transaction.perform(
mountComponentIntoNode,
null,
componentInstance,
rootID,
container,
transaction,
shouldReuseMarkup);

ReactUpdates.ReactReconcileTransaction.release(transaction);}




















var ReactMount={

_instancesByReactRootID:instancesByReactRootID,









scrollMonitor:function(container,renderCallback){
renderCallback();},









_updateRootComponent:function(
prevComponent,
nextElement,
container,
callback){
if(__DEV__){
ReactElementValidator.checkAndWarnForMutatedProps(nextElement);}


ReactMount.scrollMonitor(container,function(){
ReactUpdateQueue.enqueueElementInternal(prevComponent,nextElement);
if(callback){
ReactUpdateQueue.enqueueCallbackInternal(prevComponent,callback);}});



if(__DEV__){

rootElementsByReactRootID[getReactRootID(container)] = 
getReactRootElementInContainer(container);}


return prevComponent;},









_registerComponent:function(nextComponent,container){
invariant(
container && (
container.nodeType === ELEMENT_NODE_TYPE || 
container.nodeType === DOC_NODE_TYPE),

'_registerComponent(...): Target container is not a DOM element.');


ReactBrowserEventEmitter.ensureScrollValueMonitoring();

var reactRootID=ReactMount.registerContainer(container);
instancesByReactRootID[reactRootID] = nextComponent;
return reactRootID;},









_renderNewRootComponent:function(
nextElement,
container,
shouldReuseMarkup)
{



warning(
ReactCurrentOwner.current == null,
'_renderNewRootComponent(): Render methods should be a pure function ' + 
'of props and state; triggering nested component updates from ' + 
'render is not allowed. If necessary, trigger nested updates in ' + 
'componentDidUpdate.');


var componentInstance=instantiateReactComponent(nextElement,null);
var reactRootID=ReactMount._registerComponent(
componentInstance,
container);






ReactUpdates.batchedUpdates(
batchedMountComponentIntoNode,
componentInstance,
reactRootID,
container,
shouldReuseMarkup);


if(__DEV__){

rootElementsByReactRootID[reactRootID] = 
getReactRootElementInContainer(container);}


return componentInstance;},














render:function(nextElement,container,callback){
invariant(
ReactElement.isValidElement(nextElement),
'React.render(): Invalid component element.%s',

typeof nextElement === 'string'?
' Instead of passing an element string, make sure to instantiate ' + 
'it by passing it to React.createElement.':
typeof nextElement === 'function'?
' Instead of passing a component class, make sure to instantiate ' + 
'it by passing it to React.createElement.':

nextElement != null && nextElement.props !== undefined?
' This may be caused by unintentionally loading two independent ' + 
'copies of React.':
'');



var prevComponent=instancesByReactRootID[getReactRootID(container)];

if(prevComponent){
var prevElement=prevComponent._currentElement;
if(shouldUpdateReactComponent(prevElement,nextElement)){
return ReactMount._updateRootComponent(
prevComponent,
nextElement,
container,
callback).
getPublicInstance();}else 
{
ReactMount.unmountComponentAtNode(container);}}



var reactRootElement=getReactRootElementInContainer(container);
var containerHasReactMarkup=
reactRootElement && ReactMount.isRenderedByReact(reactRootElement);

if(__DEV__){
if(!containerHasReactMarkup || reactRootElement.nextSibling){
var rootElementSibling=reactRootElement;
while(rootElementSibling) {
if(ReactMount.isRenderedByReact(rootElementSibling)){
warning(
false,
'render(): Target node has markup rendered by React, but there ' + 
'are unrelated nodes as well. This is most commonly caused by ' + 
'white-space inserted around server-rendered markup.');

break;}


rootElementSibling = rootElementSibling.nextSibling;}}}




var shouldReuseMarkup=containerHasReactMarkup && !prevComponent;

var component=ReactMount._renderNewRootComponent(
nextElement,
container,
shouldReuseMarkup).
getPublicInstance();
if(callback){
callback.call(component);}

return component;},











constructAndRenderComponent:function(constructor,props,container){
var element=ReactElement.createElement(constructor,props);
return ReactMount.render(element,container);},











constructAndRenderComponentByID:function(constructor,props,id){
var domNode=document.getElementById(id);
invariant(
domNode,
'Tried to get element with id of "%s" but it is not present on the page.',
id);

return ReactMount.constructAndRenderComponent(constructor,props,domNode);},










registerContainer:function(container){
var reactRootID=getReactRootID(container);
if(reactRootID){

reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID);}

if(!reactRootID){

reactRootID = ReactInstanceHandles.createReactRootID();}

containersByReactRootID[reactRootID] = container;
return reactRootID;},









unmountComponentAtNode:function(container){




warning(
ReactCurrentOwner.current == null,
'unmountComponentAtNode(): Render methods should be a pure function of ' + 
'props and state; triggering nested component updates from render is ' + 
'not allowed. If necessary, trigger nested updates in ' + 
'componentDidUpdate.');


invariant(
container && (
container.nodeType === ELEMENT_NODE_TYPE || 
container.nodeType === DOC_NODE_TYPE),

'unmountComponentAtNode(...): Target container is not a DOM element.');


var reactRootID=getReactRootID(container);
var component=instancesByReactRootID[reactRootID];
if(!component){
return false;}

ReactMount.unmountComponentFromNode(component,container);
delete instancesByReactRootID[reactRootID];
delete containersByReactRootID[reactRootID];
if(__DEV__){
delete rootElementsByReactRootID[reactRootID];}

return true;},











unmountComponentFromNode:function(instance,container){
ReactReconciler.unmountComponent(instance);

if(container.nodeType === DOC_NODE_TYPE){
container = container.documentElement;}



while(container.lastChild) {
container.removeChild(container.lastChild);}},










findReactContainerForID:function(id){
var reactRootID=ReactInstanceHandles.getReactRootIDFromNodeID(id);
var container=containersByReactRootID[reactRootID];

if(__DEV__){
var rootElement=rootElementsByReactRootID[reactRootID];
if(rootElement && rootElement.parentNode !== container){
invariant(


internalGetID(rootElement) === reactRootID,
'ReactMount: Root element ID differed from reactRootID.');


var containerChild=container.firstChild;
if(containerChild && 
reactRootID === internalGetID(containerChild)){




rootElementsByReactRootID[reactRootID] = containerChild;}else 
{
warning(
false,
'ReactMount: Root element has been removed from its original ' + 
'container. New container:',rootElement.parentNode);}}}





return container;},








findReactNodeByID:function(id){
var reactRoot=ReactMount.findReactContainerForID(id);
return ReactMount.findComponentRoot(reactRoot,id);},









isRenderedByReact:function(node){
if(node.nodeType !== 1){

return false;}

var id=ReactMount.getID(node);
return id?id.charAt(0) === SEPARATOR:false;},










getFirstReactDOM:function(node){
var current=node;
while(current && current.parentNode !== current) {
if(ReactMount.isRenderedByReact(current)){
return current;}

current = current.parentNode;}

return null;},












findComponentRoot:function(ancestorNode,targetID){
var firstChildren=findComponentRootReusableArray;
var childIndex=0;

var deepestAncestor=findDeepestCachedAncestor(targetID) || ancestorNode;

firstChildren[0] = deepestAncestor.firstChild;
firstChildren.length = 1;

while(childIndex < firstChildren.length) {
var child=firstChildren[childIndex++];
var targetChild;

while(child) {
var childID=ReactMount.getID(child);
if(childID){





if(targetID === childID){
targetChild = child;}else 
if(ReactInstanceHandles.isAncestorIDOf(childID,targetID)){




firstChildren.length = childIndex = 0;
firstChildren.push(child.firstChild);}}else 


{





firstChildren.push(child.firstChild);}


child = child.nextSibling;}


if(targetChild){



firstChildren.length = 0;

return targetChild;}}



firstChildren.length = 0;

invariant(
false,
'findComponentRoot(..., %s): Unable to find element. This probably ' + 
'means the DOM was unexpectedly mutated (e.g., by the browser), ' + 
'usually due to forgetting a <tbody> when using tables, nesting tags ' + 
'like <form>, <p>, or <a>, or using non-SVG elements in an <svg> ' + 
'parent. ' + 
'Try inspecting the child nodes of the element with React ID `%s`.',
targetID,
ReactMount.getID(ancestorNode));},



_mountImageIntoNode:function(markup,container,shouldReuseMarkup){
invariant(
container && (
container.nodeType === ELEMENT_NODE_TYPE || 
container.nodeType === DOC_NODE_TYPE),

'mountComponentIntoNode(...): Target container is not valid.');


if(shouldReuseMarkup){
var rootElement=getReactRootElementInContainer(container);
if(ReactMarkupChecksum.canReuseMarkup(markup,rootElement)){
return;}else 
{
var checksum=rootElement.getAttribute(
ReactMarkupChecksum.CHECKSUM_ATTR_NAME);

rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);

var rootMarkup=rootElement.outerHTML;
rootElement.setAttribute(
ReactMarkupChecksum.CHECKSUM_ATTR_NAME,
checksum);


var diffIndex=firstDifferenceIndex(markup,rootMarkup);
var difference=' (client) ' + 
markup.substring(diffIndex - 20,diffIndex + 20) + 
'\n (server) ' + rootMarkup.substring(diffIndex - 20,diffIndex + 20);

invariant(
container.nodeType !== DOC_NODE_TYPE,
'You\'re trying to render a component to the document using ' + 
'server rendering but the checksum was invalid. This usually ' + 
'means you rendered a different component type or props on ' + 
'the client from the one on the server, or your render() ' + 
'methods are impure. React cannot handle this case due to ' + 
'cross-browser quirks by rendering at the document root. You ' + 
'should look for environment dependent code in your components ' + 
'and ensure the props are the same client and server side:\n%s',
difference);


if(__DEV__){
warning(
false,
'React attempted to reuse markup in a container but the ' + 
'checksum was invalid. This generally means that you are ' + 
'using server rendering and the markup generated on the ' + 
'server was not what the client was expecting. React injected ' + 
'new markup to compensate which works but you have lost many ' + 
'of the benefits of server rendering. Instead, figure out ' + 
'why the markup being generated is different on the client ' + 
'or server:\n%s',
difference);}}}





invariant(
container.nodeType !== DOC_NODE_TYPE,
'You\'re trying to render a component to the document but ' + 
'you didn\'t use server rendering. We can\'t do this ' + 
'without using server rendering due to cross-browser quirks. ' + 
'See React.renderToString() for server rendering.');


setInnerHTML(container,markup);},






getReactRootID:getReactRootID,

getID:getID,

setID:setID,

getNode:getNode,

getNodeFromInstance:getNodeFromInstance,

purgeID:purgeID};


ReactPerf.measureMethods(ReactMount,'ReactMount',{
_renderNewRootComponent:'_renderNewRootComponent',
_mountImageIntoNode:'_mountImageIntoNode'});


module.exports = ReactMount;
});
__d('ReactBrowserEventEmitter',["EventConstants","EventPluginHub","EventPluginRegistry","ReactEventEmitterMixin","ViewportMetrics","Object.assign","isEventSupported"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var EventConstants=require('EventConstants');
var EventPluginHub=require('EventPluginHub');
var EventPluginRegistry=require('EventPluginRegistry');
var ReactEventEmitterMixin=require('ReactEventEmitterMixin');
var ViewportMetrics=require('ViewportMetrics');

var assign=require('Object.assign');
var isEventSupported=require('isEventSupported');
























































var alreadyListeningTo={};
var isMonitoringScrollValue=false;
var reactTopListenersCounter=0;




var topEventMapping={
topBlur:'blur',
topChange:'change',
topClick:'click',
topCompositionEnd:'compositionend',
topCompositionStart:'compositionstart',
topCompositionUpdate:'compositionupdate',
topContextMenu:'contextmenu',
topCopy:'copy',
topCut:'cut',
topDoubleClick:'dblclick',
topDrag:'drag',
topDragEnd:'dragend',
topDragEnter:'dragenter',
topDragExit:'dragexit',
topDragLeave:'dragleave',
topDragOver:'dragover',
topDragStart:'dragstart',
topDrop:'drop',
topFocus:'focus',
topInput:'input',
topKeyDown:'keydown',
topKeyPress:'keypress',
topKeyUp:'keyup',
topMouseDown:'mousedown',
topMouseMove:'mousemove',
topMouseOut:'mouseout',
topMouseOver:'mouseover',
topMouseUp:'mouseup',
topPaste:'paste',
topScroll:'scroll',
topSelectionChange:'selectionchange',
topTextInput:'textInput',
topTouchCancel:'touchcancel',
topTouchEnd:'touchend',
topTouchMove:'touchmove',
topTouchStart:'touchstart',
topWheel:'wheel'};





var topListenersIDKey='_reactListenersID' + String(Math.random()).slice(2);

function getListeningForDocument(mountAt){


if(!Object.prototype.hasOwnProperty.call(mountAt,topListenersIDKey)){
mountAt[topListenersIDKey] = reactTopListenersCounter++;
alreadyListeningTo[mountAt[topListenersIDKey]] = {};}

return alreadyListeningTo[mountAt[topListenersIDKey]];}












var ReactBrowserEventEmitter=assign({},ReactEventEmitterMixin,{




ReactEventListener:null,

injection:{



injectReactEventListener:function(ReactEventListener){
ReactEventListener.setHandleTopLevel(
ReactBrowserEventEmitter.handleTopLevel);

ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;}},








setEnabled:function(enabled){
if(ReactBrowserEventEmitter.ReactEventListener){
ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);}},






isEnabled:function(){
return !!(
ReactBrowserEventEmitter.ReactEventListener && 
ReactBrowserEventEmitter.ReactEventListener.isEnabled());},
























listenTo:function(registrationName,contentDocumentHandle){
var mountAt=contentDocumentHandle;
var isListening=getListeningForDocument(mountAt);
var dependencies=EventPluginRegistry.
registrationNameDependencies[registrationName];

var topLevelTypes=EventConstants.topLevelTypes;
for(var i=0,l=dependencies.length;i < l;i++) {
var dependency=dependencies[i];
if(!(
isListening.hasOwnProperty(dependency) && 
isListening[dependency]))
{
if(dependency === topLevelTypes.topWheel){
if(isEventSupported('wheel')){
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
topLevelTypes.topWheel,
'wheel',
mountAt);}else 

if(isEventSupported('mousewheel')){
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
topLevelTypes.topWheel,
'mousewheel',
mountAt);}else 

{


ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
topLevelTypes.topWheel,
'DOMMouseScroll',
mountAt);}}else 


if(dependency === topLevelTypes.topScroll){

if(isEventSupported('scroll',true)){
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(
topLevelTypes.topScroll,
'scroll',
mountAt);}else 

{
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
topLevelTypes.topScroll,
'scroll',
ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE);}}else 


if(dependency === topLevelTypes.topFocus || 
dependency === topLevelTypes.topBlur){

if(isEventSupported('focus',true)){
ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(
topLevelTypes.topFocus,
'focus',
mountAt);

ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(
topLevelTypes.topBlur,
'blur',
mountAt);}else 

if(isEventSupported('focusin')){


ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
topLevelTypes.topFocus,
'focusin',
mountAt);

ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
topLevelTypes.topBlur,
'focusout',
mountAt);}




isListening[topLevelTypes.topBlur] = true;
isListening[topLevelTypes.topFocus] = true;}else 
if(topEventMapping.hasOwnProperty(dependency)){
ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
dependency,
topEventMapping[dependency],
mountAt);}



isListening[dependency] = true;}}},




trapBubbledEvent:function(topLevelType,handlerBaseName,handle){
return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(
topLevelType,
handlerBaseName,
handle);},



trapCapturedEvent:function(topLevelType,handlerBaseName,handle){
return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(
topLevelType,
handlerBaseName,
handle);},











ensureScrollValueMonitoring:function(){
if(!isMonitoringScrollValue){
var refresh=ViewportMetrics.refreshScrollValues;
ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);
isMonitoringScrollValue = true;}},



eventNameDispatchConfigs:EventPluginHub.eventNameDispatchConfigs,

registrationNameModules:EventPluginHub.registrationNameModules,

putListener:EventPluginHub.putListener,

getListener:EventPluginHub.getListener,

deleteListener:EventPluginHub.deleteListener,

deleteAllListeners:EventPluginHub.deleteAllListeners});



module.exports = ReactBrowserEventEmitter;
});
__d('ViewportMetrics',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ViewportMetrics={

currentScrollLeft:0,

currentScrollTop:0,

refreshScrollValues:function(scrollPosition){
ViewportMetrics.currentScrollLeft = scrollPosition.x;
ViewportMetrics.currentScrollTop = scrollPosition.y;}};




module.exports = ViewportMetrics;
});
__d('isEventSupported',["ExecutionEnvironment"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ExecutionEnvironment=require('ExecutionEnvironment');

var useHasFeature;
if(ExecutionEnvironment.canUseDOM){
useHasFeature = 
document.implementation && 
document.implementation.hasFeature && 


document.implementation.hasFeature('','') !== true;}
















function isEventSupported(eventNameSuffix,capture){
if(!ExecutionEnvironment.canUseDOM || 
capture && !('addEventListener' in document)){
return false;}


var eventName='on' + eventNameSuffix;
var isSupported=(eventName in document);

if(!isSupported){
var element=document.createElement('div');
element.setAttribute(eventName,'return;');
isSupported = typeof element[eventName] === 'function';}


if(!isSupported && useHasFeature && eventNameSuffix === 'wheel'){

isSupported = document.implementation.hasFeature('Events.wheel','3.0');}


return isSupported;}


module.exports = isEventSupported;
});
__d('ReactMarkupChecksum',["adler32"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var adler32=require('adler32');

var ReactMarkupChecksum={
CHECKSUM_ATTR_NAME:'data-react-checksum',





addChecksumToMarkup:function(markup){
var checksum=adler32(markup);
return markup.replace(
'>',
' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="' + checksum + '">');},








canReuseMarkup:function(markup,element){
var existingChecksum=element.getAttribute(
ReactMarkupChecksum.CHECKSUM_ATTR_NAME);

existingChecksum = existingChecksum && parseInt(existingChecksum,10);
var markupChecksum=adler32(markup);
return markupChecksum === existingChecksum;}};



module.exports = ReactMarkupChecksum;
});
__d('adler32',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';














var MOD=65521;





function adler32(data){
var a=1;
var b=0;
for(var i=0;i < data.length;i++) {
a = (a + data.charCodeAt(i)) % MOD;
b = (b + a) % MOD;}

return a | b << 16;}


module.exports = adler32;
});
__d('containsNode',["isTextNode"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 











isTextNode=require('isTextNode');










function containsNode(outerNode,innerNode){
if(!outerNode || !innerNode){
return false;}else 
if(outerNode === innerNode){
return true;}else 
if(isTextNode(outerNode)){
return false;}else 
if(isTextNode(innerNode)){
return containsNode(outerNode,innerNode.parentNode);}else 
if(outerNode.contains){
return outerNode.contains(innerNode);}else 
if(outerNode.compareDocumentPosition){
return !!(outerNode.compareDocumentPosition(innerNode) & 16);}else 
{
return false;}}



module.exports = containsNode;
});
__d('isTextNode',["isNode"],function(global, require, requireDynamic, requireLazy, module, exports) {  var 











isNode=require('isNode');





function isTextNode(object){
return isNode(object) && object.nodeType == 3;}


module.exports = isTextNode;
});
__d('getReactRootElementInContainer',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var DOC_NODE_TYPE=9;






function getReactRootElementInContainer(container){
if(!container){
return null;}


if(container.nodeType === DOC_NODE_TYPE){
return container.documentElement;}else 
{
return container.firstChild;}}



module.exports = getReactRootElementInContainer;
});
__d('setInnerHTML',["ExecutionEnvironment"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';














var ExecutionEnvironment=require('ExecutionEnvironment');

var WHITESPACE_TEST=/^[ \r\n\t\f]/;
var NONVISIBLE_TEST=/<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;









var setInnerHTML=function(node,html){
node.innerHTML = html;};



if(typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction){
setInnerHTML = function(node,html){
MSApp.execUnsafeLocalFunction(function(){
node.innerHTML = html;});};}




if(ExecutionEnvironment.canUseDOM){






var testElement=document.createElement('div');
testElement.innerHTML = ' ';
if(testElement.innerHTML === ''){
setInnerHTML = function(node,html){





if(node.parentNode){
node.parentNode.replaceChild(node,node);}






if(WHITESPACE_TEST.test(html) || 
html[0] === '<' && NONVISIBLE_TEST.test(html)){


node.innerHTML = '' + html;



var textNode=node.firstChild;
if(textNode.data.length === 1){
node.removeChild(textNode);}else 
{
textNode.deleteData(0,1);}}else 

{
node.innerHTML = html;}};}}





module.exports = setInnerHTML;
});
__d('AppStateIOS',["Map","NativeModules","RCTDeviceEventEmitter","logError","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var Map=require('Map');
var NativeModules=require('NativeModules');
var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');
var RCTAppState=NativeModules.AppState;

var logError=require('logError');
var invariant=require('invariant');

var _eventHandlers={
change:new Map(),
memoryWarning:new Map()};





















































var AppStateIOS={





addEventListener:function(
type,
handler)
{
invariant(
['change','memoryWarning'].indexOf(type) !== -1,
'Trying to subscribe to unknown event: "%s"',type);

if(type === 'change'){
_eventHandlers[type].set(handler,RCTDeviceEventEmitter.addListener(
'appStateDidChange',
function(appStateData){
handler(appStateData.app_state);}));}else 


if(type === 'memoryWarning'){
_eventHandlers[type].set(handler,RCTDeviceEventEmitter.addListener(
'memoryWarning',
handler));}},







removeEventListener:function(
type,
handler)
{
invariant(
['change','memoryWarning'].indexOf(type) !== -1,
'Trying to remove listener for unknown event: "%s"',type);

if(!_eventHandlers[type].has(handler)){
return;}

_eventHandlers[type].get(handler).remove();
_eventHandlers[type].delete(handler);},






currentState:'active'};



RCTDeviceEventEmitter.addListener(
'appStateDidChange',
function(appStateData){
AppStateIOS.currentState = appStateData.app_state;});



RCTAppState.getCurrentAppState(
function(appStateData){
AppStateIOS.currentState = appStateData.app_state;},

logError);


module.exports = AppStateIOS;
});
__d('CameraRoll',["ReactPropTypes","NativeModules","createStrictShapeTypeChecker","deepFreezeAndThrowOnMutationInDev","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var ReactPropTypes=require('ReactPropTypes');
var RCTCameraRollManager=require('NativeModules').CameraRollManager;

var createStrictShapeTypeChecker=require('createStrictShapeTypeChecker');
var deepFreezeAndThrowOnMutationInDev=
require('deepFreezeAndThrowOnMutationInDev');
var invariant=require('invariant');

var GROUP_TYPES_OPTIONS=[
'Album',
'All',
'Event',
'Faces',
'Library',
'PhotoStream',
'SavedPhotos'];


var ASSET_TYPE_OPTIONS=[
'All',
'Videos',
'Photos'];




deepFreezeAndThrowOnMutationInDev(GROUP_TYPES_OPTIONS);
deepFreezeAndThrowOnMutationInDev(ASSET_TYPE_OPTIONS);




var getPhotosParamChecker=createStrictShapeTypeChecker({




first:ReactPropTypes.number.isRequired,





after:ReactPropTypes.string,




groupTypes:ReactPropTypes.oneOf(GROUP_TYPES_OPTIONS),





groupName:ReactPropTypes.string,




assetType:ReactPropTypes.oneOf(ASSET_TYPE_OPTIONS),




mimeTypes:ReactPropTypes.arrayOf(ReactPropTypes.string)});





var getPhotosReturnChecker=createStrictShapeTypeChecker({
edges:ReactPropTypes.arrayOf(createStrictShapeTypeChecker({
node:createStrictShapeTypeChecker({
type:ReactPropTypes.string.isRequired,
group_name:ReactPropTypes.string.isRequired,
image:createStrictShapeTypeChecker({
uri:ReactPropTypes.string.isRequired,
height:ReactPropTypes.number.isRequired,
width:ReactPropTypes.number.isRequired,
isStored:ReactPropTypes.bool}).
isRequired,
timestamp:ReactPropTypes.number.isRequired,
location:createStrictShapeTypeChecker({
latitude:ReactPropTypes.number,
longitude:ReactPropTypes.number,
altitude:ReactPropTypes.number,
heading:ReactPropTypes.number,
speed:ReactPropTypes.number})}).

isRequired})).
isRequired,
page_info:createStrictShapeTypeChecker({
has_next_page:ReactPropTypes.bool.isRequired,
start_cursor:ReactPropTypes.string,
end_cursor:ReactPropTypes.string}).
isRequired});var 


CameraRoll=(function(){function CameraRoll(){_classCallCheck(this,CameraRoll);}_createClass(CameraRoll,null,[{key:'saveImageWithTag',value:











function saveImageWithTag(tag,successCallback,errorCallback){
invariant(
typeof tag === 'string',
'CameraRoll.saveImageWithTag tag must be a valid string.');

RCTCameraRollManager.saveImageWithTag(
tag,
function(imageTag){
successCallback && successCallback(imageTag);},

function(errorMessage){
errorCallback && errorCallback(errorMessage);});}},{key:'getPhotos',value:












function getPhotos(params,callback,errorCallback){
var metaCallback=callback;
if(__DEV__){
getPhotosParamChecker({params:params},'params','CameraRoll.getPhotos');
invariant(
typeof callback === 'function',
'CameraRoll.getPhotos callback must be a valid function.');

invariant(
typeof errorCallback === 'function',
'CameraRoll.getPhotos errorCallback must be a valid function.');}


if(__DEV__){
metaCallback = function(response){
getPhotosReturnChecker(
{response:response},
'response',
'CameraRoll.getPhotos callback');

callback(response);};}


RCTCameraRollManager.getPhotos(params,metaCallback,errorCallback);}}]);return CameraRoll;})();



CameraRoll.GroupTypesOptions = GROUP_TYPES_OPTIONS;
CameraRoll.AssetTypeOptions = ASSET_TYPE_OPTIONS;

module.exports = CameraRoll;
});
__d('ImagePickerIOS',["NativeModules"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};












var RCTImagePicker=require('NativeModules').ImagePickerIOS;

var ImagePickerIOS={
canRecordVideos:function(callback){
return RCTImagePicker.canRecordVideos(callback);},

canUseCamera:function(callback){
return RCTImagePicker.canUseCamera(callback);},

openCameraDialog:function(config,successCallback,cancelCallback){
config = _extends({
videoMode:false},
config);

return RCTImagePicker.openCameraDialog(config,successCallback,cancelCallback);},

openSelectDialog:function(config,successCallback,cancelCallback){
config = _extends({
showImages:true,
showVideos:false},
config);

return RCTImagePicker.openSelectDialog(config,successCallback,cancelCallback);}};



module.exports = ImagePickerIOS;
});
__d('LayoutAnimation',["ReactPropTypes","NativeModules","createStrictShapeTypeChecker","keyMirror"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var PropTypes=require('ReactPropTypes');
var RCTUIManager=require('NativeModules').UIManager;

var createStrictShapeTypeChecker=require('createStrictShapeTypeChecker');
var keyMirror=require('keyMirror');

var TypesEnum={
spring:true,
linear:true,
easeInEaseOut:true,
easeIn:true,
easeOut:true};

var Types=keyMirror(TypesEnum);

var PropertiesEnum={
opacity:true,
scaleXY:true};

var Properties=keyMirror(PropertiesEnum);

var animChecker=createStrictShapeTypeChecker({
duration:PropTypes.number,
delay:PropTypes.number,
springDamping:PropTypes.number,
initialVelocity:PropTypes.number,
type:PropTypes.oneOf(
Object.keys(Types)),

property:PropTypes.oneOf(
Object.keys(Properties))});












var configChecker=createStrictShapeTypeChecker({
duration:PropTypes.number.isRequired,
create:animChecker,
update:animChecker,
delete:animChecker});









function configureNext(config,onAnimationDidEnd,onError){
configChecker({config:config},'config','LayoutAnimation.configureNext');
RCTUIManager.configureNextLayoutAnimation(config,onAnimationDidEnd,onError);}


function create(duration,type,creationProp){
return {
duration:duration,
create:{
type:type,
property:creationProp},

update:{
type:type}};}




var LayoutAnimation={
configureNext:configureNext,
create:create,
Types:Types,
Properties:Properties,
configChecker:configChecker,
Presets:{
easeInEaseOut:create(
300,Types.easeInEaseOut,Properties.opacity),

linear:create(
500,Types.linear,Properties.opacity),

spring:{
duration:700,
create:{
type:Types.linear,
property:Properties.opacity},

update:{
type:Types.spring,
springDamping:0.4}}}};





module.exports = LayoutAnimation;
});
__d('LinkingIOS',["RCTDeviceEventEmitter","NativeModules","Map","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');
var RCTLinkingManager=require('NativeModules').LinkingManager;
var Map=require('Map');
var invariant=require('invariant');

var _notifHandlers=new Map();
var _initialURL=RCTLinkingManager && 
RCTLinkingManager.initialURL;

var DEVICE_NOTIF_EVENT='openURL';var 





























































LinkingIOS=(function(){function LinkingIOS(){_classCallCheck(this,LinkingIOS);}_createClass(LinkingIOS,null,[{key:'addEventListener',value:




function addEventListener(type,handler){
invariant(
type === 'url',
'LinkingIOS only supports `url` events');

var listener=RCTDeviceEventEmitter.addListener(
DEVICE_NOTIF_EVENT,
handler);

_notifHandlers.set(handler,listener);}},{key:'removeEventListener',value:





function removeEventListener(type,handler){
invariant(
type === 'url',
'LinkingIOS only supports `url` events');

var listener=_notifHandlers.get(handler);
if(!listener){
return;}

listener.remove();
_notifHandlers.delete(handler);}},{key:'openURL',value:





function openURL(url){
invariant(
typeof url === 'string',
'Invalid url: should be a string');

RCTLinkingManager.openURL(url);}},{key:'canOpenURL',value:






function canOpenURL(url,callback){
invariant(
typeof url === 'string',
'Invalid url: should be a string');

invariant(
typeof callback === 'function',
'A valid callback function is required');

RCTLinkingManager.canOpenURL(url,callback);}},{key:'popInitialURL',value:






function popInitialURL(){
var initialURL=_initialURL;
_initialURL = null;
return initialURL;}}]);return LinkingIOS;})();



module.exports = LinkingIOS;
});
__d('NetInfo',["Map","NativeModules","Platform","RCTDeviceEventEmitter"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var Map=require('Map');
var NativeModules=require('NativeModules');
var Platform=require('Platform');
var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');

if(Platform.OS === 'ios'){
var RCTNetInfo=NativeModules.Reachability;}else 
if(Platform.OS === 'android'){
var RCTNetInfo=NativeModules.NetInfo;}


var DEVICE_REACHABILITY_EVENT='reachabilityDidChange';






















































































































var _subscriptions=new Map();

var NetInfo={
addEventListener:function(
eventName,
handler)
{
var listener=RCTDeviceEventEmitter.addListener(
DEVICE_REACHABILITY_EVENT,
function(appStateData){
handler(appStateData.network_reachability);});


_subscriptions.set(handler,listener);},


removeEventListener:function(
eventName,
handler)
{
var listener=_subscriptions.get(handler);
if(!listener){
return;}

listener.remove();
_subscriptions.delete(handler);},


fetch:function(){
return new Promise(function(resolve,reject){
RCTNetInfo.getCurrentReachability(
function(resp){
resolve(resp.network_reachability);},

reject);});},




isConnected:{},

isConnectionMetered:{}};


if(Platform.OS === 'ios'){
var _isConnected=function(
reachability)
{
return reachability !== 'none' && 
reachability !== 'unknown';};}else 

if(Platform.OS === 'android'){
var _isConnected=function(
connectionType)
{
return connectionType !== 'NONE' && connectionType !== 'UNKNOWN';};}



var _isConnectedSubscriptions=new Map();

NetInfo.isConnected = {
addEventListener:function(
eventName,
handler)
{
var listener=function(connection){
handler(_isConnected(connection));};

_isConnectedSubscriptions.set(handler,listener);
NetInfo.addEventListener(
eventName,
listener);},



removeEventListener:function(
eventName,
handler)
{
var listener=_isConnectedSubscriptions.get(handler);
NetInfo.removeEventListener(
eventName,
listener);

_isConnectedSubscriptions.delete(handler);},


fetch:function(){
return NetInfo.fetch().then(
function(connection){return _isConnected(connection);});}};




if(Platform.OS === 'android'){
NetInfo.isConnectionMetered = function(callback){
RCTNetInfo.isConnectionMetered(function(_isMetered){
callback(_isMetered);});};}




module.exports = NetInfo;
});
__d('PushNotificationIOS',["Map","RCTDeviceEventEmitter","NativeModules","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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');}}












var Map=require('Map');
var RCTDeviceEventEmitter=require('RCTDeviceEventEmitter');
var RCTPushNotificationManager=require('NativeModules').PushNotificationManager;
var invariant=require('invariant');

var _notifHandlers=new Map();
var _initialNotification=RCTPushNotificationManager && 
RCTPushNotificationManager.initialNotification;

var DEVICE_NOTIF_EVENT='remoteNotificationReceived';
var NOTIF_REGISTER_EVENT='remoteNotificationsRegistered';var 








PushNotificationIOS=(function(){_createClass(PushNotificationIOS,null,[{key:'setApplicationIconBadgeNumber',value:








function setApplicationIconBadgeNumber(number){
RCTPushNotificationManager.setApplicationIconBadgeNumber(number);}},{key:'getApplicationIconBadgeNumber',value:





function getApplicationIconBadgeNumber(callback){
RCTPushNotificationManager.getApplicationIconBadgeNumber(callback);}},{key:'addEventListener',value:













function addEventListener(type,handler){
invariant(
type === 'notification' || type === 'register',
'PushNotificationIOS only supports `notification` and `register` events');

var listener;
if(type === 'notification'){
listener = RCTDeviceEventEmitter.addListener(
DEVICE_NOTIF_EVENT,
function(notifData){
handler(new PushNotificationIOS(notifData));});}else 


if(type === 'register'){
listener = RCTDeviceEventEmitter.addListener(
NOTIF_REGISTER_EVENT,
function(registrationInfo){
handler(registrationInfo.deviceToken);});}



_notifHandlers.set(handler,listener);}},{key:'requestPermissions',value:
















function requestPermissions(permissions)



{
var requestedPermissions={};
if(permissions){
requestedPermissions = {
alert:!!permissions.alert,
badge:!!permissions.badge,
sound:!!permissions.sound};}else 

{
requestedPermissions = {
alert:true,
badge:true,
sound:true};}


RCTPushNotificationManager.requestPermissions(requestedPermissions);}},{key:'abandonPermissions',value:










function abandonPermissions(){
RCTPushNotificationManager.abandonPermissions();}},{key:'checkPermissions',value:










function checkPermissions(callback){
invariant(
typeof callback === 'function',
'Must provide a valid callback');

RCTPushNotificationManager.checkPermissions(callback);}},{key:'removeEventListener',value:






function removeEventListener(type,handler){
invariant(
type === 'notification' || type === 'register',
'PushNotificationIOS only supports `notification` and `register` events');

var listener=_notifHandlers.get(handler);
if(!listener){
return;}

listener.remove();
_notifHandlers.delete(handler);}},{key:'popInitialNotification',value:










function popInitialNotification(){
var initialNotification=_initialNotification && 
new PushNotificationIOS(_initialNotification);
_initialNotification = null;
return initialNotification;}}]);







function PushNotificationIOS(nativeNotif){var _this=this;_classCallCheck(this,PushNotificationIOS);
this._data = {};





Object.keys(nativeNotif).forEach(function(notifKey){
var notifVal=nativeNotif[notifKey];
if(notifKey === 'aps'){
_this._alert = notifVal.alert;
_this._sound = notifVal.sound;
_this._badgeCount = notifVal.badge;}else 
{
_this._data[notifKey] = notifVal;}});}_createClass(PushNotificationIOS,[{key:'getMessage',value:







function getMessage(){

return this._alert;}},{key:'getSound',value:





function getSound(){
return this._sound;}},{key:'getAlert',value:





function getAlert(){
return this._alert;}},{key:'getBadgeCount',value:





function getBadgeCount(){
return this._badgeCount;}},{key:'getData',value:





function getData(){
return this._data;}}]);return PushNotificationIOS;})();



module.exports = PushNotificationIOS;
});
__d('StatusBarIOS',["NativeModules"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var RCTStatusBarManager=require('NativeModules').StatusBarManager;












var StatusBarIOS={

setStyle:function(style,animated){
animated = animated || false;
RCTStatusBarManager.setStyle(style,animated);},


setHidden:function(hidden,animation){
animation = animation || 'none';
RCTStatusBarManager.setHidden(hidden,animation);}};



module.exports = StatusBarIOS;
});
__d('VibrationIOS',["NativeModules","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var RCTVibration=require('NativeModules').Vibration;

var invariant=require('invariant');












var VibrationIOS={
vibrate:function(){
invariant(
arguments[0] === undefined,
'Vibration patterns not supported.');

RCTVibration.vibrate();}};



module.exports = VibrationIOS;
});
__d('RCTNativeAppEventEmitter',["EventEmitter"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventEmitter=require('EventEmitter');

var RCTNativeAppEventEmitter=new EventEmitter();

module.exports = RCTNativeAppEventEmitter;
});
__d('LinkedStateMixin',["ReactLink","ReactStateSetters"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';













var ReactLink=require('ReactLink');
var ReactStateSetters=require('ReactStateSetters');




var LinkedStateMixin={









linkState:function(key){
return new ReactLink(
this.state[key],
ReactStateSetters.createStateKeySetter(this,key));}};




module.exports = LinkedStateMixin;
});
__d('ReactLink',["React"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';




































var React=require('React');





function ReactLink(value,requestChange){
this.value = value;
this.requestChange = requestChange;}










function createLinkTypeChecker(linkType){
var shapes={
value:typeof linkType === 'undefined'?
React.PropTypes.any.isRequired:
linkType.isRequired,
requestChange:React.PropTypes.func.isRequired};

return React.PropTypes.shape(shapes);}


ReactLink.PropTypes = {
link:createLinkTypeChecker};


module.exports = ReactLink;
});
__d('ReactStateSetters',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var ReactStateSetters={










createStateSetter:function(component,funcReturningState){
return function(a,b,c,d,e,f){
var partialState=funcReturningState.call(component,a,b,c,d,e,f);
if(partialState){
component.setState(partialState);}};},















createStateKeySetter:function(component,key){

var cache=component.__keySetters || (component.__keySetters = {});
return cache[key] || (cache[key] = createStateKeySetter(component,key));}};



function createStateKeySetter(component,key){



var partialState={};
return function stateKeySetter(value){
partialState[key] = value;
component.setState(partialState);};}



ReactStateSetters.Mixin = {
















createStateSetter:function(funcReturningState){
return ReactStateSetters.createStateSetter(this,funcReturningState);},

















createStateKeySetter:function(key){
return ReactStateSetters.createStateKeySetter(this,key);}};



module.exports = ReactStateSetters;
});
__d('ReactComponentWithPureRenderMixin',["shallowEqual"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var shallowEqual=require('shallowEqual');

























var ReactComponentWithPureRenderMixin={
shouldComponentUpdate:function(nextProps,nextState){
return !shallowEqual(this.props,nextProps) || 
!shallowEqual(this.state,nextState);}};



module.exports = ReactComponentWithPureRenderMixin;
});
__d('shallowEqual',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';



















function shallowEqual(objA,objB){
if(objA === objB){
return true;}

var key;

for(key in objA) {
if(objA.hasOwnProperty(key) && (
!objB.hasOwnProperty(key) || objA[key] !== objB[key])){
return false;}}



for(key in objB) {
if(objB.hasOwnProperty(key) && !objA.hasOwnProperty(key)){
return false;}}


return true;}


module.exports = shallowEqual;
});
__d('update',["Object.assign","keyOf","invariant"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';














var assign=require('Object.assign');
var keyOf=require('keyOf');
var invariant=require('invariant');
var hasOwnProperty=({}).hasOwnProperty;

function shallowCopy(x){
if(Array.isArray(x)){
return x.concat();}else 
if(x && typeof x === 'object'){
return assign(new x.constructor(),x);}else 
{
return x;}}



var COMMAND_PUSH=keyOf({$push:null});
var COMMAND_UNSHIFT=keyOf({$unshift:null});
var COMMAND_SPLICE=keyOf({$splice:null});
var COMMAND_SET=keyOf({$set:null});
var COMMAND_MERGE=keyOf({$merge:null});
var COMMAND_APPLY=keyOf({$apply:null});

var ALL_COMMANDS_LIST=[
COMMAND_PUSH,
COMMAND_UNSHIFT,
COMMAND_SPLICE,
COMMAND_SET,
COMMAND_MERGE,
COMMAND_APPLY];


var ALL_COMMANDS_SET={};

ALL_COMMANDS_LIST.forEach(function(command){
ALL_COMMANDS_SET[command] = true;});


function invariantArrayCase(value,spec,command){
invariant(
Array.isArray(value),
'update(): expected target of %s to be an array; got %s.',
command,
value);

var specValue=spec[command];
invariant(
Array.isArray(specValue),
'update(): expected spec of %s to be an array; got %s. ' + 
'Did you forget to wrap your parameter in an array?',
command,
specValue);}



function update(value,spec){
invariant(
typeof spec === 'object',
'update(): You provided a key path to update() that did not contain one ' + 
'of %s. Did you forget to include {%s: ...}?',
ALL_COMMANDS_LIST.join(', '),
COMMAND_SET);


if(hasOwnProperty.call(spec,COMMAND_SET)){
invariant(
Object.keys(spec).length === 1,
'Cannot have more than one key in an object with %s',
COMMAND_SET);


return spec[COMMAND_SET];}


var nextValue=shallowCopy(value);

if(hasOwnProperty.call(spec,COMMAND_MERGE)){
var mergeObj=spec[COMMAND_MERGE];
invariant(
mergeObj && typeof mergeObj === 'object',
'update(): %s expects a spec of type \'object\'; got %s',
COMMAND_MERGE,
mergeObj);

invariant(
nextValue && typeof nextValue === 'object',
'update(): %s expects a target of type \'object\'; got %s',
COMMAND_MERGE,
nextValue);

assign(nextValue,spec[COMMAND_MERGE]);}


if(hasOwnProperty.call(spec,COMMAND_PUSH)){
invariantArrayCase(value,spec,COMMAND_PUSH);
spec[COMMAND_PUSH].forEach(function(item){
nextValue.push(item);});}



if(hasOwnProperty.call(spec,COMMAND_UNSHIFT)){
invariantArrayCase(value,spec,COMMAND_UNSHIFT);
spec[COMMAND_UNSHIFT].forEach(function(item){
nextValue.unshift(item);});}



if(hasOwnProperty.call(spec,COMMAND_SPLICE)){
invariant(
Array.isArray(value),
'Expected %s target to be an array; got %s',
COMMAND_SPLICE,
value);

invariant(
Array.isArray(spec[COMMAND_SPLICE]),
'update(): expected spec of %s to be an array of arrays; got %s. ' + 
'Did you forget to wrap your parameters in an array?',
COMMAND_SPLICE,
spec[COMMAND_SPLICE]);

spec[COMMAND_SPLICE].forEach(function(args){
invariant(
Array.isArray(args),
'update(): expected spec of %s to be an array of arrays; got %s. ' + 
'Did you forget to wrap your parameters in an array?',
COMMAND_SPLICE,
spec[COMMAND_SPLICE]);

nextValue.splice.apply(nextValue,args);});}



if(hasOwnProperty.call(spec,COMMAND_APPLY)){
invariant(
typeof spec[COMMAND_APPLY] === 'function',
'update(): expected spec of %s to be a function; got %s.',
COMMAND_APPLY,
spec[COMMAND_APPLY]);

nextValue = spec[COMMAND_APPLY](nextValue);}


for(var k in spec) {
if(!(ALL_COMMANDS_SET.hasOwnProperty(k) && ALL_COMMANDS_SET[k])){
nextValue[k] = update(value[k],spec[k]);}}



return nextValue;}


module.exports = update;
});
__d('ReactTestUtils',["EventConstants","EventPluginHub","EventPropagators","React","ReactElement","ReactEmptyComponent","ReactBrowserEventEmitter","ReactCompositeComponent","ReactInstanceHandles","ReactInstanceMap","ReactMount","ReactUpdates","SyntheticEvent","Object.assign"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';












var EventConstants=require('EventConstants');
var EventPluginHub=require('EventPluginHub');
var EventPropagators=require('EventPropagators');
var React=require('React');
var ReactElement=require('ReactElement');
var ReactEmptyComponent=require('ReactEmptyComponent');
var ReactBrowserEventEmitter=require('ReactBrowserEventEmitter');
var ReactCompositeComponent=require('ReactCompositeComponent');
var ReactInstanceHandles=require('ReactInstanceHandles');
var ReactInstanceMap=require('ReactInstanceMap');
var ReactMount=require('ReactMount');
var ReactUpdates=require('ReactUpdates');
var SyntheticEvent=require('SyntheticEvent');

var assign=require('Object.assign');

var topLevelTypes=EventConstants.topLevelTypes;

function Event(suffix){}










var ReactTestUtils={
renderIntoDocument:function(instance){
var div=document.createElement('div');





return React.render(instance,div);},


isElement:function(element){
return ReactElement.isValidElement(element);},


isElementOfType:function(inst,convenienceConstructor){
return (
ReactElement.isValidElement(inst) && 
inst.type === convenienceConstructor);},



isDOMComponent:function(inst){


return !!(inst && inst.tagName && inst.getDOMNode);},


isDOMComponentElement:function(inst){
return !!(inst && 
ReactElement.isValidElement(inst) && 
!!inst.tagName);},


isCompositeComponent:function(inst){
return typeof inst.render === 'function' && 
typeof inst.setState === 'function';},


isCompositeComponentWithType:function(inst,type){
return !!(ReactTestUtils.isCompositeComponent(inst) && 
inst.constructor === type);},


isCompositeComponentElement:function(inst){
if(!ReactElement.isValidElement(inst)){
return false;}



var prototype=inst.type.prototype;
return (
typeof prototype.render === 'function' && 
typeof prototype.setState === 'function');},



isCompositeComponentElementWithType:function(inst,type){
return !!(ReactTestUtils.isCompositeComponentElement(inst) && 
inst.constructor === type);},


getRenderedChildOfCompositeComponent:function(inst){
if(!ReactTestUtils.isCompositeComponent(inst)){
return null;}

var internalInstance=ReactInstanceMap.get(inst);
return internalInstance._renderedComponent.getPublicInstance();},


findAllInRenderedTree:function(inst,test){
if(!inst){
return [];}

var ret=test(inst)?[inst]:[];
if(ReactTestUtils.isDOMComponent(inst)){
var internalInstance=ReactInstanceMap.get(inst);
var renderedChildren=internalInstance.
_renderedComponent.
_renderedChildren;
var key;
for(key in renderedChildren) {
if(!renderedChildren.hasOwnProperty(key)){
continue;}

if(!renderedChildren[key].getPublicInstance){
continue;}

ret = ret.concat(
ReactTestUtils.findAllInRenderedTree(
renderedChildren[key].getPublicInstance(),
test));}}else 



if(ReactTestUtils.isCompositeComponent(inst)){
ret = ret.concat(
ReactTestUtils.findAllInRenderedTree(
ReactTestUtils.getRenderedChildOfCompositeComponent(inst),
test));}



return ret;},







scryRenderedDOMComponentsWithClass:function(root,className){
return ReactTestUtils.findAllInRenderedTree(root,function(inst){
var instClassName=inst.props.className;
return ReactTestUtils.isDOMComponent(inst) && (
instClassName && 
(' ' + instClassName + ' ').indexOf(' ' + className + ' ') !== -1);});},










findRenderedDOMComponentWithClass:function(root,className){
var all=
ReactTestUtils.scryRenderedDOMComponentsWithClass(root,className);
if(all.length !== 1){
throw new Error('Did not find exactly one match ' + 
'(found: ' + all.length + ') for class:' + className);}


return all[0];},








scryRenderedDOMComponentsWithTag:function(root,tagName){
return ReactTestUtils.findAllInRenderedTree(root,function(inst){
return ReactTestUtils.isDOMComponent(inst) && 
inst.tagName === tagName.toUpperCase();});},









findRenderedDOMComponentWithTag:function(root,tagName){
var all=ReactTestUtils.scryRenderedDOMComponentsWithTag(root,tagName);
if(all.length !== 1){
throw new Error('Did not find exactly one match for tag:' + tagName);}

return all[0];},







scryRenderedComponentsWithType:function(root,componentType){
return ReactTestUtils.findAllInRenderedTree(root,function(inst){
return ReactTestUtils.isCompositeComponentWithType(
inst,
componentType);});},










findRenderedComponentWithType:function(root,componentType){
var all=ReactTestUtils.scryRenderedComponentsWithType(
root,
componentType);

if(all.length !== 1){
throw new Error(
'Did not find exactly one match for componentType:' + componentType);}


return all[0];},















mockComponent:function(module,mockTagName){
mockTagName = mockTagName || module.mockTagName || 'div';

module.prototype.render.mockImplementation(function(){
return React.createElement(
mockTagName,
null,
this.props.children);});



return this;},









simulateNativeEventOnNode:function(topLevelType,node,fakeNativeEvent){
fakeNativeEvent.target = node;
ReactBrowserEventEmitter.ReactEventListener.dispatchEvent(
topLevelType,
fakeNativeEvent);},










simulateNativeEventOnDOMComponent:function(
topLevelType,
comp,
fakeNativeEvent){
ReactTestUtils.simulateNativeEventOnNode(
topLevelType,
comp.getDOMNode(),
fakeNativeEvent);},



nativeTouchData:function(x,y){
return {
touches:[
{pageX:x,pageY:y}]};},




createRenderer:function(){
return new ReactShallowRenderer();},


Simulate:null,
SimulateNative:{}};





var ReactShallowRenderer=function(){
this._instance = null;};


ReactShallowRenderer.prototype.getRenderOutput = function(){
return (
this._instance && this._instance._renderedComponent && 
this._instance._renderedComponent._renderedOutput || 
null);};



var NoopInternalComponent=function(element){
this._renderedOutput = element;
this._currentElement = element === null || element === false?
ReactEmptyComponent.emptyElement:
element;};


NoopInternalComponent.prototype = {

mountComponent:function(){},


receiveComponent:function(element){
this._renderedOutput = element;
this._currentElement = element === null || element === false?
ReactEmptyComponent.emptyElement:
element;},


unmountComponent:function(){}};




var ShallowComponentWrapper=function(){};
assign(
ShallowComponentWrapper.prototype,
ReactCompositeComponent.Mixin,{
_instantiateReactComponent:function(element){
return new NoopInternalComponent(element);},

_replaceNodeWithMarkupByID:function(){},
_renderValidatedComponent:
ReactCompositeComponent.Mixin.
_renderValidatedComponentWithoutOwnerOrContext});



ReactShallowRenderer.prototype.render = function(element,context){
var transaction=ReactUpdates.ReactReconcileTransaction.getPooled();
this._render(element,transaction,context);
ReactUpdates.ReactReconcileTransaction.release(transaction);};


ReactShallowRenderer.prototype.unmount = function(){
if(this._instance){
this._instance.unmountComponent();}};



ReactShallowRenderer.prototype._render = function(element,transaction,context){
if(!this._instance){
var rootID=ReactInstanceHandles.createReactRootID();
var instance=new ShallowComponentWrapper(element.type);
instance.construct(element);

instance.mountComponent(rootID,transaction,context);

this._instance = instance;}else 
{
this._instance.receiveComponent(element,transaction,context);}};











function makeSimulator(eventType){
return function(domComponentOrNode,eventData){
var node;
if(ReactTestUtils.isDOMComponent(domComponentOrNode)){
node = domComponentOrNode.getDOMNode();}else 
if(domComponentOrNode.tagName){
node = domComponentOrNode;}


var fakeNativeEvent=new Event();
fakeNativeEvent.target = node;


var event=new SyntheticEvent(
ReactBrowserEventEmitter.eventNameDispatchConfigs[eventType],
ReactMount.getID(node),
fakeNativeEvent);

assign(event,eventData);
EventPropagators.accumulateTwoPhaseDispatches(event);

ReactUpdates.batchedUpdates(function(){
EventPluginHub.enqueueEvents(event);
EventPluginHub.processEventQueue();});};}




function buildSimulators(){
ReactTestUtils.Simulate = {};

var eventType;
for(eventType in ReactBrowserEventEmitter.eventNameDispatchConfigs) {




ReactTestUtils.Simulate[eventType] = makeSimulator(eventType);}}




var oldInjectEventPluginOrder=EventPluginHub.injection.injectEventPluginOrder;
EventPluginHub.injection.injectEventPluginOrder = function(){
oldInjectEventPluginOrder.apply(this,arguments);
buildSimulators();};

var oldInjectEventPlugins=EventPluginHub.injection.injectEventPluginsByName;
EventPluginHub.injection.injectEventPluginsByName = function(){
oldInjectEventPlugins.apply(this,arguments);
buildSimulators();};


buildSimulators();

















function makeNativeSimulator(eventType){
return function(domComponentOrNode,nativeEventData){
var fakeNativeEvent=new Event(eventType);
assign(fakeNativeEvent,nativeEventData);
if(ReactTestUtils.isDOMComponent(domComponentOrNode)){
ReactTestUtils.simulateNativeEventOnDOMComponent(
eventType,
domComponentOrNode,
fakeNativeEvent);}else 

if(!!domComponentOrNode.tagName){

ReactTestUtils.simulateNativeEventOnNode(
eventType,
domComponentOrNode,
fakeNativeEvent);}};}





var eventType;
for(eventType in topLevelTypes) {

var convenienceName=eventType.indexOf('top') === 0?
eventType.charAt(3).toLowerCase() + eventType.substr(4):eventType;




ReactTestUtils.SimulateNative[convenienceName] = 
makeNativeSimulator(eventType);}


module.exports = ReactTestUtils;
});
__d('noder/app/containers/App.js',["react-native/Libraries/react-native/react-native.js","redux/lib/index.js","noder/app/containers/NoderApp.js","noder/app/reducers/index.js","redux/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Redux=require('redux/lib/index.js');
var NoderApp=require('noder/app/containers/NoderApp.js');

var reducer=require('noder/app/reducers/index.js');var _require=




require('redux/react-native.js');var Provider=_require.Provider;var 



createStore=
Redux.createStore;var 



Component=

React.Component;var View=React.View;


var store=createStore(reducer);var 


App=(function(_Component){_inherits(App,_Component);function App(){_classCallCheck(this,App);_get(Object.getPrototypeOf(App.prototype),'constructor',this).apply(this,arguments);}_createClass(App,[{key:'render',value:
function render(){
return (
React.createElement(Provider,{store:store},
function(){
return React.createElement(NoderApp,null);}));}}]);return App;})(Component);







module.exports = App;
});
__d('redux/lib/index.js',["redux/lib/createStore.js","redux/lib/utils/composeMiddleware.js","redux/lib/utils/composeReducers.js","redux/lib/utils/bindActionCreators.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';


exports.__esModule = true;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

var _createStore=require('redux/lib/createStore.js');

var _createStore2=_interopRequireDefault(_createStore);



var _utilsComposeMiddleware=require('redux/lib/utils/composeMiddleware.js');

var _utilsComposeMiddleware2=_interopRequireDefault(_utilsComposeMiddleware);

var _utilsComposeReducers=require('redux/lib/utils/composeReducers.js');

var _utilsComposeReducers2=_interopRequireDefault(_utilsComposeReducers);

var _utilsBindActionCreators=require('redux/lib/utils/bindActionCreators.js');

var _utilsBindActionCreators2=_interopRequireDefault(_utilsBindActionCreators);

exports.createStore = _createStore2['default'];
exports.composeMiddleware = _utilsComposeMiddleware2['default'];
exports.composeReducers = _utilsComposeReducers2['default'];
exports.bindActionCreators = _utilsBindActionCreators2['default'];
});
__d('redux/lib/createStore.js',["redux/lib/Store.js","redux/lib/utils/composeReducers.js","redux/lib/utils/composeMiddleware.js","redux/lib/middleware/thunk.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = createStore;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

var _Store=require('redux/lib/Store.js');

var _Store2=_interopRequireDefault(_Store);

var _utilsComposeReducers=require('redux/lib/utils/composeReducers.js');

var _utilsComposeReducers2=_interopRequireDefault(_utilsComposeReducers);

var _utilsComposeMiddleware=require('redux/lib/utils/composeMiddleware.js');

var _utilsComposeMiddleware2=_interopRequireDefault(_utilsComposeMiddleware);

var _middlewareThunk=require('redux/lib/middleware/thunk.js');

var _middlewareThunk2=_interopRequireDefault(_middlewareThunk);

var defaultMiddlewares=function defaultMiddlewares(_ref){
var dispatch=_ref.dispatch;
var getState=_ref.getState;
return [_middlewareThunk2['default']({dispatch:dispatch,getState:getState})];};


function createStore(reducer,initialState){
var middlewares=arguments[2] === undefined?defaultMiddlewares:arguments[2];

var finalReducer=typeof reducer === 'function'?reducer:_utilsComposeReducers2['default'](reducer);

var store=new _Store2['default'](finalReducer,initialState);
var getState=store.getState.bind(store);

var rawDispatch=store.dispatch.bind(store);
var cookedDispatch=null;

function dispatch(action){
return cookedDispatch(action);}


var finalMiddlewares=typeof middlewares === 'function'?middlewares({dispatch:dispatch,getState:getState}):middlewares;

cookedDispatch = _utilsComposeMiddleware2['default'].apply(undefined,finalMiddlewares.concat([rawDispatch]));

return {
dispatch:cookedDispatch,
subscribe:store.subscribe.bind(store),
getState:store.getState.bind(store),
getReducer:store.getReducer.bind(store),
replaceReducer:store.replaceReducer.bind(store)};}



module.exports = exports['default'];
});
__d('redux/lib/Store.js',["invariant","redux/lib/utils/isPlainObject.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}

var _invariant=require('invariant');

var _invariant2=_interopRequireDefault(_invariant);

var _utilsIsPlainObject=require('redux/lib/utils/isPlainObject.js');

var _utilsIsPlainObject2=_interopRequireDefault(_utilsIsPlainObject);

var Store=(function(){
function Store(reducer,initialState){
_classCallCheck(this,Store);

_invariant2['default'](typeof reducer === 'function','Expected the reducer to be a function.');

this.state = initialState;
this.listeners = [];
this.replaceReducer(reducer);}


Store.prototype.getReducer = function getReducer(){
return this.reducer;};


Store.prototype.replaceReducer = function replaceReducer(nextReducer){
this.reducer = nextReducer;
this.dispatch({type:'@@INIT'});};


Store.prototype.dispatch = function dispatch(action){
_invariant2['default'](_utilsIsPlainObject2['default'](action),'Actions must be plain objects. Use custom middleware for async actions.');

var reducer=this.reducer;

this.state = reducer(this.state,action);
this.listeners.forEach(function(listener){
return listener();});

return action;};


Store.prototype.getState = function getState(){
return this.state;};


Store.prototype.subscribe = function subscribe(listener){
var listeners=this.listeners;

listeners.push(listener);

return function unsubscribe(){
var index=listeners.indexOf(listener);
listeners.splice(index,1);};};



return Store;})();


exports['default'] = Store;
module.exports = exports['default'];
});
__d('invariant',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';























var invariant=function(condition,format,a,b,c,d,e,f){
if(process.env.NODE_ENV !== 'production'){
if(format === undefined){
throw new Error('invariant requires an error message argument');}}



if(!condition){
var error;
if(format === undefined){
error = new Error(
'Minified exception occurred; use the non-minified dev environment ' + 
'for the full error message and additional helpful warnings.');}else 

{
var args=[a,b,c,d,e,f];
var argIndex=0;
error = new Error(
'Invariant Violation: ' + 
format.replace(/%s/g,function(){return args[argIndex++];}));}



error.framesToPop = 1;
throw error;}};



module.exports = invariant;
});
__d('redux/lib/utils/isPlainObject.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = isPlainObject;

function isPlainObject(obj){
return obj?typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype:false;}


module.exports = exports['default'];
});
__d('redux/lib/utils/composeReducers.js',["redux/lib/utils/mapValues.js","redux/lib/utils/pick.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = composeReducers;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

var _utilsMapValues=require('redux/lib/utils/mapValues.js');

var _utilsMapValues2=_interopRequireDefault(_utilsMapValues);

var _utilsPick=require('redux/lib/utils/pick.js');

var _utilsPick2=_interopRequireDefault(_utilsPick);

function composeReducers(reducers){
var finalReducers=_utilsPick2['default'](reducers,function(val){
return typeof val === 'function';});


return function Composition(atom,action){
if(atom === undefined)atom = {};

return _utilsMapValues2['default'](finalReducers,function(store,key){
return store(atom[key],action);});};}




module.exports = exports['default'];
});
__d('redux/lib/utils/mapValues.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";

exports.__esModule = true;
exports["default"] = mapValues;

function mapValues(obj,fn){
return Object.keys(obj).reduce(function(result,key){
result[key] = fn(obj[key],key);
return result;},
{});}


module.exports = exports["default"];
});
__d('redux/lib/utils/pick.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";

exports.__esModule = true;
exports["default"] = pick;

function pick(obj,fn){
return Object.keys(obj).reduce(function(result,key){
if(fn(obj[key])){
result[key] = obj[key];}

return result;},
{});}


module.exports = exports["default"];
});
__d('redux/lib/utils/composeMiddleware.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";

exports.__esModule = true;
exports["default"] = composeMiddleware;

function composeMiddleware(){
for(var _len=arguments.length,middlewares=Array(_len),_key=0;_key < _len;_key++) {
middlewares[_key] = arguments[_key];}


return middlewares.reduceRight(function(composed,m){
return m(composed);});}



module.exports = exports["default"];
});
__d('redux/lib/middleware/thunk.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = thunkMiddleware;

function thunkMiddleware(_ref){
var dispatch=_ref.dispatch;
var getState=_ref.getState;

return function(next){
return function(action){
return typeof action === 'function'?action(dispatch,getState):next(action);};};}




module.exports = exports['default'];
});
__d('redux/lib/utils/bindActionCreators.js',["redux/lib/utils/mapValues.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = bindActionCreators;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

var _utilsMapValues=require('redux/lib/utils/mapValues.js');

var _utilsMapValues2=_interopRequireDefault(_utilsMapValues);

function bindActionCreators(actionCreators,dispatch){
return _utilsMapValues2['default'](actionCreators,function(actionCreator){
return function(){
return dispatch(actionCreator.apply(undefined,arguments));};});}




module.exports = exports['default'];
});
__d('noder/app/containers/NoderApp.js',["react-native/Libraries/react-native/react-native.js","redux/lib/index.js","noder/app/containers/Navitation.js","noder/app/actions/index.js","redux/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Redux=require('redux/lib/index.js');
var Navigation=require('noder/app/containers/Navitation.js');
var NoderActions=require('noder/app/actions/index.js');var 

bindActionCreators=Redux.bindActionCreators;var _require=



require('redux/react-native.js');var Connector=_require.Connector;var 


Component=

React.Component;var Navigator=React.Navigator;var 


NoderApp=(function(_Component){_inherits(NoderApp,_Component);
function NoderApp(props){_classCallCheck(this,NoderApp);
_get(Object.getPrototypeOf(NoderApp.prototype),'constructor',this).call(this,props);}_createClass(NoderApp,[{key:'render',value:



function render(){
return (
React.createElement(Connector,{select:function(state){return state;}},
this.renderChild));}},{key:'renderChild',value:





function renderChild(state){
var actions=bindActionCreators(NoderActions,state.dispatch);
return (
React.createElement(Navigation,{state:state,actions:actions}));}}]);return NoderApp;})(Component);





module.exports = NoderApp;
});
__d('noder/app/containers/Navitation.js',["react-native/Libraries/react-native/react-native.js","noder/app/containers/Home.js","noder/app/configs/routes.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Home=require('noder/app/containers/Home.js');
var Router=require('noder/app/configs/routes.js');var 


PropTypes=


React.PropTypes;var Component=React.Component;var Navigator=React.Navigator;var 


Navitation=(function(_Component){_inherits(Navitation,_Component);
function Navitation(props){_classCallCheck(this,Navitation);
_get(Object.getPrototypeOf(Navitation.prototype),'constructor',this).call(this,props);
this.initialRoute = {
name:'home',
index:0,
component:Home};}_createClass(Navitation,[{key:'componentDidMount',value:





function componentDidMount(){
this.props.actions.getLoginUserFromStorage();
this.props.actions.getAllTopicsFromStorage();}},{key:'renderScene',value:



function renderScene(route,navigator){var _this=this;
if(route.component){
return React.createElement.bind(this)(route.component,Object.assign({},route.props,
{
ref:function(view){return _this[route.name] = view;},
actions:this.props.actions,
state:this.props.state,
router:new Router(navigator)}));}}},{key:'configureScene',value:












function configureScene(route){
if(route.sceneConfig){
return route.sceneConfig;}

return Navigator.SceneConfigs.FloatFromRight;}},{key:'render',value:



function render(){var _this2=this;
return (
React.createElement(Navigator,{
ref:function(view){return _this2.navigator = view;},
initialRoute:this.initialRoute,
configureScene:this.configureScene.bind(this),
renderScene:this.renderScene.bind(this),
onDidFocus:function(route){
_this2[route.name] && _this2[route.name].componentDidFocus && _this2[route.name].componentDidFocus();}}));}}]);return Navitation;})(Component);






Navitation.propTypes = {
actions:PropTypes.object};



module.exports = Navitation;
});
__d('noder/app/containers/Home.js',["react-native/Libraries/react-native/react-native.js","noder/app/components/overlay/userOverlay.js","noder/app/components/login.js","noder/app/components/topicsInTab.js","noder/app/components/overlay/messageOverlay.js","noder/app/configs/routes.js","noder/app/configs/config.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');


var UserOverlay=require('noder/app/components/overlay/userOverlay.js');
var Login=require('noder/app/components/login.js');
var TopicsInTab=require('noder/app/components/topicsInTab.js');
var MessageOverlay=require('noder/app/components/overlay/messageOverlay.js');


var routes=require('noder/app/configs/routes.js');

var config=require('noder/app/configs/config.js');
var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 



View=






React.View;var Component=React.Component;var PropTypes=React.PropTypes;var Text=React.Text;var StyleSheet=React.StyleSheet;var Image=React.Image;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;var 

Home=(function(_Component){_inherits(Home,_Component);
function Home(props){_classCallCheck(this,Home);
_get(Object.getPrototypeOf(Home.prototype),'constructor',this).call(this,props);}_createClass(Home,[{key:'_userOverlayOnPress',value:



function _userOverlayOnPress(){
var actions=this.props.actions;
var state=this.props.state;
if(!state.user){
actions.openLoginModal();}else 

{
this.props.router.toUser({
isLoginUser:true});}}},{key:'render',value:





function render(){
var loginUser=this.props.state.user;
var home=this.props.state.home;

var messageOverlay=
React.createElement(MessageOverlay,{
user:loginUser,
getUnreadCount:this.props.actions.getUnreadMessageCount,
count:this.props.state.message.unreadMessageCount,
router:this.props.router});




return (
React.createElement(View,{
style:[styles.container]},
React.createElement(Image,{
style:{height:height,width:width},
source:{uri:config.bgImgUri}},

React.createElement(TopicsInTab,{
router:this.props.router,
actions:this.props.actions,
topic:this.props.state.topic})),



React.createElement(UserOverlay,{
ref:'userOverlay',
user:loginUser,
onPress:this._userOverlayOnPress.bind(this)}),



loginUser?messageOverlay:null,


React.createElement(Login,{
isModalOpen:home.isModalOpen,
checkTokenLoading:home.checkTokenLoading,
actions:this.props.actions})));}}]);return Home;})(Component);








Home.propTypes = {
actions:PropTypes.object,
state:PropTypes.object};


var styles=StyleSheet.create({
container:{
width:width,
'flex':1,
'backgroundColor':'transparent'},

page:{
width:width},

scrollContainer:{
height:height - 40,
'flex':1},

listView:{
backgroundColor:'blue'},

navScroll:{
'height':40,
'backgroundColor':'rgba(0, 0, 0, 0.75)',
'position':'absolute',
'left':0,
'right':0,
'overflow':'hidden'}});



module.exports = Home;
});
__d('noder/app/components/overlay/userOverlay.js',["react-native/Libraries/react-native/react-native.js","react-native-icons/index.js","noder/app/components/overlay/overlayButton.js","noder/app/configs/config.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;

var OverlayButton=require('noder/app/components/overlay/overlayButton.js');

var config=require('noder/app/configs/config.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=




React.View;var Text=React.Text;var Component=React.Component;var StyleSheet=React.StyleSheet;var Image=React.Image;


var overlaySize=45;

var styles=StyleSheet.create({
userImg:{
borderWidth:2,
borderColor:'#2C3E50'},

icon:{
height:overlaySize,
width:overlaySize,
borderRadius:overlaySize / 2}});var 




UserOverlay=(function(_Component){_inherits(UserOverlay,_Component);
function UserOverlay(props){_classCallCheck(this,UserOverlay);
_get(Object.getPrototypeOf(UserOverlay.prototype),'constructor',this).call(this,props);}_createClass(UserOverlay,[{key:'_renderOverlayContent',value:



function _renderOverlayContent(){
if(this.props.user){
return (
React.createElement(Image,{
style:[styles.icon,styles.userImg],
source:{uri:config.domain + this.props.user.avatar_url}}));}




return (
React.createElement(Icon,{
name:'ion|ios-person',
size:28,
color:'rgba(255,255,255,0.9)',
style:styles.icon}));}},{key:'render',value:




function render(){
return (
React.createElement(OverlayButton,{
onPress:this.props.onPress},
this._renderOverlayContent()));}}]);return UserOverlay;})(Component);





module.exports = UserOverlay;
});
__d('react-native-icons/index.js',["FAKIconImage","SMXTabBarIOS"],function(global, require, requireDynamic, requireLazy, module, exports) {  module.exports = {
Icon:require('FAKIconImage'),
TabBarIOS:require('SMXTabBarIOS')};
});
__d('FAKIconImage',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






var EdgeInsetsPropType=require('EdgeInsetsPropType');
var NativeMethodsMixin=require('NativeMethodsMixin');
var NativeModules=require('NativeModules');
var PropTypes=require('ReactPropTypes');
var ImageResizeMode=require('ImageResizeMode');
var ImageStylePropTypes=require('ImageStylePropTypes');
var React=require('React');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var StyleSheet=require('StyleSheet');
var StyleSheetPropType=require('StyleSheetPropType');

var createReactNativeComponentClass=require('createReactNativeComponentClass');
var flattenStyle=require('flattenStyle');
var insetsDiffer=require('insetsDiffer');
var invariant=require('invariant');
var merge=require('merge');
var warning=require('warning');
var deepDiffer=require('deepDiffer');

var FAKIconImage=React.createClass({displayName:'FAKIconImage',
propTypes:{
name:PropTypes.string,
size:PropTypes.number,
color:PropTypes.string,





accessible:PropTypes.bool,



accessibilityLabel:PropTypes.string,

style:StyleSheetPropType(ImageStylePropTypes),




testID:PropTypes.string},


mixins:[NativeMethodsMixin],





viewConfig:{
uiViewClassName:'UIView',
validAttributes:ReactNativeViewAttributes.UIView},


render:function(){

var style=flattenStyle([styles.base,this.props.style]);
invariant(style,'style must be initialized');

var name=this.props.name;
invariant(name,'name must be initialized');

var size=this.props.size;
invariant(size,'size must be initialized');

var color=this.props.color;


var nativeProps=merge(this.props,{
style:style,
icon:{
name:name,
size:size,
color:color}});


return React.createElement(FAKIconImageView,nativeProps);}});



var styles=StyleSheet.create({
base:{
overflow:'hidden'}});



var CommonImageViewAttributes=merge(ReactNativeViewAttributes.UIView,{
accessible:true,
accessibilityLabel:true,
icon:{diff:deepDiffer},
testID:PropTypes.string});


var FAKIconImageView=createReactNativeComponentClass({
validAttributes:CommonImageViewAttributes,
uiViewClassName:'FAKIconImage'});


module.exports = FAKIconImage;
});
__d('SMXTabBarIOS',["SMXTabBarItemIOS","react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};






var React=require('react-native/Libraries/react-native/react-native.js');var 
StyleSheet=React.StyleSheet;var requireNativeComponent=React.requireNativeComponent;var PropTypes=React.PropTypes;
var SMXTabBarIconItemIOS=require('SMXTabBarItemIOS');

var SMXTabBarIOS=React.createClass({displayName:'SMXTabBarIOS',
propTypes:{
tintColor:PropTypes.string,
barTintColor:PropTypes.string,
translucent:PropTypes.bool},


statics:{
Item:SMXTabBarIconItemIOS},


render:function(){
var nativeProps={
tintColor:this.props.tintColor,
barTintColor:this.props.barTintColor,
translucent:this.props.translucent};


return (
React.createElement(SMXIconTabBar,_extends({style:[styles.tabGroup,this.props.style]},nativeProps),
this.props.children));}});





var styles=StyleSheet.create({
tabGroup:{
flex:1}});



var SMXIconTabBar=requireNativeComponent('SMXTabBar',SMXTabBarIOS);

module.exports = SMXTabBarIOS;
});
__d('SMXTabBarItemIOS',["Dimensions","react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  '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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}






var React=require('react-native/Libraries/react-native/react-native.js');var 
Image=React.Image;var StyleSheet=React.StyleSheet;var View=React.View;var requireNativeComponent=React.requireNativeComponent;var PropTypes=React.PropTypes;



var Dimensions=require('Dimensions');

var onlyChild=React.Children.only;var 


StaticContainer=(function(_React$Component){_inherits(StaticContainer,_React$Component);function StaticContainer(){_classCallCheck(this,StaticContainer);_get(Object.getPrototypeOf(StaticContainer.prototype),'constructor',this).apply(this,arguments);}_createClass(StaticContainer,[{key:'shouldComponentUpdate',value:

function shouldComponentUpdate(nextProps){
return !!nextProps.shouldUpdate;}},{key:'render',value:


function render(){
var child=this.props.children;
return child === null || child === false?null:onlyChild(child);}}]);return StaticContainer;})(React.Component);




var SmixxTabBarItemIOS=React.createClass({displayName:'SmixxTabBarItemIOS',
propTypes:{
onPress:PropTypes.func.isRequired,
selected:PropTypes.bool.isRequired,
badgeValue:PropTypes.string,
title:PropTypes.string,
icon:PropTypes.object},


getInitialState:function(){
return {
hasBeenSelected:false};},



componentWillMount:function(){
if(this.props.selected){
this.setState({hasBeenSelected:true});}},



componentWillReceiveProps:function(nextProps){
if(this.state.hasBeenSelected || nextProps.selected){
this.setState({hasBeenSelected:true});}},



render:function(){
var tabContents=null;


if(this.state.hasBeenSelected){
tabContents = 
React.createElement(StaticContainer,{shouldUpdate:this.props.selected},
this.props.children);}else 


{
tabContents = React.createElement(View,null);}


var icon={name:this.props.iconName,size:this.props.iconSize?this.props.iconSize:28};

return (
React.createElement(SmixxTabBarItem,{
icon:icon,
selectedIcon:icon,
onPress:this.props.onPress,
selected:this.props.selected,
badgeValue:this.props.badgeValue,
title:this.props.title,
style:[styles.tab,this.props.style]},
tabContents));}});





var styles=StyleSheet.create({
tab:{
position:'absolute',
width:Dimensions.get('window').width,
height:Dimensions.get('window').height}});



var SmixxTabBarItem=requireNativeComponent('SMXTabBarItem',SmixxTabBarItemIOS);
module.exports = SmixxTabBarItemIOS;
});
__d('noder/app/components/overlay/overlayButton.js',["react-native/Libraries/react-native/react-native.js","react-native-button/Button.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Button=require('react-native-button/Button.js');var 


View=




React.View;var Text=React.Text;var Component=React.Component;var TouchableHighlight=React.TouchableHighlight;var StyleSheet=React.StyleSheet;

var overlayButtonSize=45;

var styles=StyleSheet.create({
container:{
height:overlayButtonSize,
width:overlayButtonSize,
position:'absolute',


borderRadius:overlayButtonSize / 2,
backgroundColor:'rgba(0,0,0,0.7)'},

returnIcon:{
height:overlayButtonSize,
width:overlayButtonSize,
borderRadius:overlayButtonSize / 2},

defaultPosition:{
left:20,
bottom:20}});var 




OverlayButton=(function(_Component){_inherits(OverlayButton,_Component);
function OverlayButton(props){_classCallCheck(this,OverlayButton);
_get(Object.getPrototypeOf(OverlayButton.prototype),'constructor',this).call(this,props);}_createClass(OverlayButton,[{key:'render',value:



function render(){
return (
React.createElement(View,{
style:[styles.container,this.props.position?this.props.position:styles.defaultPosition,this.props.style]},
React.createElement(Button,{
style:this.props.buttonStyle,
onPress:this.props.onPress},
this.props.children)));}}]);return OverlayButton;})(Component);







module.exports = OverlayButton;
});
__d('react-native-button/Button.js',["react-native/Libraries/react-native/react-native.js","react-native-button/coalesceNonElementChildren.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};

var React=require('react-native/Libraries/react-native/react-native.js');var 

PropTypes=




React.PropTypes;var StyleSheet=React.StyleSheet;var Text=React.Text;var TouchableOpacity=React.TouchableOpacity;var View=React.View;

var coalesceNonElementChildren=require('react-native-button/coalesceNonElementChildren.js');

var systemButtonOpacity=0.2;

var Button=React.createClass({displayName:'Button',
propTypes:_extends({},
TouchableOpacity.propTypes,{
disabled:PropTypes.bool,
style:Text.propTypes.style}),


render:function(){
var touchableProps={
activeOpacity:this._computeActiveOpacity()};

if(!this.props.disabled){
touchableProps.onPress = this.props.onPress;
touchableProps.onPressIn = this.props.onPressIn;
touchableProps.onPressOut = this.props.onPressOut;
touchableProps.onLongPress = this.props.onLongPress;}


return (
React.createElement(TouchableOpacity,touchableProps,
this._renderGroupedChildren()));},




_renderGroupedChildren:function(){var _this=this;
var buttonStateStyle=this.props.disabled?styles.disabledText:null;

var children=coalesceNonElementChildren(this.props.children,function(children,index){
return (
React.createElement(Text,{
key:index,
style:[styles.text,buttonStateStyle,_this.props.style]},
children));});




switch(children.length){
case 0:
return null;
case 1:
return children[0];
default:
return React.createElement(View,{style:styles.group},children);}},



_computeActiveOpacity:function(){
if(this.props.disabled){
return 1;}

return this.props.activeOpacity != null?
this.props.activeOpacity:
systemButtonOpacity;}});



var styles=StyleSheet.create({
text:{
color:'#007aff',
fontFamily:'.HelveticaNeueInterface-MediumP4',
fontSize:17,
fontWeight:'bold',
textAlign:'center'},

disabledText:{
color:'#dcdcdc'},

group:{
flexDirection:'row',
justifyContent:'space-between',
alignItems:'center'}});



module.exports = Button;
});
__d('react-native-button/coalesceNonElementChildren.js',["react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

var React=require('react-native/Libraries/react-native/react-native.js');

function coalesceNonElementChildren(children,coalesceNodes){
var coalescedChildren=[];

var contiguousNonElements=[];
React.Children.forEach(children,function(child){
if(!React.isValidElement(child)){
contiguousNonElements.push(child);
return;}


if(contiguousNonElements.length){
var coalescedChild=coalesceNodes(contiguousNonElements,coalescedChildren.length);
coalescedChildren.push(
coalesceNodes(contiguousNonElements,coalescedChildren.length));

contiguousNonElements = [];}


coalescedChildren.push(child);});


if(contiguousNonElements.length){
coalescedChildren.push(
coalesceNodes(contiguousNonElements,coalescedChildren.length));}



return coalescedChildren;}


module.exports = coalesceNonElementChildren;
});
__d('noder/app/configs/config.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  module.exports = {
domain:'https://cnodejs.org',
apiPath:'/api/v1',
bgImgUri:'http://lingyong-me.qiniudn.com/127H.jpg 2014-10-28 20:33-px1366',
replySuffix:'\n\nFrom [Noder](https://github.com/soliury/noder-react-native)'};
});
__d('noder/app/util/window.js',["Dimensions","react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var React=require('react-native/Libraries/react-native/react-native.js');
var Dimensions=require('Dimensions');var 



AlertIOS=

React.AlertIOS;var LinkingIOS=React.LinkingIOS;



exports.get = function(){
return Dimensions.get('window');};



exports.alert = function(content){
AlertIOS.alert(content);};



exports.link = function(url){
LinkingIOS.canOpenURL(url,function(supported){
if(!supported){
console.warn('Can\'t support the url');}else 
{
LinkingIOS.openURL(url);}});};
});
__d('noder/app/components/login.js',["Modal","react-native/Libraries/react-native/react-native.js","react-native-button/Button.js","react-native-icons/index.js","noder/app/configs/routes.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Modal=require('Modal');
var Button=require('react-native-button/Button.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;


var routes=require('noder/app/configs/routes.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=











React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;var AsyncStorage=React.AsyncStorage;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;


var styles=StyleSheet.create({
wrapper:{
flexDirection:'column',
alignItems:'center',
justifyContent:'space-between',
height:40,
backgroundColor:'transparent'},

row:{
height:40,
backgroundColor:'#3498DB',
paddingTop:10,
paddingBottom:10,
paddingLeft:20,
paddingRight:20,
flexDirection:'row',
alignItems:'center',
borderRadius:2},

button:{
flexDirection:'row',
alignItems:'center'},

icon:{
height:40,
width:30,
marginRight:10},

closeIcon:{
height:20,
width:20},

closeButton:{
position:'absolute',

borderRadius:2,

right:20,
top:20,
paddingLeft:10,
paddingRight:10,
paddingTop:10,
paddingBottom:5},

buttonText:{
color:'rgba(255,255,255,0.8)'},

loading:{
paddingRight:40,
paddingLeft:40,
paddingTop:10,
paddingBottom:10}});



var modalStyles=StyleSheet.create({
container:{
position:'absolute',
top:0,
bottom:0,
left:0,
right:0,
backgroundColor:'transparent',
justifyContent:'center'},

backdrop:{
position:'absolute',
top:0,
bottom:0,
left:0,
right:0,
backgroundColor:'#000000',
opacity:0.5},

modal:{
backgroundColor:'rgba(0,0,0,0.3)',
borderRadius:3,
borderWidth:2,
borderColor:'rgba(255,255,255,0.3)',
paddingTop:40,
paddingBottom:40,
margin:20}});var 



Login=(function(_Component){_inherits(Login,_Component);
function Login(props){_classCallCheck(this,Login);
_get(Object.getPrototypeOf(Login.prototype),'constructor',this).call(this,props);}_createClass(Login,[{key:'closeModal',value:



function closeModal(){
this.props.actions.closeLoginModal();}},{key:'_onLoginPress',value:



function _onLoginPress(){
if(this.props.checkTokenLoading)return;
routes.toQRCode(this);}},{key:'_getCustomCloseButton',value:



function _getCustomCloseButton(){
return (
React.createElement(View,{style:styles.closeButton},
React.createElement(Button,null,
React.createElement(Icon,{
name:'ion|ios-close-empty',
size:30,
color:'rgba(255,255,255,0.5)',
style:styles.closeIcon}))));}},{key:'_renderLoginButton',value:






function _renderLoginButton(){
if(this.props.checkTokenLoading){
return (
React.createElement(ActivityIndicatorIOS,{
hidesWhenStopped:false,
size:'small',
animating:true,
color:'white',
style:styles.loading}));}



return (
React.createElement(Button,{
onPress:this._onLoginPress.bind(this),
style:styles.button},
React.createElement(Icon,{
name:'ion|camera',
size:28,
color:'rgba(255,255,255,0.7)',
style:styles.icon}),
React.createElement(Text,{style:styles.buttonText},'扫码登陆')));}},{key:'render',value:





function render(){var _this=this;

return (
React.createElement(Modal,{
customCloseButton:this._getCustomCloseButton(),
style:modalStyles,
onPressBackdrop:this.closeModal.bind(this),
hideCloseButton:false,
backdropType:'blur',
backdropBlur:'dark',
isVisible:this.props.isModalOpen,
onClose:function(){return _this.closeModal();}},

React.createElement(View,{style:styles.wrapper},
React.createElement(View,{style:styles.row},

this._renderLoginButton()))));}}]);return Login;})(Component);










module.exports = Login;
});
__d('Modal',["Overlay","react-native/Libraries/react-native/react-native.js","react-native-modal/Transitions.js","react-native-modal/Style.js","react-native-blur/index.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






var merge=require('merge');

var React=require('react-native/Libraries/react-native/react-native.js');var 

View=




React.View;var Text=React.Text;var TouchableOpacity=React.TouchableOpacity;var TouchableWithoutFeedback=React.TouchableWithoutFeedback;var PropTypes=React.PropTypes;

var Transitions=require('react-native-modal/Transitions.js');
var DefaultStyles=require('react-native-modal/Style.js');
var Overlay=require('Overlay');
var BlurView=require('react-native-blur/index.js').BlurView;
var noop=function(){};

var ModalMixin={
getInitialState:function(){
return {isModalOpen:false};},


openModal:function(){
this.setState({isModalOpen:true});},


closeModal:function(){
this.setState({isModalOpen:false});}};



var Modal=React.createClass({displayName:'Modal',
mixins:[Transitions.Mixin],

statics:{
transitionEasings:Transitions.Easings,
Mixin:ModalMixin,
DefaultStyles:DefaultStyles},


propTypes:{
isVisible:PropTypes.bool,
hideCloseButton:PropTypes.bool,
backdropType:PropTypes.string,
onClose:PropTypes.func,
onPressBackdrop:PropTypes.func,
customCloseButton:PropTypes.node,
customShowHandler:PropTypes.func,
customHideHandler:PropTypes.func,
forceToFront:PropTypes.bool,
containerPointerEvents:PropTypes.string},


getDefaultProps:function(){
return {
isVisible:false,
hideCloseButton:false,
onClose:noop,
onPressBackdrop:noop,
backdropType:'plain',
backdropBlur:'light',
forceToFront:false,
containerPointerEvents:'auto'};},



componentWillReceiveProps:function(nextProps){
var willBeVisible=nextProps.isVisible;var _props=




this.props;var isVisible=_props.isVisible;var customShowHandler=_props.customShowHandler;var customHideHandler=_props.customHideHandler;

if(willBeVisible !== isVisible){
var fadeIn=function(t){return t('opacity',{duration:300,begin:0,end:1});};
var fadeOut=function(t){return t('opacity',{duration:300,end:0});};

if(willBeVisible){
var showHandler=customShowHandler || fadeIn;
showHandler(this.transition);}else 
{
var hideHandler=customHideHandler || fadeOut;
hideHandler(this.transition);}}},




renderCloseButton:function(){var _props2=




this.props;var customCloseButton=_props2.customCloseButton;var hideCloseButton=_props2.hideCloseButton;var onClose=_props2.onClose;

var styles=this.props.style || DefaultStyles;

if(customCloseButton){
return React.addons.cloneWithProps(customCloseButton,null);}else 
if(!hideCloseButton && onClose){
return (
React.createElement(View,{style:styles.closeButton},
React.createElement(TouchableOpacity,{onPress:onClose},
React.createElement(Text,{style:styles.closeButtonText},'Close'))));}},






renderBody:function(){
var styles=this.props.style || DefaultStyles;

var responderProps=this.extractResponderProps();

return (
React.createElement(View,responderProps,
this.renderCloseButton(),
React.createElement(View,{style:styles.modal,pointerEvents:this.props.containerPointerEvents},
React.Children.map(this.props.children,React.addons.cloneWithProps))));},





extractResponderProps:function(){
var responderProps={};
if(this.props.onMoveShouldSetResponder)responderProps.onMoveShouldSetResponder = this.props.onMoveShouldSetResponder;
if(this.props.onMoveShouldSetResponderCapture)responderProps.onMoveShouldSetResponderCapture = this.props.onMoveShouldSetResponderCapture;
if(this.props.onResponderEnd)responderProps.onResponderEnd = this.props.onResponderEnd;
if(this.props.onResponderGrant)responderProps.onResponderGrant = this.props.onResponderGrant;
if(this.props.onResponderMove)responderProps.onResponderMove = this.props.onResponderMove;
if(this.props.onResponderReject)responderProps.onResponderReject = this.props.onResponderReject;
if(this.props.onResponderRelease)responderProps.onResponderRelease = this.props.onResponderRelease;
if(this.props.onResponderStart)responderProps.onResponderStart = this.props.onResponderStart;
if(this.props.onResponderTerminate)responderProps.onResponderTerminate = this.props.onResponderTerminate;
if(this.props.onResponderTerminationRequest)responderProps.onResponderTerminationRequest = this.props.onResponderTerminationRequest;
if(this.props.onStartShouldSetResponder)responderProps.onStartShouldSetResponder = this.props.onStartShouldSetResponder;
if(this.props.onStartShouldSetResponderCapture)responderProps.onStartShouldSetResponderCapture = this.props.onStartShouldSetResponderCapture;
return responderProps;},


renderModal:function(){var _props3=




this.props;var onPressBackdrop=_props3.onPressBackdrop;var backdropType=_props3.backdropType;var backdropBlur=_props3.backdropBlur;

var styles=this.props.style || DefaultStyles;
var body=this.renderBody();

if(backdropType == 'plain'){
return (
React.createElement(View,{style:[styles.container,this.transitionStyles()]},
React.createElement(TouchableWithoutFeedback,{onPress:onPressBackdrop},
React.createElement(View,{style:styles.backdrop})),

body));}else 


if(backdropType === 'none'){
return (
React.createElement(View,{style:[styles.container,this.transitionStyles()]},
body));}else 


{
return (
React.createElement(TouchableWithoutFeedback,{onPress:onPressBackdrop},
React.createElement(BlurView,{blurType:backdropBlur,style:[styles.container,this.transitionStyles()]},
body)));}},






render:function(){
var styles=this.props.style || DefaultStyles;var _props4=
this.props;var isVisible=_props4.isVisible;var forceToFront=_props4.forceToFront;

if(!isVisible && !this.state.isTransitioning){
return React.createElement(View,null);}


if(forceToFront){
return (
React.createElement(Overlay,{isVisible:true,aboveStatusBar:true,style:styles.container},
this.renderModal()));}else 


{
return (
React.createElement(View,{style:styles.container},this.renderModal()));}}});





module.exports = Modal;
});
__d('react-native-modal/Transitions.js',["react-tween-state/index.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _require=

require('react-tween-state/index.js');var Mixin=_require.Mixin;var easingTypes=_require.easingTypes;

var Transitions=Object.assign(Mixin,{
getInitialState:function(){
return {
isTransitioning:false,
tweenQueue:[],
tweenProperties:[]};},



transition:function(property,options){var _this=this;
this.setState({isTransitioning:true});


if(this.state.tweenProperties.indexOf(property) === -1){


this.state.tweenProperties.push(property);}



var begin=typeof options.begin === 'undefined'?this.state[property]:options.begin;
this.tweenState(property,{
easing:options.easing || easingTypes.easeInOutQuad,
duration:options.duration || 300,
delay:options.delay,
beginValue:begin,
endValue:options.end,
onEnd:function(){

requestAnimationFrame(function(){

if(!_this.state.tweenQueue.length){
_this.setState({isTransitioning:false});}



if(options.reset){
_this.state[property] = begin;}



if(options.onEnd){
options.onEnd();}});}});},






transitionStyles:function(propertySet){var _this2=this;
if(typeof propertySet === 'undefined'){
propertySet = [];}

var result={};

this.state.tweenProperties.forEach(function(property){
if(propertySet.length === 0 || propertySet.indexOf(property) > -1){
var value,tweeningValue=_this2.getTweeningValue(property);

if(typeof tweeningValue === 'undefined' || tweeningValue === null){
value = _this2.state[property];}else 
{
value = tweeningValue;}


result[property] = value;}});



return result;}});



module.exports = {
Mixin:Transitions,
Easings:easingTypes};
});
__d('react-tween-state/index.js',["tween-functions/index.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

var easingTypes=require('tween-functions/index.js');




var DEFAULT_STACK_BEHAVIOR='ADDITIVE';
var DEFAULT_EASING=easingTypes.easeInOutQuad;
var DEFAULT_DURATION=300;
var DEFAULT_DELAY=0;


function returnState(state){
return state;}


var tweenState={
easingTypes:easingTypes,
stackBehavior:{
ADDITIVE:'ADDITIVE',
DESTRUCTIVE:'DESTRUCTIVE'}};



tweenState.Mixin = {
getInitialState:function(){
return {
tweenQueue:[]};},



tweenState:function(a,b,c){








if(typeof a === 'string'){
c = b;
b = a;
a = returnState;}

this._tweenState(a,b,c);},


_tweenState:function(stateRefFunc,stateName,config){


var state=this._pendingState || this.state;
var stateRef=stateRefFunc(state);


var newConfig={
easing:config.easing || DEFAULT_EASING,
duration:config.duration == null?DEFAULT_DURATION:config.duration,
delay:config.delay == null?DEFAULT_DELAY:config.delay,
beginValue:config.beginValue == null?stateRef[stateName]:config.beginValue,
endValue:config.endValue,
onEnd:config.onEnd,
stackBehavior:config.stackBehavior || DEFAULT_STACK_BEHAVIOR};


var newTweenQueue=state.tweenQueue;
if(newConfig.stackBehavior === tweenState.stackBehavior.DESTRUCTIVE){
newTweenQueue = state.tweenQueue.filter(function(item){
return item.stateName !== stateName || item.stateRefFunc(state) !== stateRef;});}



newTweenQueue.push({
stateRefFunc:stateRefFunc,
stateName:stateName,
config:newConfig,
initTime:Date.now() + newConfig.delay});




stateRef[stateName] = newConfig.endValue;

this.setState({tweenQueue:newTweenQueue});

if(newTweenQueue.length === 1){
this.startRaf();}},



getTweeningValue:function(a,b){

if(typeof a === 'string'){
b = a;
a = returnState;}

return this._getTweeningValue(a,b);},


_getTweeningValue:function(stateRefFunc,stateName){
var state=this.state;
var stateRef=stateRefFunc(state);
var tweeningValue=stateRef[stateName];
var now=Date.now();

for(var i=0;i < state.tweenQueue.length;i++) {
var item=state.tweenQueue[i];
var itemStateRef=item.stateRefFunc(state);
if(item.stateName !== stateName || itemStateRef !== stateRef){
continue;}


var progressTime=now - item.initTime > item.config.duration?
item.config.duration:
Math.max(0,now - item.initTime);



var contrib=-item.config.endValue + item.config.easing(
progressTime,
item.config.beginValue,
item.config.endValue,
item.config.duration);


tweeningValue += contrib;}


return tweeningValue;},


_rafCb:function(){
var state=this.state;
if(state.tweenQueue.length === 0){
return;}


var now=Date.now();
var newTweenQueue=[];

for(var i=0;i < state.tweenQueue.length;i++) {
var item=state.tweenQueue[i];
if(now - item.initTime < item.config.duration){
newTweenQueue.push(item);}else 
{
item.config.onEnd && item.config.onEnd();}}




if(!this.isMounted()){
return;}


this.setState({
tweenQueue:newTweenQueue});


requestAnimationFrame(this._rafCb);},


startRaf:function(){
requestAnimationFrame(this._rafCb);}};




module.exports = tweenState;
});
__d('tween-functions/index.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';


var tweenFunctions={
linear:function(t,b,_c,d){
var c=_c - b;
return c * t / d + b;},

easeInQuad:function(t,b,_c,d){
var c=_c - b;
return c * (t /= d) * t + b;},

easeOutQuad:function(t,b,_c,d){
var c=_c - b;
return -c * (t /= d) * (t - 2) + b;},

easeInOutQuad:function(t,b,_c,d){
var c=_c - b;
if((t /= d / 2) < 1){
return c / 2 * t * t + b;}else 
{
return -c / 2 * (--t * (t - 2) - 1) + b;}},


easeInCubic:function(t,b,_c,d){
var c=_c - b;
return c * (t /= d) * t * t + b;},

easeOutCubic:function(t,b,_c,d){
var c=_c - b;
return c * ((t = t / d - 1) * t * t + 1) + b;},

easeInOutCubic:function(t,b,_c,d){
var c=_c - b;
if((t /= d / 2) < 1){
return c / 2 * t * t * t + b;}else 
{
return c / 2 * ((t -= 2) * t * t + 2) + b;}},


easeInQuart:function(t,b,_c,d){
var c=_c - b;
return c * (t /= d) * t * t * t + b;},

easeOutQuart:function(t,b,_c,d){
var c=_c - b;
return -c * ((t = t / d - 1) * t * t * t - 1) + b;},

easeInOutQuart:function(t,b,_c,d){
var c=_c - b;
if((t /= d / 2) < 1){
return c / 2 * t * t * t * t + b;}else 
{
return -c / 2 * ((t -= 2) * t * t * t - 2) + b;}},


easeInQuint:function(t,b,_c,d){
var c=_c - b;
return c * (t /= d) * t * t * t * t + b;},

easeOutQuint:function(t,b,_c,d){
var c=_c - b;
return c * ((t = t / d - 1) * t * t * t * t + 1) + b;},

easeInOutQuint:function(t,b,_c,d){
var c=_c - b;
if((t /= d / 2) < 1){
return c / 2 * t * t * t * t * t + b;}else 
{
return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;}},


easeInSine:function(t,b,_c,d){
var c=_c - b;
return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;},

easeOutSine:function(t,b,_c,d){
var c=_c - b;
return c * Math.sin(t / d * (Math.PI / 2)) + b;},

easeInOutSine:function(t,b,_c,d){
var c=_c - b;
return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;},

easeInExpo:function(t,b,_c,d){
var c=_c - b;
var _ref;
return (_ref = t === 0) !== null?_ref:{
b:c * Math.pow(2,10 * (t / d - 1)) + b};},


easeOutExpo:function(t,b,_c,d){
var c=_c - b;
var _ref;
return (_ref = t === d) !== null?_ref:b + {
c:c * (-Math.pow(2,-10 * t / d) + 1) + b};},


easeInOutExpo:function(t,b,_c,d){
var c=_c - b;
if(t === 0){
b;}

if(t === d){
b + c;}

if((t /= d / 2) < 1){
return c / 2 * Math.pow(2,10 * (t - 1)) + b;}else 
{
return c / 2 * (-Math.pow(2,-10 * --t) + 2) + b;}},


easeInCirc:function(t,b,_c,d){
var c=_c - b;
return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;},

easeOutCirc:function(t,b,_c,d){
var c=_c - b;
return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;},

easeInOutCirc:function(t,b,_c,d){
var c=_c - b;
if((t /= d / 2) < 1){
return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;}else 
{
return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;}},


easeInElastic:function(t,b,_c,d){
var c=_c - b;
var a,p,s;
s = 1.70158;
p = 0;
a = c;
if(t === 0){
b;}else 
if((t /= d) === 1){
b + c;}

if(!p){
p = d * 0.3;}

if(a < Math.abs(c)){
a = c;
s = p / 4;}else 
{
s = p / (2 * Math.PI) * Math.asin(c / a);}

return -(a * Math.pow(2,10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;},

easeOutElastic:function(t,b,_c,d){
var c=_c - b;
var a,p,s;
s = 1.70158;
p = 0;
a = c;
if(t === 0){
b;}else 
if((t /= d) === 1){
b + c;}

if(!p){
p = d * 0.3;}

if(a < Math.abs(c)){
a = c;
s = p / 4;}else 
{
s = p / (2 * Math.PI) * Math.asin(c / a);}

return a * Math.pow(2,-10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b;},

easeInOutElastic:function(t,b,_c,d){
var c=_c - b;
var a,p,s;
s = 1.70158;
p = 0;
a = c;
if(t === 0){
b;}else 
if((t /= d / 2) === 2){
b + c;}

if(!p){
p = d * (0.3 * 1.5);}

if(a < Math.abs(c)){
a = c;
s = p / 4;}else 
{
s = p / (2 * Math.PI) * Math.asin(c / a);}

if(t < 1){
return -0.5 * (a * Math.pow(2,10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;}else 
{
return a * Math.pow(2,-10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * 0.5 + c + b;}},


easeInBack:function(t,b,_c,d,s){
var c=_c - b;
if(s === void 0){
s = 1.70158;}

return c * (t /= d) * t * ((s + 1) * t - s) + b;},

easeOutBack:function(t,b,_c,d,s){
var c=_c - b;
if(s === void 0){
s = 1.70158;}

return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;},

easeInOutBack:function(t,b,_c,d,s){
var c=_c - b;
if(s === void 0){
s = 1.70158;}

if((t /= d / 2) < 1){
return c / 2 * (t * t * (((s *= 1.525) + 1) * t - s)) + b;}else 
{
return c / 2 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;}},


easeInBounce:function(t,b,_c,d){
var c=_c - b;
var v;
v = tweenFunctions.easeOutBounce(d - t,0,c,d);
return c - v + b;},

easeOutBounce:function(t,b,_c,d){
var c=_c - b;
if((t /= d) < 1 / 2.75){
return c * (7.5625 * t * t) + b;}else 
if(t < 2 / 2.75){
return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b;}else 
if(t < 2.5 / 2.75){
return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b;}else 
{
return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b;}},


easeInOutBounce:function(t,b,_c,d){
var c=_c - b;
var v;
if(t < d / 2){
v = tweenFunctions.easeInBounce(t * 2,0,c,d);
return v * 0.5 + b;}else 
{
v = tweenFunctions.easeOutBounce(t * 2 - d,0,c,d);
return v * 0.5 + c * 0.5 + b;}}};




module.exports = tweenFunctions;
});
__d('react-native-modal/Style.js',["react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

var StyleSheet=require('react-native/Libraries/react-native/react-native.js').StyleSheet;

module.exports = StyleSheet.create({
container:{
position:'absolute',
top:0,
bottom:0,
left:0,
right:0,
backgroundColor:'transparent',
justifyContent:'center'},

backdrop:{
position:'absolute',
top:0,
bottom:0,
left:0,
right:0,
backgroundColor:'#000000',
opacity:0.5},

closeButton:{
position:'absolute',
borderColor:'#ffffff',
borderRadius:2,
borderWidth:1,
right:20,
top:20,
paddingLeft:10,
paddingRight:10,
paddingTop:5,
paddingBottom:5},

closeButtonText:{
color:'#ffffff'},

modal:{
margin:20,
backgroundColor:'#ffffff',
borderRadius:3,
padding:20}});
});
__d('Overlay',["react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';






var React=require('react-native/Libraries/react-native/react-native.js');var 

View=



React.View;var PropTypes=React.PropTypes;var StyleSheet=React.StyleSheet;var requireNativeComponent=React.requireNativeComponent;





var Overlay=React.createClass({displayName:'Overlay',
propTypes:{




aboveStatusBar:React.PropTypes.bool,





isVisible:React.PropTypes.bool},


getDefaultProps:function(){
return {
aboveStatusBar:false,
isVisible:false};},



render:function(){var 

isVisible=
this.props.isVisible;

if(this.props.isVisible){
return (
React.createElement(RNOverlay,{isVisible:true,style:styles.container,pointerEvents:'none',aboveStatusBar:this.props.aboveStatusBar},
React.Children.map(this.props.children,React.addons.cloneWithProps)));}else 


{
return React.createElement(View,null);}}});




var RNOverlay=requireNativeComponent('RNOverlay',Overlay);

var styles=StyleSheet.create({
container:{
position:'absolute',
top:0,
bottom:0,
left:0,
right:0,
borderWidth:0,
backgroundColor:'transparent'}});



module.exports = Overlay;
});
__d('react-native-blur/index.js',["react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var React=require('react-native/Libraries/react-native/react-native.js');var 
requireNativeComponent=React.requireNativeComponent;

var BlurView=React.createClass({displayName:'BlurView',
propTypes:{
blurType:React.PropTypes.string},


render:function(){
return React.createElement(NativeBlurView,this.props);}});


var NativeBlurView=requireNativeComponent('BlurView',BlurView);

var VibrancyView=React.createClass({displayName:'VibrancyView',
propTypes:{
blurType:React.PropTypes.string},


render:function(){
return React.createElement(NativeVibrancyView,this.props);}});


var NativeVibrancyView=requireNativeComponent('VibrancyView',VibrancyView);



module.exports = {
BlurView:BlurView,
VibrancyView:VibrancyView};
});
__d('noder/app/configs/routes.js',["react-native/Libraries/react-native/react-native.js","noder/app/containers/User.js","noder/app/scene/topic.js","noder/app/scene/comments.js","noder/app/containers/Message.js","noder/app/containers/QRCode.js","noder/app/configs/sceneConfig.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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');}}var React=require('react-native/Libraries/react-native/react-native.js');


var User=require('noder/app/containers/User.js');
var Topic=require('noder/app/scene/topic.js');
var Comments=require('noder/app/scene/comments.js');
var Message=require('noder/app/containers/Message.js');
var QRCode=require('noder/app/containers/QRCode.js');


var sceneConfig=require('noder/app/configs/sceneConfig.js');var 



Navigator=
React.Navigator;

var customFloatFromRight=sceneConfig.customFloatFromRight;var 


Router=(function(){
function Router(navigator){_classCallCheck(this,Router);
this.navigator = navigator;}_createClass(Router,[{key:'push',value:


function push(props,route){
var routesList=this.navigator.getCurrentRoutes();
var nextIndex=routesList[routesList.length - 1].index + 1;
route.props = props;
route.index = nextIndex;
this.navigator.push(route);}},{key:'pop',value:



function pop(){
this.navigator.pop();}},{key:'toUser',value:



function toUser(props){
this.push(props,{
component:User,
name:'user',
sceneConfig:customFloatFromRight});}},{key:'toTopic',value:



function toTopic(props){
this.push(props,{
component:Topic,
name:'topic',
sceneConfig:customFloatFromRight});}},{key:'toComments',value:



function toComments(props){
this.push(props,{
component:Comments,
name:'comments',
sceneConfig:customFloatFromRight});}},{key:'toMessage',value:



function toMessage(props){
this.push(props,{
component:Message,
name:'message',
sceneConfig:customFloatFromRight});}},{key:'toQRCode',value:



function toQRCode(props){
this.push(props,{
component:QRCode,
name:'qrCode',
sceneConfig:Navigator.SceneConfigs.FloatFromBottom});}}]);return Router;})();




module.exports = Router;
});
__d('noder/app/containers/User.js',["react-native/Libraries/react-native/react-native.js","moment/moment.js","react-native-scrollable-tab-view/index.js","react-native-icons/index.js","noder/app/components/userTopicPage.js","noder/app/components/overlay/return.js","noder/app/components/TabBar.js","noder/app/util/genColor.js","noder/app/services/userService.js","noder/app/configs/config.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}
var React=require('react-native/Libraries/react-native/react-native.js');
var moment=require('moment/moment.js');
var ScrollableTabView=require('react-native-scrollable-tab-view/index.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;



var UserTopicPage=require('noder/app/components/userTopicPage.js');
var Return=require('noder/app/components/overlay/return.js');
var TabBar=require('noder/app/components/TabBar.js');


var genColor=require('noder/app/util/genColor.js');
var UserService=require('noder/app/services/userService.js');
var config=require('noder/app/configs/config.js');
var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=












React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var TouchableHighlight=React.TouchableHighlight;var TouchableOpacity=React.TouchableOpacity;var Navigator=React.Navigator;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;var LayoutAnimation=React.LayoutAnimation;var 


User=(function(_Component){_inherits(User,_Component);
function User(props){_classCallCheck(this,User);
_get(Object.getPrototypeOf(User.prototype),'constructor',this).call(this,props);
this.state = {
userInfo:null,
wallColor:genColor(),
didFocus:false};}_createClass(User,[{key:'componentDidMount',value:




function componentDidMount(){
if(this.props.isLoginUser){
this.props.actions.fetchUser(this.props.state.user);}else 

{
this._getUserInfo();}}},{key:'componentDidFocus',value:




function componentDidFocus(){
LayoutAnimation.configureNext(LayoutAnimation.Presets.spring);
this.setState({
didFocus:true});}},{key:'_onGithubPress',value:




function _onGithubPress(name){
if(name == '' || !name)return;
window.link('https://github.com/' + name);}},{key:'_getUserInfo',value:



function _getUserInfo(){var _this=this;
var userName=this.props.userName;

UserService.req.getUserInfo(userName).
then(function(userInfo){
console.log('get userINfo');
_this.setState({
userInfo:userInfo});}).


catch(function(err){
console.warn(err);
if(err == 'UserNotExist'){
window.alert('用户不存在');
Navigator.getContext(_this).pop();}}).


done();}},{key:'_renderUserTopics',value:



function _renderUserTopics(userInfo){
var recentReplies=userInfo.recent_replies;
var recentTopics=userInfo.recent_topics;
var collectTopics=userInfo.collect_topics;
if(this.state.didFocus){
return (
React.createElement(View,{style:styles.list},
React.createElement(ScrollableTabView,{
edgeHitWidth:width / 3 * 2,
renderTabBar:function(){return TabBar;}},
React.createElement(UserTopicPage,{
router:this.props.router,
style:styles.userTopicPage,
data:recentReplies,
tabLabel:'最近回复'}),
React.createElement(UserTopicPage,{
router:this.props.router,
style:styles.userTopicPage,
data:recentTopics,
tabLabel:'最近发布'}),
React.createElement(UserTopicPage,{
router:this.props.router,
style:styles.userTopicPage,
data:collectTopics,
tabLabel:'收藏'}))));}





if(this.props.isLoginUser){
return (
React.createElement(ActivityIndicatorIOS,{
hidesWhenStopped:true,
size:'large',
animating:true,
style:styles.loading}));}}},{key:'render',value:






function render(){
var userInfo=this.state.userInfo;

var isLoginUser=this.props.isLoginUser;

if(isLoginUser){
userInfo = this.props.state.user;}


if(!userInfo){
return (
React.createElement(View,{style:styles.container},
React.createElement(ActivityIndicatorIOS,{
hidesWhenStopped:true,
size:'large',
animating:true,
style:styles.loading})));}




var imgUri=config.domain + userInfo.avatar_url;
var createTime=moment(userInfo.create_at).format('l');
var authorName=userInfo.loginname;
var githubName=userInfo.githubUsername;
var pubTopicIcon=
React.createElement(TouchableOpacity,null,
React.createElement(Icon,{
name:'ion|ios-compose',
size:34,
color:'rgba(255,255,255,0.7)',
style:styles.icon}));



var settingIcon=
React.createElement(TouchableOpacity,null,
React.createElement(Icon,{
name:'ion|ios-gear',
size:34,
color:'rgba(255,255,255,0.7)',
style:styles.icon}));



return (
React.createElement(View,{style:styles.container},
React.createElement(View,{style:[styles.bgWall,{backgroundColor:this.state.wallColor}]},
React.createElement(View,{style:styles.imgRow},

isLoginUser?pubTopicIcon:null,

React.createElement(TouchableOpacity,{
onPress:this._onGithubPress.bind(this,githubName)},
React.createElement(Image,{
style:styles.authorImg,
source:{uri:imgUri}})),



isLoginUser?settingIcon:null),




React.createElement(TouchableOpacity,{
onPress:this._onGithubPress.bind(this,authorName)},
React.createElement(Text,{style:styles.github},
authorName)),




React.createElement(View,{style:styles.bgWallFooter},
React.createElement(Text,{style:styles.bgWallFooterText},
'注册时间: ' + createTime),


React.createElement(Text,{style:styles.bgWallFooterText},
'积分:' + userInfo.score))),



this._renderUserTopics(userInfo),

React.createElement(Return,{router:this.props.router})));}}]);return User;})(Component);





var bgWallHeight=160;
var authorWrapperHeight=100;
var authorImgSize=60;
var fontColor='rgba(255,255,255,0.7)';

var styles=StyleSheet.create({
container:{
flex:1,
backgroundColor:'white'},

loading:{
flex:1,
width:width},

bgWall:{
height:bgWallHeight,
flexDirection:'column',
justifyContent:'space-between',
alignItems:'center',
paddingTop:30,
paddingBottom:10},

imgRow:{
width:width,
flexDirection:'row',
justifyContent:'space-around'},

icon:{
width:30,
height:authorImgSize},

authorWrapper:{
height:authorWrapperHeight,
flexDirection:'column',
alignItems:'center',
justifyContent:'space-between'},

authorImg:{
height:authorImgSize,
width:authorImgSize,
borderRadius:authorImgSize / 2},

bgWallFooter:{
flexDirection:'row',
justifyContent:'space-between',
width:width},

bgWallFooterText:{
paddingLeft:10,
paddingRight:10,
fontSize:12,
color:'rgba(255,255,255,0.6)'},

github:{
color:fontColor},

userTopicPage:{
height:height - bgWallHeight - 70},

list:{
width:width}});





module.exports = User;
});
__d('moment/moment.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  (





function(global,factory){
typeof exports === 'object' && typeof module !== 'undefined'?module.exports = factory():
typeof define === 'function' && define.amd?define(factory):
global.moment = factory();})(
this,function(){'use strict';

var hookCallback;

function utils_hooks__hooks(){
return hookCallback.apply(null,arguments);}




function setHookCallback(callback){
hookCallback = callback;}


function isArray(input){
return Object.prototype.toString.call(input) === '[object Array]';}


function isDate(input){
return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';}


function map(arr,fn){
var res=[],i;
for(i = 0;i < arr.length;++i) {
res.push(fn(arr[i],i));}

return res;}


function hasOwnProp(a,b){
return Object.prototype.hasOwnProperty.call(a,b);}


function extend(a,b){
for(var i in b) {
if(hasOwnProp(b,i)){
a[i] = b[i];}}



if(hasOwnProp(b,'toString')){
a.toString = b.toString;}


if(hasOwnProp(b,'valueOf')){
a.valueOf = b.valueOf;}


return a;}


function create_utc__createUTC(input,format,locale,strict){
return createLocalOrUTC(input,format,locale,strict,true).utc();}


function defaultParsingFlags(){

return {
empty:false,
unusedTokens:[],
unusedInput:[],
overflow:-2,
charsLeftOver:0,
nullInput:false,
invalidMonth:null,
invalidFormat:false,
userInvalidated:false,
iso:false};}



function getParsingFlags(m){
if(m._pf == null){
m._pf = defaultParsingFlags();}

return m._pf;}


function valid__isValid(m){
if(m._isValid == null){
var flags=getParsingFlags(m);
m._isValid = !isNaN(m._d.getTime()) && 
flags.overflow < 0 && 
!flags.empty && 
!flags.invalidMonth && 
!flags.nullInput && 
!flags.invalidFormat && 
!flags.userInvalidated;

if(m._strict){
m._isValid = m._isValid && 
flags.charsLeftOver === 0 && 
flags.unusedTokens.length === 0 && 
flags.bigHour === undefined;}}


return m._isValid;}


function valid__createInvalid(flags){
var m=create_utc__createUTC(NaN);
if(flags != null){
extend(getParsingFlags(m),flags);}else 

{
getParsingFlags(m).userInvalidated = true;}


return m;}


var momentProperties=utils_hooks__hooks.momentProperties = [];

function copyConfig(to,from){
var i,prop,val;

if(typeof from._isAMomentObject !== 'undefined'){
to._isAMomentObject = from._isAMomentObject;}

if(typeof from._i !== 'undefined'){
to._i = from._i;}

if(typeof from._f !== 'undefined'){
to._f = from._f;}

if(typeof from._l !== 'undefined'){
to._l = from._l;}

if(typeof from._strict !== 'undefined'){
to._strict = from._strict;}

if(typeof from._tzm !== 'undefined'){
to._tzm = from._tzm;}

if(typeof from._isUTC !== 'undefined'){
to._isUTC = from._isUTC;}

if(typeof from._offset !== 'undefined'){
to._offset = from._offset;}

if(typeof from._pf !== 'undefined'){
to._pf = getParsingFlags(from);}

if(typeof from._locale !== 'undefined'){
to._locale = from._locale;}


if(momentProperties.length > 0){
for(i in momentProperties) {
prop = momentProperties[i];
val = from[prop];
if(typeof val !== 'undefined'){
to[prop] = val;}}}




return to;}


var updateInProgress=false;


function Moment(config){
copyConfig(this,config);
this._d = new Date(+config._d);


if(updateInProgress === false){
updateInProgress = true;
utils_hooks__hooks.updateOffset(this);
updateInProgress = false;}}



function isMoment(obj){
return obj instanceof Moment || obj != null && obj._isAMomentObject != null;}


function toInt(argumentForCoercion){
var coercedNumber=+argumentForCoercion,
value=0;

if(coercedNumber !== 0 && isFinite(coercedNumber)){
if(coercedNumber >= 0){
value = Math.floor(coercedNumber);}else 
{
value = Math.ceil(coercedNumber);}}



return value;}


function compareArrays(array1,array2,dontConvert){
var len=Math.min(array1.length,array2.length),
lengthDiff=Math.abs(array1.length - array2.length),
diffs=0,
i;
for(i = 0;i < len;i++) {
if(dontConvert && array1[i] !== array2[i] || 
!dontConvert && toInt(array1[i]) !== toInt(array2[i])){
diffs++;}}


return diffs + lengthDiff;}


function Locale(){}


var locales={};
var globalLocale;

function normalizeLocale(key){
return key?key.toLowerCase().replace('_','-'):key;}





function chooseLocale(names){
var i=0,j,next,locale,split;

while(i < names.length) {
split = normalizeLocale(names[i]).split('-');
j = split.length;
next = normalizeLocale(names[i + 1]);
next = next?next.split('-'):null;
while(j > 0) {
locale = loadLocale(split.slice(0,j).join('-'));
if(locale){
return locale;}

if(next && next.length >= j && compareArrays(split,next,true) >= j - 1){

break;}

j--;}

i++;}

return null;}


function loadLocale(name){
var oldLocale=null;

if(!locales[name] && typeof module !== 'undefined' && 
module && module.exports){
try{
oldLocale = globalLocale._abbr;
require('./locale/' + name);


locale_locales__getSetGlobalLocale(oldLocale);}
catch(e) {}}

return locales[name];}





function locale_locales__getSetGlobalLocale(key,values){
var data;
if(key){
if(typeof values === 'undefined'){
data = locale_locales__getLocale(key);}else 

{
data = defineLocale(key,values);}


if(data){

globalLocale = data;}}



return globalLocale._abbr;}


function defineLocale(name,values){
if(values !== null){
values.abbr = name;
if(!locales[name]){
locales[name] = new Locale();}

locales[name].set(values);


locale_locales__getSetGlobalLocale(name);

return locales[name];}else 
{

delete locales[name];
return null;}}




function locale_locales__getLocale(key){
var locale;

if(key && key._locale && key._locale._abbr){
key = key._locale._abbr;}


if(!key){
return globalLocale;}


if(!isArray(key)){

locale = loadLocale(key);
if(locale){
return locale;}

key = [key];}


return chooseLocale(key);}


var aliases={};

function addUnitAlias(unit,shorthand){
var lowerCase=unit.toLowerCase();
aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;}


function normalizeUnits(units){
return typeof units === 'string'?aliases[units] || aliases[units.toLowerCase()]:undefined;}


function normalizeObjectUnits(inputObject){
var normalizedInput={},
normalizedProp,
prop;

for(prop in inputObject) {
if(hasOwnProp(inputObject,prop)){
normalizedProp = normalizeUnits(prop);
if(normalizedProp){
normalizedInput[normalizedProp] = inputObject[prop];}}}




return normalizedInput;}


function makeGetSet(unit,keepTime){
return function(value){
if(value != null){
get_set__set(this,unit,value);
utils_hooks__hooks.updateOffset(this,keepTime);
return this;}else 
{
return get_set__get(this,unit);}};}




function get_set__get(mom,unit){
return mom._d['get' + (mom._isUTC?'UTC':'') + unit]();}


function get_set__set(mom,unit,value){
return mom._d['set' + (mom._isUTC?'UTC':'') + unit](value);}




function getSet(units,value){
var unit;
if(typeof units === 'object'){
for(unit in units) {
this.set(unit,units[unit]);}}else 

{
units = normalizeUnits(units);
if(typeof this[units] === 'function'){
return this[units](value);}}


return this;}


function zeroFill(number,targetLength,forceSign){
var output='' + Math.abs(number),
sign=number >= 0;

while(output.length < targetLength) {
output = '0' + output;}

return (sign?forceSign?'+':'':'-') + output;}


var formattingTokens=/(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|x|X|zz?|ZZ?|.)/g;

var localFormattingTokens=/(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;

var formatFunctions={};

var formatTokenFunctions={};





function addFormatToken(token,padded,ordinal,callback){
var func=callback;
if(typeof callback === 'string'){
func = function(){
return this[callback]();};}


if(token){
formatTokenFunctions[token] = func;}

if(padded){
formatTokenFunctions[padded[0]] = function(){
return zeroFill(func.apply(this,arguments),padded[1],padded[2]);};}


if(ordinal){
formatTokenFunctions[ordinal] = function(){
return this.localeData().ordinal(func.apply(this,arguments),token);};}}




function removeFormattingTokens(input){
if(input.match(/\[[\s\S]/)){
return input.replace(/^\[|\]$/g,'');}

return input.replace(/\\/g,'');}


function makeFormatFunction(format){
var array=format.match(formattingTokens),i,length;

for(i = 0,length = array.length;i < length;i++) {
if(formatTokenFunctions[array[i]]){
array[i] = formatTokenFunctions[array[i]];}else 
{
array[i] = removeFormattingTokens(array[i]);}}



return function(mom){
var output='';
for(i = 0;i < length;i++) {
output += array[i] instanceof Function?array[i].call(mom,format):array[i];}

return output;};}




function formatMoment(m,format){
if(!m.isValid()){
return m.localeData().invalidDate();}


format = expandFormat(format,m.localeData());

if(!formatFunctions[format]){
formatFunctions[format] = makeFormatFunction(format);}


return formatFunctions[format](m);}


function expandFormat(format,locale){
var i=5;

function replaceLongDateFormatTokens(input){
return locale.longDateFormat(input) || input;}


localFormattingTokens.lastIndex = 0;
while(i >= 0 && localFormattingTokens.test(format)) {
format = format.replace(localFormattingTokens,replaceLongDateFormatTokens);
localFormattingTokens.lastIndex = 0;
i -= 1;}


return format;}


var match1=/\d/;
var match2=/\d\d/;
var match3=/\d{3}/;
var match4=/\d{4}/;
var match6=/[+-]?\d{6}/;
var match1to2=/\d\d?/;
var match1to3=/\d{1,3}/;
var match1to4=/\d{1,4}/;
var match1to6=/[+-]?\d{1,6}/;

var matchUnsigned=/\d+/;
var matchSigned=/[+-]?\d+/;

var matchOffset=/Z|[+-]\d\d:?\d\d/gi;

var matchTimestamp=/[+-]?\d+(\.\d{1,3})?/;


var matchWord=/[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;

var regexes={};

function addRegexToken(token,regex,strictRegex){
regexes[token] = typeof regex === 'function'?regex:function(isStrict){
return isStrict && strictRegex?strictRegex:regex;};}



function getParseRegexForToken(token,config){
if(!hasOwnProp(regexes,token)){
return new RegExp(unescapeFormat(token));}


return regexes[token](config._strict,config._locale);}



function unescapeFormat(s){
return s.replace('\\','').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g,function(matched,p1,p2,p3,p4){
return p1 || p2 || p3 || p4;}).
replace(/[-\/\\^$*+?.()|[\]{}]/g,'\\$&');}


var tokens={};

function addParseToken(token,callback){
var i,func=callback;
if(typeof token === 'string'){
token = [token];}

if(typeof callback === 'number'){
func = function(input,array){
array[callback] = toInt(input);};}


for(i = 0;i < token.length;i++) {
tokens[token[i]] = func;}}



function addWeekParseToken(token,callback){
addParseToken(token,function(input,array,config,token){
config._w = config._w || {};
callback(input,config._w,config,token);});}



function addTimeToArrayFromToken(token,input,config){
if(input != null && hasOwnProp(tokens,token)){
tokens[token](input,config._a,config,token);}}



var YEAR=0;
var MONTH=1;
var DATE=2;
var HOUR=3;
var MINUTE=4;
var SECOND=5;
var MILLISECOND=6;

function daysInMonth(year,month){
return new Date(Date.UTC(year,month + 1,0)).getUTCDate();}




addFormatToken('M',['MM',2],'Mo',function(){
return this.month() + 1;});


addFormatToken('MMM',0,0,function(format){
return this.localeData().monthsShort(this,format);});


addFormatToken('MMMM',0,0,function(format){
return this.localeData().months(this,format);});




addUnitAlias('month','M');



addRegexToken('M',match1to2);
addRegexToken('MM',match1to2,match2);
addRegexToken('MMM',matchWord);
addRegexToken('MMMM',matchWord);

addParseToken(['M','MM'],function(input,array){
array[MONTH] = toInt(input) - 1;});


addParseToken(['MMM','MMMM'],function(input,array,config,token){
var month=config._locale.monthsParse(input,token,config._strict);

if(month != null){
array[MONTH] = month;}else 
{
getParsingFlags(config).invalidMonth = input;}});





var defaultLocaleMonths='January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
function localeMonths(m){
return this._months[m.month()];}


var defaultLocaleMonthsShort='Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
function localeMonthsShort(m){
return this._monthsShort[m.month()];}


function localeMonthsParse(monthName,format,strict){
var i,mom,regex;

if(!this._monthsParse){
this._monthsParse = [];
this._longMonthsParse = [];
this._shortMonthsParse = [];}


for(i = 0;i < 12;i++) {

mom = create_utc__createUTC([2000,i]);
if(strict && !this._longMonthsParse[i]){
this._longMonthsParse[i] = new RegExp('^' + this.months(mom,'').replace('.','') + '$','i');
this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom,'').replace('.','') + '$','i');}

if(!strict && !this._monthsParse[i]){
regex = '^' + this.months(mom,'') + '|^' + this.monthsShort(mom,'');
this._monthsParse[i] = new RegExp(regex.replace('.',''),'i');}


if(strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)){
return i;}else 
if(strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)){
return i;}else 
if(!strict && this._monthsParse[i].test(monthName)){
return i;}}}






function setMonth(mom,value){
var dayOfMonth;


if(typeof value === 'string'){
value = mom.localeData().monthsParse(value);

if(typeof value !== 'number'){
return mom;}}



dayOfMonth = Math.min(mom.date(),daysInMonth(mom.year(),value));
mom._d['set' + (mom._isUTC?'UTC':'') + 'Month'](value,dayOfMonth);
return mom;}


function getSetMonth(value){
if(value != null){
setMonth(this,value);
utils_hooks__hooks.updateOffset(this,true);
return this;}else 
{
return get_set__get(this,'Month');}}



function getDaysInMonth(){
return daysInMonth(this.year(),this.month());}


function checkOverflow(m){
var overflow;
var a=m._a;

if(a && getParsingFlags(m).overflow === -2){
overflow = 
a[MONTH] < 0 || a[MONTH] > 11?MONTH:
a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR],a[MONTH])?DATE:
a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)?HOUR:
a[MINUTE] < 0 || a[MINUTE] > 59?MINUTE:
a[SECOND] < 0 || a[SECOND] > 59?SECOND:
a[MILLISECOND] < 0 || a[MILLISECOND] > 999?MILLISECOND:
-1;

if(getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)){
overflow = DATE;}


getParsingFlags(m).overflow = overflow;}


return m;}


function warn(msg){
if(utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn){
console.warn('Deprecation warning: ' + msg);}}



function deprecate(msg,fn){
var firstTime=true,
msgWithStack=msg + '\n' + new Error().stack;

return extend(function(){
if(firstTime){
warn(msgWithStack);
firstTime = false;}

return fn.apply(this,arguments);},
fn);}


var deprecations={};

function deprecateSimple(name,msg){
if(!deprecations[name]){
warn(msg);
deprecations[name] = true;}}



utils_hooks__hooks.suppressDeprecationWarnings = false;

var from_string__isoRegex=/^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;

var isoDates=[
['YYYYYY-MM-DD',/[+-]\d{6}-\d{2}-\d{2}/],
['YYYY-MM-DD',/\d{4}-\d{2}-\d{2}/],
['GGGG-[W]WW-E',/\d{4}-W\d{2}-\d/],
['GGGG-[W]WW',/\d{4}-W\d{2}/],
['YYYY-DDD',/\d{4}-\d{3}/]];



var isoTimes=[
['HH:mm:ss.SSSS',/(T| )\d\d:\d\d:\d\d\.\d+/],
['HH:mm:ss',/(T| )\d\d:\d\d:\d\d/],
['HH:mm',/(T| )\d\d:\d\d/],
['HH',/(T| )\d\d/]];


var aspNetJsonRegex=/^\/?Date\((\-?\d+)/i;


function configFromISO(config){
var i,l,
string=config._i,
match=from_string__isoRegex.exec(string);

if(match){
getParsingFlags(config).iso = true;
for(i = 0,l = isoDates.length;i < l;i++) {
if(isoDates[i][1].exec(string)){

config._f = isoDates[i][0] + (match[6] || ' ');
break;}}


for(i = 0,l = isoTimes.length;i < l;i++) {
if(isoTimes[i][1].exec(string)){
config._f += isoTimes[i][0];
break;}}


if(string.match(matchOffset)){
config._f += 'Z';}

configFromStringAndFormat(config);}else 
{
config._isValid = false;}}




function configFromString(config){
var matched=aspNetJsonRegex.exec(config._i);

if(matched !== null){
config._d = new Date(+matched[1]);
return;}


configFromISO(config);
if(config._isValid === false){
delete config._isValid;
utils_hooks__hooks.createFromInputFallback(config);}}



utils_hooks__hooks.createFromInputFallback = deprecate(
'moment construction falls back to js Date. This is ' + 
'discouraged and will be removed in upcoming major ' + 
'release. Please refer to ' + 
'https://github.com/moment/moment/issues/1407 for more info.',
function(config){
config._d = new Date(config._i + (config._useUTC?' UTC':''));});



function createDate(y,m,d,h,M,s,ms){


var date=new Date(y,m,d,h,M,s,ms);


if(y < 1970){
date.setFullYear(y);}

return date;}


function createUTCDate(y){
var date=new Date(Date.UTC.apply(null,arguments));
if(y < 1970){
date.setUTCFullYear(y);}

return date;}


addFormatToken(0,['YY',2],0,function(){
return this.year() % 100;});


addFormatToken(0,['YYYY',4],0,'year');
addFormatToken(0,['YYYYY',5],0,'year');
addFormatToken(0,['YYYYYY',6,true],0,'year');



addUnitAlias('year','y');



addRegexToken('Y',matchSigned);
addRegexToken('YY',match1to2,match2);
addRegexToken('YYYY',match1to4,match4);
addRegexToken('YYYYY',match1to6,match6);
addRegexToken('YYYYYY',match1to6,match6);

addParseToken(['YYYY','YYYYY','YYYYYY'],YEAR);
addParseToken('YY',function(input,array){
array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);});




function daysInYear(year){
return isLeapYear(year)?366:365;}


function isLeapYear(year){
return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;}




utils_hooks__hooks.parseTwoDigitYear = function(input){
return toInt(input) + (toInt(input) > 68?1900:2000);};




var getSetYear=makeGetSet('FullYear',false);

function getIsLeapYear(){
return isLeapYear(this.year());}


addFormatToken('w',['ww',2],'wo','week');
addFormatToken('W',['WW',2],'Wo','isoWeek');



addUnitAlias('week','w');
addUnitAlias('isoWeek','W');



addRegexToken('w',match1to2);
addRegexToken('ww',match1to2,match2);
addRegexToken('W',match1to2);
addRegexToken('WW',match1to2,match2);

addWeekParseToken(['w','ww','W','WW'],function(input,week,config,token){
week[token.substr(0,1)] = toInt(input);});











function weekOfYear(mom,firstDayOfWeek,firstDayOfWeekOfYear){
var end=firstDayOfWeekOfYear - firstDayOfWeek,
daysToDayOfWeek=firstDayOfWeekOfYear - mom.day(),
adjustedMoment;


if(daysToDayOfWeek > end){
daysToDayOfWeek -= 7;}


if(daysToDayOfWeek < end - 7){
daysToDayOfWeek += 7;}


adjustedMoment = local__createLocal(mom).add(daysToDayOfWeek,'d');
return {
week:Math.ceil(adjustedMoment.dayOfYear() / 7),
year:adjustedMoment.year()};}





function localeWeek(mom){
return weekOfYear(mom,this._week.dow,this._week.doy).week;}


var defaultLocaleWeek={
dow:0,
doy:6};


function localeFirstDayOfWeek(){
return this._week.dow;}


function localeFirstDayOfYear(){
return this._week.doy;}




function getSetWeek(input){
var week=this.localeData().week(this);
return input == null?week:this.add((input - week) * 7,'d');}


function getSetISOWeek(input){
var week=weekOfYear(this,1,4).week;
return input == null?week:this.add((input - week) * 7,'d');}


addFormatToken('DDD',['DDDD',3],'DDDo','dayOfYear');



addUnitAlias('dayOfYear','DDD');



addRegexToken('DDD',match1to3);
addRegexToken('DDDD',match3);
addParseToken(['DDD','DDDD'],function(input,array,config){
config._dayOfYear = toInt(input);});





function dayOfYearFromWeeks(year,week,weekday,firstDayOfWeekOfYear,firstDayOfWeek){
var d=createUTCDate(year,0,1).getUTCDay();
var daysToAdd;
var dayOfYear;

d = d === 0?7:d;
weekday = weekday != null?weekday:firstDayOfWeek;
daysToAdd = firstDayOfWeek - d + (d > firstDayOfWeekOfYear?7:0) - (d < firstDayOfWeek?7:0);
dayOfYear = 7 * (week - 1) + (weekday - firstDayOfWeek) + daysToAdd + 1;

return {
year:dayOfYear > 0?year:year - 1,
dayOfYear:dayOfYear > 0?dayOfYear:daysInYear(year - 1) + dayOfYear};}





function getSetDayOfYear(input){
var dayOfYear=Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
return input == null?dayOfYear:this.add(input - dayOfYear,'d');}



function defaults(a,b,c){
if(a != null){
return a;}

if(b != null){
return b;}

return c;}


function currentDateArray(config){
var now=new Date();
if(config._useUTC){
return [now.getUTCFullYear(),now.getUTCMonth(),now.getUTCDate()];}

return [now.getFullYear(),now.getMonth(),now.getDate()];}






function configFromArray(config){
var i,date,input=[],currentDate,yearToUse;

if(config._d){
return;}


currentDate = currentDateArray(config);


if(config._w && config._a[DATE] == null && config._a[MONTH] == null){
dayOfYearFromWeekInfo(config);}



if(config._dayOfYear){
yearToUse = defaults(config._a[YEAR],currentDate[YEAR]);

if(config._dayOfYear > daysInYear(yearToUse)){
getParsingFlags(config)._overflowDayOfYear = true;}


date = createUTCDate(yearToUse,0,config._dayOfYear);
config._a[MONTH] = date.getUTCMonth();
config._a[DATE] = date.getUTCDate();}







for(i = 0;i < 3 && config._a[i] == null;++i) {
config._a[i] = input[i] = currentDate[i];}



for(;i < 7;i++) {
config._a[i] = input[i] = config._a[i] == null?i === 2?1:0:config._a[i];}



if(config._a[HOUR] === 24 && 
config._a[MINUTE] === 0 && 
config._a[SECOND] === 0 && 
config._a[MILLISECOND] === 0){
config._nextDay = true;
config._a[HOUR] = 0;}


config._d = (config._useUTC?createUTCDate:createDate).apply(null,input);


if(config._tzm != null){
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);}


if(config._nextDay){
config._a[HOUR] = 24;}}



function dayOfYearFromWeekInfo(config){
var w,weekYear,week,weekday,dow,doy,temp;

w = config._w;
if(w.GG != null || w.W != null || w.E != null){
dow = 1;
doy = 4;





weekYear = defaults(w.GG,config._a[YEAR],weekOfYear(local__createLocal(),1,4).year);
week = defaults(w.W,1);
weekday = defaults(w.E,1);}else 
{
dow = config._locale._week.dow;
doy = config._locale._week.doy;

weekYear = defaults(w.gg,config._a[YEAR],weekOfYear(local__createLocal(),dow,doy).year);
week = defaults(w.w,1);

if(w.d != null){

weekday = w.d;
if(weekday < dow){
++week;}}else 

if(w.e != null){

weekday = w.e + dow;}else 
{

weekday = dow;}}


temp = dayOfYearFromWeeks(weekYear,week,weekday,doy,dow);

config._a[YEAR] = temp.year;
config._dayOfYear = temp.dayOfYear;}


utils_hooks__hooks.ISO_8601 = function(){};


function configFromStringAndFormat(config){

if(config._f === utils_hooks__hooks.ISO_8601){
configFromISO(config);
return;}


config._a = [];
getParsingFlags(config).empty = true;


var string='' + config._i,
i,parsedInput,tokens,token,skipped,
stringLength=string.length,
totalParsedInputLength=0;

tokens = expandFormat(config._f,config._locale).match(formattingTokens) || [];

for(i = 0;i < tokens.length;i++) {
token = tokens[i];
parsedInput = (string.match(getParseRegexForToken(token,config)) || [])[0];
if(parsedInput){
skipped = string.substr(0,string.indexOf(parsedInput));
if(skipped.length > 0){
getParsingFlags(config).unusedInput.push(skipped);}

string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
totalParsedInputLength += parsedInput.length;}


if(formatTokenFunctions[token]){
if(parsedInput){
getParsingFlags(config).empty = false;}else 

{
getParsingFlags(config).unusedTokens.push(token);}

addTimeToArrayFromToken(token,parsedInput,config);}else 

if(config._strict && !parsedInput){
getParsingFlags(config).unusedTokens.push(token);}}




getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
if(string.length > 0){
getParsingFlags(config).unusedInput.push(string);}



if(getParsingFlags(config).bigHour === true && 
config._a[HOUR] <= 12 && 
config._a[HOUR] > 0){
getParsingFlags(config).bigHour = undefined;}


config._a[HOUR] = meridiemFixWrap(config._locale,config._a[HOUR],config._meridiem);

configFromArray(config);
checkOverflow(config);}



function meridiemFixWrap(locale,hour,meridiem){
var isPm;

if(meridiem == null){

return hour;}

if(locale.meridiemHour != null){
return locale.meridiemHour(hour,meridiem);}else 
if(locale.isPM != null){

isPm = locale.isPM(meridiem);
if(isPm && hour < 12){
hour += 12;}

if(!isPm && hour === 12){
hour = 0;}

return hour;}else 
{

return hour;}}



function configFromStringAndArray(config){
var tempConfig,
bestMoment,

scoreToBeat,
i,
currentScore;

if(config._f.length === 0){
getParsingFlags(config).invalidFormat = true;
config._d = new Date(NaN);
return;}


for(i = 0;i < config._f.length;i++) {
currentScore = 0;
tempConfig = copyConfig({},config);
if(config._useUTC != null){
tempConfig._useUTC = config._useUTC;}

tempConfig._f = config._f[i];
configFromStringAndFormat(tempConfig);

if(!valid__isValid(tempConfig)){
continue;}



currentScore += getParsingFlags(tempConfig).charsLeftOver;


currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;

getParsingFlags(tempConfig).score = currentScore;

if(scoreToBeat == null || currentScore < scoreToBeat){
scoreToBeat = currentScore;
bestMoment = tempConfig;}}



extend(config,bestMoment || tempConfig);}


function configFromObject(config){
if(config._d){
return;}


var i=normalizeObjectUnits(config._i);
config._a = [i.year,i.month,i.day || i.date,i.hour,i.minute,i.second,i.millisecond];

configFromArray(config);}


function createFromConfig(config){
var input=config._i,
format=config._f,
res;

config._locale = config._locale || locale_locales__getLocale(config._l);

if(input === null || format === undefined && input === ''){
return valid__createInvalid({nullInput:true});}


if(typeof input === 'string'){
config._i = input = config._locale.preparse(input);}


if(isMoment(input)){
return new Moment(checkOverflow(input));}else 
if(isArray(format)){
configFromStringAndArray(config);}else 
if(format){
configFromStringAndFormat(config);}else 
if(isDate(input)){
config._d = input;}else 
{
configFromInput(config);}


res = new Moment(checkOverflow(config));
if(res._nextDay){

res.add(1,'d');
res._nextDay = undefined;}


return res;}


function configFromInput(config){
var input=config._i;
if(input === undefined){
config._d = new Date();}else 
if(isDate(input)){
config._d = new Date(+input);}else 
if(typeof input === 'string'){
configFromString(config);}else 
if(isArray(input)){
config._a = map(input.slice(0),function(obj){
return parseInt(obj,10);});

configFromArray(config);}else 
if(typeof input === 'object'){
configFromObject(config);}else 
if(typeof input === 'number'){

config._d = new Date(input);}else 
{
utils_hooks__hooks.createFromInputFallback(config);}}



function createLocalOrUTC(input,format,locale,strict,isUTC){
var c={};

if(typeof locale === 'boolean'){
strict = locale;
locale = undefined;}



c._isAMomentObject = true;
c._useUTC = c._isUTC = isUTC;
c._l = locale;
c._i = input;
c._f = format;
c._strict = strict;

return createFromConfig(c);}


function local__createLocal(input,format,locale,strict){
return createLocalOrUTC(input,format,locale,strict,false);}


var prototypeMin=deprecate(
'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
function(){
var other=local__createLocal.apply(null,arguments);
return other < this?this:other;});



var prototypeMax=deprecate(
'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
function(){
var other=local__createLocal.apply(null,arguments);
return other > this?this:other;});








function pickBy(fn,moments){
var res,i;
if(moments.length === 1 && isArray(moments[0])){
moments = moments[0];}

if(!moments.length){
return local__createLocal();}

res = moments[0];
for(i = 1;i < moments.length;++i) {
if(moments[i][fn](res)){
res = moments[i];}}


return res;}



function min(){
var args=[].slice.call(arguments,0);

return pickBy('isBefore',args);}


function max(){
var args=[].slice.call(arguments,0);

return pickBy('isAfter',args);}


function Duration(duration){
var normalizedInput=normalizeObjectUnits(duration),
years=normalizedInput.year || 0,
quarters=normalizedInput.quarter || 0,
months=normalizedInput.month || 0,
weeks=normalizedInput.week || 0,
days=normalizedInput.day || 0,
hours=normalizedInput.hour || 0,
minutes=normalizedInput.minute || 0,
seconds=normalizedInput.second || 0,
milliseconds=normalizedInput.millisecond || 0;


this._milliseconds = +milliseconds + 
seconds * 1e3 + 
minutes * 6e4 + 
hours * 36e5;


this._days = +days + 
weeks * 7;



this._months = +months + 
quarters * 3 + 
years * 12;

this._data = {};

this._locale = locale_locales__getLocale();

this._bubble();}


function isDuration(obj){
return obj instanceof Duration;}


function offset(token,separator){
addFormatToken(token,0,0,function(){
var offset=this.utcOffset();
var sign='+';
if(offset < 0){
offset = -offset;
sign = '-';}

return sign + zeroFill(~ ~(offset / 60),2) + separator + zeroFill(~ ~offset % 60,2);});}



offset('Z',':');
offset('ZZ','');



addRegexToken('Z',matchOffset);
addRegexToken('ZZ',matchOffset);
addParseToken(['Z','ZZ'],function(input,array,config){
config._useUTC = true;
config._tzm = offsetFromString(input);});







var chunkOffset=/([\+\-]|\d\d)/gi;

function offsetFromString(string){
var matches=(string || '').match(matchOffset) || [];
var chunk=matches[matches.length - 1] || [];
var parts=(chunk + '').match(chunkOffset) || ['-',0,0];
var minutes=+(parts[1] * 60) + toInt(parts[2]);

return parts[0] === '+'?minutes:-minutes;}



function cloneWithOffset(input,model){
var res,diff;
if(model._isUTC){
res = model.clone();
diff = (isMoment(input) || isDate(input)?+input:+local__createLocal(input)) - +res;

res._d.setTime(+res._d + diff);
utils_hooks__hooks.updateOffset(res,false);
return res;}else 
{
return local__createLocal(input).local();}

return model._isUTC?local__createLocal(input).zone(model._offset || 0):local__createLocal(input).local();}


function getDateOffset(m){


return -Math.round(m._d.getTimezoneOffset() / 15) * 15;}






utils_hooks__hooks.updateOffset = function(){};













function getSetOffset(input,keepLocalTime){
var offset=this._offset || 0,
localAdjust;
if(input != null){
if(typeof input === 'string'){
input = offsetFromString(input);}

if(Math.abs(input) < 16){
input = input * 60;}

if(!this._isUTC && keepLocalTime){
localAdjust = getDateOffset(this);}

this._offset = input;
this._isUTC = true;
if(localAdjust != null){
this.add(localAdjust,'m');}

if(offset !== input){
if(!keepLocalTime || this._changeInProgress){
add_subtract__addSubtract(this,create__createDuration(input - offset,'m'),1,false);}else 
if(!this._changeInProgress){
this._changeInProgress = true;
utils_hooks__hooks.updateOffset(this,true);
this._changeInProgress = null;}}


return this;}else 
{
return this._isUTC?offset:getDateOffset(this);}}



function getSetZone(input,keepLocalTime){
if(input != null){
if(typeof input !== 'string'){
input = -input;}


this.utcOffset(input,keepLocalTime);

return this;}else 
{
return -this.utcOffset();}}



function setOffsetToUTC(keepLocalTime){
return this.utcOffset(0,keepLocalTime);}


function setOffsetToLocal(keepLocalTime){
if(this._isUTC){
this.utcOffset(0,keepLocalTime);
this._isUTC = false;

if(keepLocalTime){
this.subtract(getDateOffset(this),'m');}}


return this;}


function setOffsetToParsedOffset(){
if(this._tzm){
this.utcOffset(this._tzm);}else 
if(typeof this._i === 'string'){
this.utcOffset(offsetFromString(this._i));}

return this;}


function hasAlignedHourOffset(input){
if(!input){
input = 0;}else 

{
input = local__createLocal(input).utcOffset();}


return (this.utcOffset() - input) % 60 === 0;}


function isDaylightSavingTime(){
return (
this.utcOffset() > this.clone().month(0).utcOffset() || 
this.utcOffset() > this.clone().month(5).utcOffset());}



function isDaylightSavingTimeShifted(){
if(this._a){
var other=this._isUTC?create_utc__createUTC(this._a):local__createLocal(this._a);
return this.isValid() && compareArrays(this._a,other.toArray()) > 0;}


return false;}


function isLocal(){
return !this._isUTC;}


function isUtcOffset(){
return this._isUTC;}


function isUtc(){
return this._isUTC && this._offset === 0;}


var aspNetRegex=/(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;



var create__isoRegex=/^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;

function create__createDuration(input,key){
var duration=input,

match=null,
sign,
ret,
diffRes;

if(isDuration(input)){
duration = {
ms:input._milliseconds,
d:input._days,
M:input._months};}else 

if(typeof input === 'number'){
duration = {};
if(key){
duration[key] = input;}else 
{
duration.milliseconds = input;}}else 

if(!!(match = aspNetRegex.exec(input))){
sign = match[1] === '-'?-1:1;
duration = {
y:0,
d:toInt(match[DATE]) * sign,
h:toInt(match[HOUR]) * sign,
m:toInt(match[MINUTE]) * sign,
s:toInt(match[SECOND]) * sign,
ms:toInt(match[MILLISECOND]) * sign};}else 

if(!!(match = create__isoRegex.exec(input))){
sign = match[1] === '-'?-1:1;
duration = {
y:parseIso(match[2],sign),
M:parseIso(match[3],sign),
d:parseIso(match[4],sign),
h:parseIso(match[5],sign),
m:parseIso(match[6],sign),
s:parseIso(match[7],sign),
w:parseIso(match[8],sign)};}else 

if(duration == null){
duration = {};}else 
if(typeof duration === 'object' && ('from' in duration || 'to' in duration)){
diffRes = momentsDifference(local__createLocal(duration.from),local__createLocal(duration.to));

duration = {};
duration.ms = diffRes.milliseconds;
duration.M = diffRes.months;}


ret = new Duration(duration);

if(isDuration(input) && hasOwnProp(input,'_locale')){
ret._locale = input._locale;}


return ret;}


create__createDuration.fn = Duration.prototype;

function parseIso(inp,sign){



var res=inp && parseFloat(inp.replace(',','.'));

return (isNaN(res)?0:res) * sign;}


function positiveMomentsDifference(base,other){
var res={milliseconds:0,months:0};

res.months = other.month() - base.month() + 
(other.year() - base.year()) * 12;
if(base.clone().add(res.months,'M').isAfter(other)){
--res.months;}


res.milliseconds = +other - +base.clone().add(res.months,'M');

return res;}


function momentsDifference(base,other){
var res;
other = cloneWithOffset(other,base);
if(base.isBefore(other)){
res = positiveMomentsDifference(base,other);}else 
{
res = positiveMomentsDifference(other,base);
res.milliseconds = -res.milliseconds;
res.months = -res.months;}


return res;}


function createAdder(direction,name){
return function(val,period){
var dur,tmp;

if(period !== null && !isNaN(+period)){
deprecateSimple(name,'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
tmp = val;val = period;period = tmp;}


val = typeof val === 'string'?+val:val;
dur = create__createDuration(val,period);
add_subtract__addSubtract(this,dur,direction);
return this;};}



function add_subtract__addSubtract(mom,duration,isAdding,updateOffset){
var milliseconds=duration._milliseconds,
days=duration._days,
months=duration._months;
updateOffset = updateOffset == null?true:updateOffset;

if(milliseconds){
mom._d.setTime(+mom._d + milliseconds * isAdding);}

if(days){
get_set__set(mom,'Date',get_set__get(mom,'Date') + days * isAdding);}

if(months){
setMonth(mom,get_set__get(mom,'Month') + months * isAdding);}

if(updateOffset){
utils_hooks__hooks.updateOffset(mom,days || months);}}



var add_subtract__add=createAdder(1,'add');
var add_subtract__subtract=createAdder(-1,'subtract');

function moment_calendar__calendar(time){


var now=time || local__createLocal(),
sod=cloneWithOffset(now,this).startOf('day'),
diff=this.diff(sod,'days',true),
format=diff < -6?'sameElse':
diff < -1?'lastWeek':
diff < 0?'lastDay':
diff < 1?'sameDay':
diff < 2?'nextDay':
diff < 7?'nextWeek':'sameElse';
return this.format(this.localeData().calendar(format,this,local__createLocal(now)));}


function clone(){
return new Moment(this);}


function isAfter(input,units){
var inputMs;
units = normalizeUnits(typeof units !== 'undefined'?units:'millisecond');
if(units === 'millisecond'){
input = isMoment(input)?input:local__createLocal(input);
return +this > +input;}else 
{
inputMs = isMoment(input)?+input:+local__createLocal(input);
return inputMs < +this.clone().startOf(units);}}



function isBefore(input,units){
var inputMs;
units = normalizeUnits(typeof units !== 'undefined'?units:'millisecond');
if(units === 'millisecond'){
input = isMoment(input)?input:local__createLocal(input);
return +this < +input;}else 
{
inputMs = isMoment(input)?+input:+local__createLocal(input);
return +this.clone().endOf(units) < inputMs;}}



function isBetween(from,to,units){
return this.isAfter(from,units) && this.isBefore(to,units);}


function isSame(input,units){
var inputMs;
units = normalizeUnits(units || 'millisecond');
if(units === 'millisecond'){
input = isMoment(input)?input:local__createLocal(input);
return +this === +input;}else 
{
inputMs = +local__createLocal(input);
return +this.clone().startOf(units) <= inputMs && inputMs <= +this.clone().endOf(units);}}



function absFloor(number){
if(number < 0){
return Math.ceil(number);}else 
{
return Math.floor(number);}}



function diff(input,units,asFloat){
var that=cloneWithOffset(input,this),
zoneDelta=(that.utcOffset() - this.utcOffset()) * 6e4,
delta,output;

units = normalizeUnits(units);

if(units === 'year' || units === 'month' || units === 'quarter'){
output = monthDiff(this,that);
if(units === 'quarter'){
output = output / 3;}else 
if(units === 'year'){
output = output / 12;}}else 

{
delta = this - that;
output = units === 'second'?delta / 1e3:
units === 'minute'?delta / 6e4:
units === 'hour'?delta / 36e5:
units === 'day'?(delta - zoneDelta) / 864e5:
units === 'week'?(delta - zoneDelta) / 6048e5:
delta;}

return asFloat?output:absFloor(output);}


function monthDiff(a,b){

var wholeMonthDiff=(b.year() - a.year()) * 12 + (b.month() - a.month()),

anchor=a.clone().add(wholeMonthDiff,'months'),
anchor2,adjust;

if(b - anchor < 0){
anchor2 = a.clone().add(wholeMonthDiff - 1,'months');

adjust = (b - anchor) / (anchor - anchor2);}else 
{
anchor2 = a.clone().add(wholeMonthDiff + 1,'months');

adjust = (b - anchor) / (anchor2 - anchor);}


return -(wholeMonthDiff + adjust);}


utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';

function toString(){
return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');}


function moment_format__toISOString(){
var m=this.clone().utc();
if(0 < m.year() && m.year() <= 9999){
if('function' === typeof Date.prototype.toISOString){

return this.toDate().toISOString();}else 
{
return formatMoment(m,'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');}}else 

{
return formatMoment(m,'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');}}



function format(inputString){
var output=formatMoment(this,inputString || utils_hooks__hooks.defaultFormat);
return this.localeData().postformat(output);}


function from(time,withoutSuffix){
if(!this.isValid()){
return this.localeData().invalidDate();}

return create__createDuration({to:this,from:time}).locale(this.locale()).humanize(!withoutSuffix);}


function fromNow(withoutSuffix){
return this.from(local__createLocal(),withoutSuffix);}


function to(time,withoutSuffix){
if(!this.isValid()){
return this.localeData().invalidDate();}

return create__createDuration({from:this,to:time}).locale(this.locale()).humanize(!withoutSuffix);}


function toNow(withoutSuffix){
return this.to(local__createLocal(),withoutSuffix);}


function locale(key){
var newLocaleData;

if(key === undefined){
return this._locale._abbr;}else 
{
newLocaleData = locale_locales__getLocale(key);
if(newLocaleData != null){
this._locale = newLocaleData;}

return this;}}



var lang=deprecate(
'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
function(key){
if(key === undefined){
return this.localeData();}else 
{
return this.locale(key);}});




function localeData(){
return this._locale;}


function startOf(units){
units = normalizeUnits(units);


switch(units){
case 'year':
this.month(0);

case 'quarter':
case 'month':
this.date(1);

case 'week':
case 'isoWeek':
case 'day':
this.hours(0);

case 'hour':
this.minutes(0);

case 'minute':
this.seconds(0);

case 'second':
this.milliseconds(0);}



if(units === 'week'){
this.weekday(0);}

if(units === 'isoWeek'){
this.isoWeekday(1);}



if(units === 'quarter'){
this.month(Math.floor(this.month() / 3) * 3);}


return this;}


function endOf(units){
units = normalizeUnits(units);
if(units === undefined || units === 'millisecond'){
return this;}

return this.startOf(units).add(1,units === 'isoWeek'?'week':units).subtract(1,'ms');}


function to_type__valueOf(){
return +this._d - (this._offset || 0) * 60000;}


function unix(){
return Math.floor(+this / 1000);}


function toDate(){
return this._offset?new Date(+this):this._d;}


function toArray(){
var m=this;
return [m.year(),m.month(),m.date(),m.hour(),m.minute(),m.second(),m.millisecond()];}


function moment_valid__isValid(){
return valid__isValid(this);}


function parsingFlags(){
return extend({},getParsingFlags(this));}


function invalidAt(){
return getParsingFlags(this).overflow;}


addFormatToken(0,['gg',2],0,function(){
return this.weekYear() % 100;});


addFormatToken(0,['GG',2],0,function(){
return this.isoWeekYear() % 100;});


function addWeekYearFormatToken(token,getter){
addFormatToken(0,[token,token.length],0,getter);}


addWeekYearFormatToken('gggg','weekYear');
addWeekYearFormatToken('ggggg','weekYear');
addWeekYearFormatToken('GGGG','isoWeekYear');
addWeekYearFormatToken('GGGGG','isoWeekYear');



addUnitAlias('weekYear','gg');
addUnitAlias('isoWeekYear','GG');



addRegexToken('G',matchSigned);
addRegexToken('g',matchSigned);
addRegexToken('GG',match1to2,match2);
addRegexToken('gg',match1to2,match2);
addRegexToken('GGGG',match1to4,match4);
addRegexToken('gggg',match1to4,match4);
addRegexToken('GGGGG',match1to6,match6);
addRegexToken('ggggg',match1to6,match6);

addWeekParseToken(['gggg','ggggg','GGGG','GGGGG'],function(input,week,config,token){
week[token.substr(0,2)] = toInt(input);});


addWeekParseToken(['gg','GG'],function(input,week,config,token){
week[token] = utils_hooks__hooks.parseTwoDigitYear(input);});




function weeksInYear(year,dow,doy){
return weekOfYear(local__createLocal([year,11,31 + dow - doy]),dow,doy).week;}




function getSetWeekYear(input){
var year=weekOfYear(this,this.localeData()._week.dow,this.localeData()._week.doy).year;
return input == null?year:this.add(input - year,'y');}


function getSetISOWeekYear(input){
var year=weekOfYear(this,1,4).year;
return input == null?year:this.add(input - year,'y');}


function getISOWeeksInYear(){
return weeksInYear(this.year(),1,4);}


function getWeeksInYear(){
var weekInfo=this.localeData()._week;
return weeksInYear(this.year(),weekInfo.dow,weekInfo.doy);}


addFormatToken('Q',0,0,'quarter');



addUnitAlias('quarter','Q');



addRegexToken('Q',match1);
addParseToken('Q',function(input,array){
array[MONTH] = (toInt(input) - 1) * 3;});




function getSetQuarter(input){
return input == null?Math.ceil((this.month() + 1) / 3):this.month((input - 1) * 3 + this.month() % 3);}


addFormatToken('D',['DD',2],'Do','date');



addUnitAlias('date','D');



addRegexToken('D',match1to2);
addRegexToken('DD',match1to2,match2);
addRegexToken('Do',function(isStrict,locale){
return isStrict?locale._ordinalParse:locale._ordinalParseLenient;});


addParseToken(['D','DD'],DATE);
addParseToken('Do',function(input,array){
array[DATE] = toInt(input.match(match1to2)[0],10);});




var getSetDayOfMonth=makeGetSet('Date',true);

addFormatToken('d',0,'do','day');

addFormatToken('dd',0,0,function(format){
return this.localeData().weekdaysMin(this,format);});


addFormatToken('ddd',0,0,function(format){
return this.localeData().weekdaysShort(this,format);});


addFormatToken('dddd',0,0,function(format){
return this.localeData().weekdays(this,format);});


addFormatToken('e',0,0,'weekday');
addFormatToken('E',0,0,'isoWeekday');



addUnitAlias('day','d');
addUnitAlias('weekday','e');
addUnitAlias('isoWeekday','E');



addRegexToken('d',match1to2);
addRegexToken('e',match1to2);
addRegexToken('E',match1to2);
addRegexToken('dd',matchWord);
addRegexToken('ddd',matchWord);
addRegexToken('dddd',matchWord);

addWeekParseToken(['dd','ddd','dddd'],function(input,week,config){
var weekday=config._locale.weekdaysParse(input);

if(weekday != null){
week.d = weekday;}else 
{
getParsingFlags(config).invalidWeekday = input;}});



addWeekParseToken(['d','e','E'],function(input,week,config,token){
week[token] = toInt(input);});




function parseWeekday(input,locale){
if(typeof input === 'string'){
if(!isNaN(input)){
input = parseInt(input,10);}else 

{
input = locale.weekdaysParse(input);
if(typeof input !== 'number'){
return null;}}}



return input;}




var defaultLocaleWeekdays='Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
function localeWeekdays(m){
return this._weekdays[m.day()];}


var defaultLocaleWeekdaysShort='Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
function localeWeekdaysShort(m){
return this._weekdaysShort[m.day()];}


var defaultLocaleWeekdaysMin='Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
function localeWeekdaysMin(m){
return this._weekdaysMin[m.day()];}


function localeWeekdaysParse(weekdayName){
var i,mom,regex;

if(!this._weekdaysParse){
this._weekdaysParse = [];}


for(i = 0;i < 7;i++) {

if(!this._weekdaysParse[i]){
mom = local__createLocal([2000,1]).day(i);
regex = '^' + this.weekdays(mom,'') + '|^' + this.weekdaysShort(mom,'') + '|^' + this.weekdaysMin(mom,'');
this._weekdaysParse[i] = new RegExp(regex.replace('.',''),'i');}


if(this._weekdaysParse[i].test(weekdayName)){
return i;}}}






function getSetDayOfWeek(input){
var day=this._isUTC?this._d.getUTCDay():this._d.getDay();
if(input != null){
input = parseWeekday(input,this.localeData());
return this.add(input - day,'d');}else 
{
return day;}}



function getSetLocaleDayOfWeek(input){
var weekday=(this.day() + 7 - this.localeData()._week.dow) % 7;
return input == null?weekday:this.add(input - weekday,'d');}


function getSetISODayOfWeek(input){



return input == null?this.day() || 7:this.day(this.day() % 7?input:input - 7);}


addFormatToken('H',['HH',2],0,'hour');
addFormatToken('h',['hh',2],0,function(){
return this.hours() % 12 || 12;});


function meridiem(token,lowercase){
addFormatToken(token,0,0,function(){
return this.localeData().meridiem(this.hours(),this.minutes(),lowercase);});}



meridiem('a',true);
meridiem('A',false);



addUnitAlias('hour','h');



function matchMeridiem(isStrict,locale){
return locale._meridiemParse;}


addRegexToken('a',matchMeridiem);
addRegexToken('A',matchMeridiem);
addRegexToken('H',match1to2);
addRegexToken('h',match1to2);
addRegexToken('HH',match1to2,match2);
addRegexToken('hh',match1to2,match2);

addParseToken(['H','HH'],HOUR);
addParseToken(['a','A'],function(input,array,config){
config._isPm = config._locale.isPM(input);
config._meridiem = input;});

addParseToken(['h','hh'],function(input,array,config){
array[HOUR] = toInt(input);
getParsingFlags(config).bigHour = true;});




function localeIsPM(input){


return (input + '').toLowerCase().charAt(0) === 'p';}


var defaultLocaleMeridiemParse=/[ap]\.?m?\.?/i;
function localeMeridiem(hours,minutes,isLower){
if(hours > 11){
return isLower?'pm':'PM';}else 
{
return isLower?'am':'AM';}}










var getSetHour=makeGetSet('Hours',true);

addFormatToken('m',['mm',2],0,'minute');



addUnitAlias('minute','m');



addRegexToken('m',match1to2);
addRegexToken('mm',match1to2,match2);
addParseToken(['m','mm'],MINUTE);



var getSetMinute=makeGetSet('Minutes',false);

addFormatToken('s',['ss',2],0,'second');



addUnitAlias('second','s');



addRegexToken('s',match1to2);
addRegexToken('ss',match1to2,match2);
addParseToken(['s','ss'],SECOND);



var getSetSecond=makeGetSet('Seconds',false);

addFormatToken('S',0,0,function(){
return ~ ~(this.millisecond() / 100);});


addFormatToken(0,['SS',2],0,function(){
return ~ ~(this.millisecond() / 10);});


function millisecond__milliseconds(token){
addFormatToken(0,[token,3],0,'millisecond');}


millisecond__milliseconds('SSS');
millisecond__milliseconds('SSSS');



addUnitAlias('millisecond','ms');



addRegexToken('S',match1to3,match1);
addRegexToken('SS',match1to3,match2);
addRegexToken('SSS',match1to3,match3);
addRegexToken('SSSS',matchUnsigned);
addParseToken(['S','SS','SSS','SSSS'],function(input,array){
array[MILLISECOND] = toInt(('0.' + input) * 1000);});




var getSetMillisecond=makeGetSet('Milliseconds',false);

addFormatToken('z',0,0,'zoneAbbr');
addFormatToken('zz',0,0,'zoneName');



function getZoneAbbr(){
return this._isUTC?'UTC':'';}


function getZoneName(){
return this._isUTC?'Coordinated Universal Time':'';}


var momentPrototype__proto=Moment.prototype;

momentPrototype__proto.add = add_subtract__add;
momentPrototype__proto.calendar = moment_calendar__calendar;
momentPrototype__proto.clone = clone;
momentPrototype__proto.diff = diff;
momentPrototype__proto.endOf = endOf;
momentPrototype__proto.format = format;
momentPrototype__proto.from = from;
momentPrototype__proto.fromNow = fromNow;
momentPrototype__proto.to = to;
momentPrototype__proto.toNow = toNow;
momentPrototype__proto.get = getSet;
momentPrototype__proto.invalidAt = invalidAt;
momentPrototype__proto.isAfter = isAfter;
momentPrototype__proto.isBefore = isBefore;
momentPrototype__proto.isBetween = isBetween;
momentPrototype__proto.isSame = isSame;
momentPrototype__proto.isValid = moment_valid__isValid;
momentPrototype__proto.lang = lang;
momentPrototype__proto.locale = locale;
momentPrototype__proto.localeData = localeData;
momentPrototype__proto.max = prototypeMax;
momentPrototype__proto.min = prototypeMin;
momentPrototype__proto.parsingFlags = parsingFlags;
momentPrototype__proto.set = getSet;
momentPrototype__proto.startOf = startOf;
momentPrototype__proto.subtract = add_subtract__subtract;
momentPrototype__proto.toArray = toArray;
momentPrototype__proto.toDate = toDate;
momentPrototype__proto.toISOString = moment_format__toISOString;
momentPrototype__proto.toJSON = moment_format__toISOString;
momentPrototype__proto.toString = toString;
momentPrototype__proto.unix = unix;
momentPrototype__proto.valueOf = to_type__valueOf;


momentPrototype__proto.year = getSetYear;
momentPrototype__proto.isLeapYear = getIsLeapYear;


momentPrototype__proto.weekYear = getSetWeekYear;
momentPrototype__proto.isoWeekYear = getSetISOWeekYear;


momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;


momentPrototype__proto.month = getSetMonth;
momentPrototype__proto.daysInMonth = getDaysInMonth;


momentPrototype__proto.week = momentPrototype__proto.weeks = getSetWeek;
momentPrototype__proto.isoWeek = momentPrototype__proto.isoWeeks = getSetISOWeek;
momentPrototype__proto.weeksInYear = getWeeksInYear;
momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;


momentPrototype__proto.date = getSetDayOfMonth;
momentPrototype__proto.day = momentPrototype__proto.days = getSetDayOfWeek;
momentPrototype__proto.weekday = getSetLocaleDayOfWeek;
momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
momentPrototype__proto.dayOfYear = getSetDayOfYear;


momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;


momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;


momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;


momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;


momentPrototype__proto.utcOffset = getSetOffset;
momentPrototype__proto.utc = setOffsetToUTC;
momentPrototype__proto.local = setOffsetToLocal;
momentPrototype__proto.parseZone = setOffsetToParsedOffset;
momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
momentPrototype__proto.isDST = isDaylightSavingTime;
momentPrototype__proto.isDSTShifted = isDaylightSavingTimeShifted;
momentPrototype__proto.isLocal = isLocal;
momentPrototype__proto.isUtcOffset = isUtcOffset;
momentPrototype__proto.isUtc = isUtc;
momentPrototype__proto.isUTC = isUtc;


momentPrototype__proto.zoneAbbr = getZoneAbbr;
momentPrototype__proto.zoneName = getZoneName;


momentPrototype__proto.dates = deprecate('dates accessor is deprecated. Use date instead.',getSetDayOfMonth);
momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead',getSetMonth);
momentPrototype__proto.years = deprecate('years accessor is deprecated. Use year instead',getSetYear);
momentPrototype__proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779',getSetZone);

var momentPrototype=momentPrototype__proto;

function moment__createUnix(input){
return local__createLocal(input * 1000);}


function moment__createInZone(){
return local__createLocal.apply(null,arguments).parseZone();}


var defaultCalendar={
sameDay:'[Today at] LT',
nextDay:'[Tomorrow at] LT',
nextWeek:'dddd [at] LT',
lastDay:'[Yesterday at] LT',
lastWeek:'[Last] dddd [at] LT',
sameElse:'L'};


function locale_calendar__calendar(key,mom,now){
var output=this._calendar[key];
return typeof output === 'function'?output.call(mom,now):output;}


var defaultLongDateFormat={
LTS:'h:mm:ss A',
LT:'h:mm A',
L:'MM/DD/YYYY',
LL:'MMMM D, YYYY',
LLL:'MMMM D, YYYY LT',
LLLL:'dddd, MMMM D, YYYY LT'};


function longDateFormat(key){
var output=this._longDateFormat[key];
if(!output && this._longDateFormat[key.toUpperCase()]){
output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g,function(val){
return val.slice(1);});

this._longDateFormat[key] = output;}

return output;}


var defaultInvalidDate='Invalid date';

function invalidDate(){
return this._invalidDate;}


var defaultOrdinal='%d';
var defaultOrdinalParse=/\d{1,2}/;

function ordinal(number){
return this._ordinal.replace('%d',number);}


function preParsePostFormat(string){
return string;}


var defaultRelativeTime={
future:'in %s',
past:'%s ago',
s:'a few seconds',
m:'a minute',
mm:'%d minutes',
h:'an hour',
hh:'%d hours',
d:'a day',
dd:'%d days',
M:'a month',
MM:'%d months',
y:'a year',
yy:'%d years'};


function relative__relativeTime(number,withoutSuffix,string,isFuture){
var output=this._relativeTime[string];
return typeof output === 'function'?
output(number,withoutSuffix,string,isFuture):
output.replace(/%d/i,number);}


function pastFuture(diff,output){
var format=this._relativeTime[diff > 0?'future':'past'];
return typeof format === 'function'?format(output):format.replace(/%s/i,output);}


function locale_set__set(config){
var prop,i;
for(i in config) {
prop = config[i];
if(typeof prop === 'function'){
this[i] = prop;}else 
{
this['_' + i] = prop;}}




this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + /\d{1,2}/.source);}


var prototype__proto=Locale.prototype;

prototype__proto._calendar = defaultCalendar;
prototype__proto.calendar = locale_calendar__calendar;
prototype__proto._longDateFormat = defaultLongDateFormat;
prototype__proto.longDateFormat = longDateFormat;
prototype__proto._invalidDate = defaultInvalidDate;
prototype__proto.invalidDate = invalidDate;
prototype__proto._ordinal = defaultOrdinal;
prototype__proto.ordinal = ordinal;
prototype__proto._ordinalParse = defaultOrdinalParse;
prototype__proto.preparse = preParsePostFormat;
prototype__proto.postformat = preParsePostFormat;
prototype__proto._relativeTime = defaultRelativeTime;
prototype__proto.relativeTime = relative__relativeTime;
prototype__proto.pastFuture = pastFuture;
prototype__proto.set = locale_set__set;


prototype__proto.months = localeMonths;
prototype__proto._months = defaultLocaleMonths;
prototype__proto.monthsShort = localeMonthsShort;
prototype__proto._monthsShort = defaultLocaleMonthsShort;
prototype__proto.monthsParse = localeMonthsParse;


prototype__proto.week = localeWeek;
prototype__proto._week = defaultLocaleWeek;
prototype__proto.firstDayOfYear = localeFirstDayOfYear;
prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;


prototype__proto.weekdays = localeWeekdays;
prototype__proto._weekdays = defaultLocaleWeekdays;
prototype__proto.weekdaysMin = localeWeekdaysMin;
prototype__proto._weekdaysMin = defaultLocaleWeekdaysMin;
prototype__proto.weekdaysShort = localeWeekdaysShort;
prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
prototype__proto.weekdaysParse = localeWeekdaysParse;


prototype__proto.isPM = localeIsPM;
prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
prototype__proto.meridiem = localeMeridiem;

function lists__get(format,index,field,setter){
var locale=locale_locales__getLocale();
var utc=create_utc__createUTC().set(setter,index);
return locale[field](utc,format);}


function list(format,index,field,count,setter){
if(typeof format === 'number'){
index = format;
format = undefined;}


format = format || '';

if(index != null){
return lists__get(format,index,field,setter);}


var i;
var out=[];
for(i = 0;i < count;i++) {
out[i] = lists__get(format,i,field,setter);}

return out;}


function lists__listMonths(format,index){
return list(format,index,'months',12,'month');}


function lists__listMonthsShort(format,index){
return list(format,index,'monthsShort',12,'month');}


function lists__listWeekdays(format,index){
return list(format,index,'weekdays',7,'day');}


function lists__listWeekdaysShort(format,index){
return list(format,index,'weekdaysShort',7,'day');}


function lists__listWeekdaysMin(format,index){
return list(format,index,'weekdaysMin',7,'day');}


locale_locales__getSetGlobalLocale('en',{
ordinalParse:/\d{1,2}(th|st|nd|rd)/,
ordinal:function(number){
var b=number % 10,
output=toInt(number % 100 / 10) === 1?'th':
b === 1?'st':
b === 2?'nd':
b === 3?'rd':'th';
return number + output;}});




utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.',locale_locales__getSetGlobalLocale);
utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.',locale_locales__getLocale);

var mathAbs=Math.abs;

function duration_abs__abs(){
var data=this._data;

this._milliseconds = mathAbs(this._milliseconds);
this._days = mathAbs(this._days);
this._months = mathAbs(this._months);

data.milliseconds = mathAbs(data.milliseconds);
data.seconds = mathAbs(data.seconds);
data.minutes = mathAbs(data.minutes);
data.hours = mathAbs(data.hours);
data.months = mathAbs(data.months);
data.years = mathAbs(data.years);

return this;}


function duration_add_subtract__addSubtract(duration,input,value,direction){
var other=create__createDuration(input,value);

duration._milliseconds += direction * other._milliseconds;
duration._days += direction * other._days;
duration._months += direction * other._months;

return duration._bubble();}



function duration_add_subtract__add(input,value){
return duration_add_subtract__addSubtract(this,input,value,1);}



function duration_add_subtract__subtract(input,value){
return duration_add_subtract__addSubtract(this,input,value,-1);}


function bubble(){
var milliseconds=this._milliseconds;
var days=this._days;
var months=this._months;
var data=this._data;
var seconds,minutes,hours,years=0;



data.milliseconds = milliseconds % 1000;

seconds = absFloor(milliseconds / 1000);
data.seconds = seconds % 60;

minutes = absFloor(seconds / 60);
data.minutes = minutes % 60;

hours = absFloor(minutes / 60);
data.hours = hours % 24;

days += absFloor(hours / 24);


years = absFloor(daysToYears(days));
days -= absFloor(yearsToDays(years));



months += absFloor(days / 30);
days %= 30;


years += absFloor(months / 12);
months %= 12;

data.days = days;
data.months = months;
data.years = years;

return this;}


function daysToYears(days){

return days * 400 / 146097;}


function yearsToDays(years){


return years * 146097 / 400;}


function as(units){
var days;
var months;
var milliseconds=this._milliseconds;

units = normalizeUnits(units);

if(units === 'month' || units === 'year'){
days = this._days + milliseconds / 864e5;
months = this._months + daysToYears(days) * 12;
return units === 'month'?months:months / 12;}else 
{

days = this._days + Math.round(yearsToDays(this._months / 12));
switch(units){
case 'week':return days / 7 + milliseconds / 6048e5;
case 'day':return days + milliseconds / 864e5;
case 'hour':return days * 24 + milliseconds / 36e5;
case 'minute':return days * 1440 + milliseconds / 6e4;
case 'second':return days * 86400 + milliseconds / 1000;

case 'millisecond':return Math.floor(days * 864e5) + milliseconds;
default:throw new Error('Unknown unit ' + units);}}}





function duration_as__valueOf(){
return (
this._milliseconds + 
this._days * 864e5 + 
this._months % 12 * 2592e6 + 
toInt(this._months / 12) * 31536e6);}



function makeAs(alias){
return function(){
return this.as(alias);};}



var asMilliseconds=makeAs('ms');
var asSeconds=makeAs('s');
var asMinutes=makeAs('m');
var asHours=makeAs('h');
var asDays=makeAs('d');
var asWeeks=makeAs('w');
var asMonths=makeAs('M');
var asYears=makeAs('y');

function duration_get__get(units){
units = normalizeUnits(units);
return this[units + 's']();}


function makeGetter(name){
return function(){
return this._data[name];};}



var duration_get__milliseconds=makeGetter('milliseconds');
var seconds=makeGetter('seconds');
var minutes=makeGetter('minutes');
var hours=makeGetter('hours');
var days=makeGetter('days');
var months=makeGetter('months');
var years=makeGetter('years');

function weeks(){
return absFloor(this.days() / 7);}


var round=Math.round;
var thresholds={
s:45,
m:45,
h:22,
d:26,
M:11};



function substituteTimeAgo(string,number,withoutSuffix,isFuture,locale){
return locale.relativeTime(number || 1,!!withoutSuffix,string,isFuture);}


function duration_humanize__relativeTime(posNegDuration,withoutSuffix,locale){
var duration=create__createDuration(posNegDuration).abs();
var seconds=round(duration.as('s'));
var minutes=round(duration.as('m'));
var hours=round(duration.as('h'));
var days=round(duration.as('d'));
var months=round(duration.as('M'));
var years=round(duration.as('y'));

var a=seconds < thresholds.s && ['s',seconds] || 
minutes === 1 && ['m'] || 
minutes < thresholds.m && ['mm',minutes] || 
hours === 1 && ['h'] || 
hours < thresholds.h && ['hh',hours] || 
days === 1 && ['d'] || 
days < thresholds.d && ['dd',days] || 
months === 1 && ['M'] || 
months < thresholds.M && ['MM',months] || 
years === 1 && ['y'] || ['yy',years];

a[2] = withoutSuffix;
a[3] = +posNegDuration > 0;
a[4] = locale;
return substituteTimeAgo.apply(null,a);}



function duration_humanize__getSetRelativeTimeThreshold(threshold,limit){
if(thresholds[threshold] === undefined){
return false;}

if(limit === undefined){
return thresholds[threshold];}

thresholds[threshold] = limit;
return true;}


function humanize(withSuffix){
var locale=this.localeData();
var output=duration_humanize__relativeTime(this,!withSuffix,locale);

if(withSuffix){
output = locale.pastFuture(+this,output);}


return locale.postformat(output);}


var iso_string__abs=Math.abs;

function iso_string__toISOString(){

var Y=iso_string__abs(this.years());
var M=iso_string__abs(this.months());
var D=iso_string__abs(this.days());
var h=iso_string__abs(this.hours());
var m=iso_string__abs(this.minutes());
var s=iso_string__abs(this.seconds() + this.milliseconds() / 1000);
var total=this.asSeconds();

if(!total){


return 'P0D';}


return (total < 0?'-':'') + 
'P' + (
Y?Y + 'Y':'') + (
M?M + 'M':'') + (
D?D + 'D':'') + (
h || m || s?'T':'') + (
h?h + 'H':'') + (
m?m + 'M':'') + (
s?s + 'S':'');}


var duration_prototype__proto=Duration.prototype;

duration_prototype__proto.abs = duration_abs__abs;
duration_prototype__proto.add = duration_add_subtract__add;
duration_prototype__proto.subtract = duration_add_subtract__subtract;
duration_prototype__proto.as = as;
duration_prototype__proto.asMilliseconds = asMilliseconds;
duration_prototype__proto.asSeconds = asSeconds;
duration_prototype__proto.asMinutes = asMinutes;
duration_prototype__proto.asHours = asHours;
duration_prototype__proto.asDays = asDays;
duration_prototype__proto.asWeeks = asWeeks;
duration_prototype__proto.asMonths = asMonths;
duration_prototype__proto.asYears = asYears;
duration_prototype__proto.valueOf = duration_as__valueOf;
duration_prototype__proto._bubble = bubble;
duration_prototype__proto.get = duration_get__get;
duration_prototype__proto.milliseconds = duration_get__milliseconds;
duration_prototype__proto.seconds = seconds;
duration_prototype__proto.minutes = minutes;
duration_prototype__proto.hours = hours;
duration_prototype__proto.days = days;
duration_prototype__proto.weeks = weeks;
duration_prototype__proto.months = months;
duration_prototype__proto.years = years;
duration_prototype__proto.humanize = humanize;
duration_prototype__proto.toISOString = iso_string__toISOString;
duration_prototype__proto.toString = iso_string__toISOString;
duration_prototype__proto.toJSON = iso_string__toISOString;
duration_prototype__proto.locale = locale;
duration_prototype__proto.localeData = localeData;


duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)',iso_string__toISOString);
duration_prototype__proto.lang = lang;



addFormatToken('X',0,0,'unix');
addFormatToken('x',0,0,'valueOf');



addRegexToken('x',matchSigned);
addRegexToken('X',matchTimestamp);
addParseToken('X',function(input,array,config){
config._d = new Date(parseFloat(input,10) * 1000);});

addParseToken('x',function(input,array,config){
config._d = new Date(toInt(input));});





utils_hooks__hooks.version = '2.10.3';

setHookCallback(local__createLocal);

utils_hooks__hooks.fn = momentPrototype;
utils_hooks__hooks.min = min;
utils_hooks__hooks.max = max;
utils_hooks__hooks.utc = create_utc__createUTC;
utils_hooks__hooks.unix = moment__createUnix;
utils_hooks__hooks.months = lists__listMonths;
utils_hooks__hooks.isDate = isDate;
utils_hooks__hooks.locale = locale_locales__getSetGlobalLocale;
utils_hooks__hooks.invalid = valid__createInvalid;
utils_hooks__hooks.duration = create__createDuration;
utils_hooks__hooks.isMoment = isMoment;
utils_hooks__hooks.weekdays = lists__listWeekdays;
utils_hooks__hooks.parseZone = moment__createInZone;
utils_hooks__hooks.localeData = locale_locales__getLocale;
utils_hooks__hooks.isDuration = isDuration;
utils_hooks__hooks.monthsShort = lists__listMonthsShort;
utils_hooks__hooks.weekdaysMin = lists__listWeekdaysMin;
utils_hooks__hooks.defineLocale = defineLocale;
utils_hooks__hooks.weekdaysShort = lists__listWeekdaysShort;
utils_hooks__hooks.normalizeUnits = normalizeUnits;
utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;

var _moment=utils_hooks__hooks;

return _moment;});
});
__d('react-native-scrollable-tab-view/index.js',["react-native/Libraries/react-native/react-native.js","react-native-scrollable-tab-view/DefaultTabBar.js","rebound/rebound.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};

var React=require('react-native/Libraries/react-native/react-native.js');var 

Text=




React.Text;var View=React.View;var ScrollView=React.ScrollView;var TouchableOpacity=React.TouchableOpacity;var PanResponder=React.PanResponder;

var DefaultTabBar=require('react-native-scrollable-tab-view/DefaultTabBar.js');
var deviceWidth=require('Dimensions').get('window').width;
var rebound=require('rebound/rebound.js');
var precomputeStyle=require('precomputeStyle');
var TAB_BAR_REF='TAB_BAR';

var ScrollableTabView=React.createClass({displayName:'ScrollableTabView',
getDefaultProps:function(){
return {
edgeHitWidth:30};},



getInitialState:function(){
return {currentPage:0};},


componentDidMount:function(){
this._scrollSpring.setCurrentValue(0);},


componentWillMount:function(){var _this=this;

this.springSystem = new rebound.SpringSystem();
this._scrollSpring = this.springSystem.createSpring();
this._updateSpringConfig(this.props);

this._scrollSpring.addListener({
onSpringUpdate:function(){
if(!_this.scrollView){return;}

var currentValue=_this._scrollSpring.getCurrentValue();
var offsetX=deviceWidth * currentValue;

_this.scrollView.setNativeProps(precomputeStyle({
transform:[{translateX:-1 * offsetX}]}));



_this.refs[TAB_BAR_REF].setAnimationValue(currentValue);}});



this._panResponder = PanResponder.create({

onMoveShouldSetPanResponder:function(e,gestureState){
if(Math.abs(gestureState.dx) > Math.abs(gestureState.dy)){
if(gestureState.moveX <= _this.props.edgeHitWidth || 
gestureState.moveX >= deviceWidth - _this.props.edgeHitWidth){
return true;}}},





onPanResponderRelease:function(e,gestureState){
var relativeGestureDistance=gestureState.dx / deviceWidth,
lastPageIndex=_this.props.children.length - 1,
vx=gestureState.vx,
newPage=_this.state.currentPage;

if(_this.state.currentPage !== lastPageIndex && (relativeGestureDistance < -0.5 || relativeGestureDistance < 0 && vx <= 0.5)){
newPage = newPage + 1;}else 
if(_this.state.currentPage !== 0 && (relativeGestureDistance > 0.5 || relativeGestureDistance > 0 && vx >= 0.5)){
newPage = newPage - 1;}


_this.goToPage(newPage);},



onPanResponderMove:function(e,gestureState){
var dx=gestureState.dx;
var lastPageIndex=_this.props.children.length - 1;

if(_this.state.currentPage === 0 && dx > 0){}else 

if(_this.state.currentPage === lastPageIndex && dx < 0){}else 

{


var offsetX=dx - _this.state.currentPage * deviceWidth;
_this._scrollSpring.setCurrentValue(-1 * offsetX / deviceWidth);}}});},





componentWillReceiveProps:function(nextProps){
this._updateSpringConfig(nextProps);},


_updateSpringConfig:function(props){
var springConfig=this._scrollSpring.getSpringConfig();
springConfig.tension = rebound.OrigamiValueConverter.tensionFromOrigamiValue(props.springTension || 25);
springConfig.friction = rebound.OrigamiValueConverter.frictionFromOrigamiValue(props.springFriction || 8);

this._scrollSpring.setOvershootClampingEnabled(typeof props.clampSpring === 'undefined'?true:props.clampSpring);},


goToPage:function(pageNumber){
this.props.currentPage !== pageNumber && this.props.onChangeTab && 
this.props.onChangeTab({i:pageNumber,ref:this.props.children[pageNumber]});

this._scrollSpring.setEndValue(pageNumber);
this.setState({currentPage:pageNumber});},


renderTabBar:function(props){
if(this.props.renderTabBar){
return React.cloneElement(this.props.renderTabBar(),props);}else 
{
return React.createElement(DefaultTabBar,props);}},



render:function(){var _this2=this;
var sceneContainerStyle={
width:deviceWidth * this.props.children.length,
flex:1,
flexDirection:'row'};


return (
React.createElement(View,{style:{flex:1}},
this.renderTabBar({goToPage:this.goToPage,
tabs:this.props.children.map(function(child){return child.props.tabLabel;}),
activeTab:this.state.currentPage,
ref:TAB_BAR_REF}),

React.createElement(View,_extends({style:sceneContainerStyle},this._panResponder.panHandlers,{
ref:function(view){_this2.scrollView = view;}}),
this.props.children)));}});






module.exports = ScrollableTabView;
});
__d('react-native-scrollable-tab-view/DefaultTabBar.js',["react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

var React=require('react-native/Libraries/react-native/react-native.js');var 

StyleSheet=



React.StyleSheet;var Text=React.Text;var View=React.View;var TouchableOpacity=React.TouchableOpacity;

var deviceWidth=require('Dimensions').get('window').width;
var precomputeStyle=require('precomputeStyle');
var TAB_UNDERLINE_REF='TAB_UNDERLINE';

var styles=StyleSheet.create({
tab:{
flex:1,
alignItems:'center',
justifyContent:'center',
paddingBottom:10},


tabs:{
height:50,
flexDirection:'row',
marginTop:20,
borderWidth:1,
borderTopWidth:0,
borderLeftWidth:0,
borderRightWidth:0,
borderBottomColor:'#ccc'}});



var DefaultTabBar=React.createClass({displayName:'DefaultTabBar',
propTypes:{
goToPage:React.PropTypes.func,
activeTab:React.PropTypes.number,
tabs:React.PropTypes.array},


renderTabOption:function(name,page){var _this=this;
var isTabActive=this.props.activeTab === page;

return (
React.createElement(TouchableOpacity,{key:name,onPress:function(){return _this.props.goToPage(page);}},
React.createElement(View,{style:[styles.tab]},
React.createElement(Text,{style:{color:isTabActive?'navy':'black',fontWeight:isTabActive?'bold':'normal'}},name))));},





setAnimationValue:function(value){
this.refs[TAB_UNDERLINE_REF].setNativeProps(precomputeStyle({
left:deviceWidth * value / this.props.tabs.length}));},



render:function(){var _this2=this;
var numberOfTabs=this.props.tabs.length;
var tabUnderlineStyle={
position:'absolute',
width:deviceWidth / numberOfTabs,
height:4,
backgroundColor:'navy',
bottom:0};


return (
React.createElement(View,{style:styles.tabs},
this.props.tabs.map(function(tab,i){return _this2.renderTabOption(tab,i);}),
React.createElement(View,{style:tabUnderlineStyle,ref:TAB_UNDERLINE_REF})));}});





module.exports = DefaultTabBar;
});
__d('rebound/rebound.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  (


























































































































function(){
var rebound={};
var util=rebound.util = {};
var concat=Array.prototype.concat;
var slice=Array.prototype.slice;


util.bind = function bind(func,context){
var args=slice.call(arguments,2);
return function(){
func.apply(context,concat.call(args,slice.call(arguments)));};};




util.extend = function extend(target,source){
for(var key in source) {
if(source.hasOwnProperty(key)){
target[key] = source[key];}}};









var SpringSystem=rebound.SpringSystem = function SpringSystem(looper){
this._springRegistry = {};
this._activeSprings = [];
this.listeners = [];
this._idleSpringIndices = [];
this.looper = looper || new AnimationLooper();
this.looper.springSystem = this;};


util.extend(SpringSystem.prototype,{

_springRegistry:null,

_isIdle:true,

_lastTimeMillis:-1,

_activeSprings:null,

listeners:null,

_idleSpringIndices:null,






setLooper:function(looper){
this.looper = looper;
looper.springSystem = this;},






createSpring:function(tension,friction){
var springConfig;
if(tension === undefined || friction === undefined){
springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;}else 
{
springConfig = 
SpringConfig.fromOrigamiTensionAndFriction(tension,friction);}

return this.createSpringWithConfig(springConfig);},





createSpringWithBouncinessAndSpeed:function(bounciness,speed){
var springConfig;
if(bounciness === undefined || speed === undefined){
springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;}else 
{
springConfig = 
SpringConfig.fromBouncinessAndSpeed(bounciness,speed);}

return this.createSpringWithConfig(springConfig);},



createSpringWithConfig:function(springConfig){
var spring=new Spring(this);
this.registerSpring(spring);
spring.setSpringConfig(springConfig);
return spring;},






getIsIdle:function(){
return this._isIdle;},





getSpringById:function(id){
return this._springRegistry[id];},




getAllSprings:function(){
var vals=[];
for(var id in this._springRegistry) {
if(this._springRegistry.hasOwnProperty(id)){
vals.push(this._springRegistry[id]);}}


return vals;},






registerSpring:function(spring){
this._springRegistry[spring.getId()] = spring;},






deregisterSpring:function(spring){
removeFirst(this._activeSprings,spring);
delete this._springRegistry[spring.getId()];},


advance:function(time,deltaTime){
while(this._idleSpringIndices.length > 0) this._idleSpringIndices.pop();
for(var i=0,len=this._activeSprings.length;i < len;i++) {
var spring=this._activeSprings[i];
if(spring.systemShouldAdvance()){
spring.advance(time / 1000.0,deltaTime / 1000.0);}else 
{
this._idleSpringIndices.push(this._activeSprings.indexOf(spring));}}


while(this._idleSpringIndices.length > 0) {
var idx=this._idleSpringIndices.pop();
idx >= 0 && this._activeSprings.splice(idx,1);}},
















loop:function(currentTimeMillis){
var listener;
if(this._lastTimeMillis === -1){
this._lastTimeMillis = currentTimeMillis - 1;}

var ellapsedMillis=currentTimeMillis - this._lastTimeMillis;
this._lastTimeMillis = currentTimeMillis;

var i=0,len=this.listeners.length;
for(i = 0;i < len;i++) {
listener = this.listeners[i];
listener.onBeforeIntegrate && listener.onBeforeIntegrate(this);}


this.advance(currentTimeMillis,ellapsedMillis);
if(this._activeSprings.length === 0){
this._isIdle = true;
this._lastTimeMillis = -1;}


for(i = 0;i < len;i++) {
listener = this.listeners[i];
listener.onAfterIntegrate && listener.onAfterIntegrate(this);}


if(!this._isIdle){
this.looper.run();}},






activateSpring:function(springId){
var spring=this._springRegistry[springId];
if(this._activeSprings.indexOf(spring) == -1){
this._activeSprings.push(spring);}

if(this.getIsIdle()){
this._isIdle = false;
this.looper.run();}},






addListener:function(listener){
this.listeners.push(listener);},



removeListener:function(listener){
removeFirst(this.listeners,listener);},



removeAllListeners:function(){
this.listeners = [];}});


















var Spring=rebound.Spring = function Spring(springSystem){
this._id = 's' + Spring._ID++;
this._springSystem = springSystem;
this.listeners = [];
this._currentState = new PhysicsState();
this._previousState = new PhysicsState();
this._tempState = new PhysicsState();};


util.extend(Spring,{
_ID:0,

MAX_DELTA_TIME_SEC:0.064,

SOLVER_TIMESTEP_SEC:0.001});



util.extend(Spring.prototype,{

_id:0,

_springConfig:null,

_overshootClampingEnabled:false,

_currentState:null,

_previousState:null,

_tempState:null,

_startValue:0,

_endValue:0,

_wasAtRest:true,

_restSpeedThreshold:0.001,

_displacementFromRestThreshold:0.001,

listeners:null,

_timeAccumulator:0,

_springSystem:null,


destroy:function(){
this.listeners = [];
this.frames = [];
this._springSystem.deregisterSpring(this);},




getId:function(){
return this._id;},





setSpringConfig:function(springConfig){
this._springConfig = springConfig;
return this;},



getSpringConfig:function(){
return this._springConfig;},





























setCurrentValue:function(currentValue,skipSetAtRest){
this._startValue = currentValue;
this._currentState.position = currentValue;
if(!skipSetAtRest){
this.setAtRest();}

this.notifyPositionUpdated(false,false);
return this;},





getStartValue:function(){
return this._startValue;},



getCurrentValue:function(){
return this._currentState.position;},




getCurrentDisplacementDistance:function(){
return this.getDisplacementDistanceForState(this._currentState);},


getDisplacementDistanceForState:function(state){
return Math.abs(this._endValue - state.position);},








setEndValue:function(endValue){
if(this._endValue == endValue && this.isAtRest()){
return this;}

this._startValue = this.getCurrentValue();
this._endValue = endValue;
this._springSystem.activateSpring(this.getId());
for(var i=0,len=this.listeners.length;i < len;i++) {
var listener=this.listeners[i];
var onChange=listener.onSpringEndStateChange;
onChange && onChange(this);}

return this;},



getEndValue:function(){
return this._endValue;},









setVelocity:function(velocity){
if(velocity === this._currentState.velocity){
return this;}

this._currentState.velocity = velocity;
this._springSystem.activateSpring(this.getId());
return this;},



getVelocity:function(){
return this._currentState.velocity;},




setRestSpeedThreshold:function(restSpeedThreshold){
this._restSpeedThreshold = restSpeedThreshold;
return this;},



getRestSpeedThreshold:function(){
return this._restSpeedThreshold;},





setRestDisplacementThreshold:function(displacementFromRestThreshold){
this._displacementFromRestThreshold = displacementFromRestThreshold;},



getRestDisplacementThreshold:function(){
return this._displacementFromRestThreshold;},







setOvershootClampingEnabled:function(enabled){
this._overshootClampingEnabled = enabled;
return this;},



isOvershootClampingEnabled:function(){
return this._overshootClampingEnabled;},





isOvershooting:function(){
var start=this._startValue;
var end=this._endValue;
return this._springConfig.tension > 0 && (
start < end && this.getCurrentValue() > end || 
start > end && this.getCurrentValue() < end);},







advance:function(time,realDeltaTime){
var isAtRest=this.isAtRest();

if(isAtRest && this._wasAtRest){
return;}


var adjustedDeltaTime=realDeltaTime;
if(realDeltaTime > Spring.MAX_DELTA_TIME_SEC){
adjustedDeltaTime = Spring.MAX_DELTA_TIME_SEC;}


this._timeAccumulator += adjustedDeltaTime;

var tension=this._springConfig.tension,
friction=this._springConfig.friction,

position=this._currentState.position,
velocity=this._currentState.velocity,
tempPosition=this._tempState.position,
tempVelocity=this._tempState.velocity,

aVelocity,aAcceleration,
bVelocity,bAcceleration,
cVelocity,cAcceleration,
dVelocity,dAcceleration,

dxdt,dvdt;

while(this._timeAccumulator >= Spring.SOLVER_TIMESTEP_SEC) {

this._timeAccumulator -= Spring.SOLVER_TIMESTEP_SEC;

if(this._timeAccumulator < Spring.SOLVER_TIMESTEP_SEC){
this._previousState.position = position;
this._previousState.velocity = velocity;}


aVelocity = velocity;
aAcceleration = 
tension * (this._endValue - tempPosition) - friction * velocity;

tempPosition = position + aVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;
tempVelocity = 
velocity + aAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;
bVelocity = tempVelocity;
bAcceleration = 
tension * (this._endValue - tempPosition) - friction * tempVelocity;

tempPosition = position + bVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;
tempVelocity = 
velocity + bAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;
cVelocity = tempVelocity;
cAcceleration = 
tension * (this._endValue - tempPosition) - friction * tempVelocity;

tempPosition = position + cVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;
tempVelocity = 
velocity + cAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;
dVelocity = tempVelocity;
dAcceleration = 
tension * (this._endValue - tempPosition) - friction * tempVelocity;

dxdt = 
1.0 / 6.0 * (aVelocity + 2.0 * (bVelocity + cVelocity) + dVelocity);
dvdt = 1.0 / 6.0 * (
aAcceleration + 2.0 * (bAcceleration + cAcceleration) + dAcceleration);


position += dxdt * Spring.SOLVER_TIMESTEP_SEC;
velocity += dvdt * Spring.SOLVER_TIMESTEP_SEC;}


this._tempState.position = tempPosition;
this._tempState.velocity = tempVelocity;

this._currentState.position = position;
this._currentState.velocity = velocity;

if(this._timeAccumulator > 0){
this._interpolate(this._timeAccumulator / Spring.SOLVER_TIMESTEP_SEC);}


if(this.isAtRest() || 
this._overshootClampingEnabled && this.isOvershooting()){

if(this._springConfig.tension > 0){
this._startValue = this._endValue;
this._currentState.position = this._endValue;}else 
{
this._endValue = this._currentState.position;
this._startValue = this._endValue;}

this.setVelocity(0);
isAtRest = true;}


var notifyActivate=false;
if(this._wasAtRest){
this._wasAtRest = false;
notifyActivate = true;}


var notifyAtRest=false;
if(isAtRest){
this._wasAtRest = true;
notifyAtRest = true;}


this.notifyPositionUpdated(notifyActivate,notifyAtRest);},


notifyPositionUpdated:function(notifyActivate,notifyAtRest){
for(var i=0,len=this.listeners.length;i < len;i++) {
var listener=this.listeners[i];
if(notifyActivate && listener.onSpringActivate){
listener.onSpringActivate(this);}


if(listener.onSpringUpdate){
listener.onSpringUpdate(this);}


if(notifyAtRest && listener.onSpringAtRest){
listener.onSpringAtRest(this);}}},









systemShouldAdvance:function(){
return !this.isAtRest() || !this.wasAtRest();},


wasAtRest:function(){
return this._wasAtRest;},








isAtRest:function(){
return Math.abs(this._currentState.velocity) < this._restSpeedThreshold && (
this.getDisplacementDistanceForState(this._currentState) <= 
this._displacementFromRestThreshold || 
this._springConfig.tension === 0);},






setAtRest:function(){
this._endValue = this._currentState.position;
this._tempState.position = this._currentState.position;
this._currentState.velocity = 0;
return this;},


_interpolate:function(alpha){
this._currentState.position = this._currentState.position * 
alpha + this._previousState.position * (1 - alpha);
this._currentState.velocity = this._currentState.velocity * 
alpha + this._previousState.velocity * (1 - alpha);},


getListeners:function(){
return this.listeners;},


addListener:function(newListener){
this.listeners.push(newListener);
return this;},


removeListener:function(listenerToRemove){
removeFirst(this.listeners,listenerToRemove);
return this;},


removeAllListeners:function(){
this.listeners = [];
return this;},


currentValueIsApproximately:function(value){
return Math.abs(this.getCurrentValue() - value) <= 
this.getRestDisplacementThreshold();}});









var PhysicsState=function PhysicsState(){};

util.extend(PhysicsState.prototype,{
position:0,
velocity:0});








var SpringConfig=rebound.SpringConfig = 
function SpringConfig(tension,friction){
this.tension = tension;
this.friction = friction;};







var AnimationLooper=rebound.AnimationLooper = function AnimationLooper(){
this.springSystem = null;
var _this=this;
var _run=function(){
_this.springSystem.loop(Date.now());};


this.run = function(){
util.onFrame(_run);};};









rebound.SimulationLooper = function SimulationLooper(timestep){
this.springSystem = null;
var time=0;
var running=false;
timestep = timestep || 16.667;

this.run = function(){
if(running){
return;}

running = true;
while(!this.springSystem.getIsIdle()) {
this.springSystem.loop(time += timestep);}

running = false;};};








rebound.SteppingSimulationLooper = function(timestep){
this.springSystem = null;
var time=0;



this.run = function(){};


this.step = function(timestep){
this.springSystem.loop(time += timestep);};};








var OrigamiValueConverter=rebound.OrigamiValueConverter = {
tensionFromOrigamiValue:function(oValue){
return (oValue - 30.0) * 3.62 + 194.0;},


origamiValueFromTension:function(tension){
return (tension - 194.0) / 3.62 + 30.0;},


frictionFromOrigamiValue:function(oValue){
return (oValue - 8.0) * 3.0 + 25.0;},


origamiFromFriction:function(friction){
return (friction - 25.0) / 3.0 + 8.0;}};










var BouncyConversion=rebound.BouncyConversion = function(bounciness,speed){
this.bounciness = bounciness;
this.speed = speed;
var b=this.normalize(bounciness / 1.7,0,20.0);
b = this.projectNormal(b,0.0,0.8);
var s=this.normalize(speed / 1.7,0,20.0);
this.bouncyTension = this.projectNormal(s,0.5,200);
this.bouncyFriction = this.quadraticOutInterpolation(
b,
this.b3Nobounce(this.bouncyTension),
0.01);};


util.extend(BouncyConversion.prototype,{

normalize:function(value,startValue,endValue){
return (value - startValue) / (endValue - startValue);},


projectNormal:function(n,start,end){
return start + n * (end - start);},


linearInterpolation:function(t,start,end){
return t * end + (1.0 - t) * start;},


quadraticOutInterpolation:function(t,start,end){
return this.linearInterpolation(2 * t - t * t,start,end);},


b3Friction1:function(x){
return 0.0007 * Math.pow(x,3) - 
0.031 * Math.pow(x,2) + 0.64 * x + 1.28;},


b3Friction2:function(x){
return 0.000044 * Math.pow(x,3) - 
0.006 * Math.pow(x,2) + 0.36 * x + 2;},


b3Friction3:function(x){
return 0.00000045 * Math.pow(x,3) - 
0.000332 * Math.pow(x,2) + 0.1078 * x + 5.84;},


b3Nobounce:function(tension){
var friction=0;
if(tension <= 18){
friction = this.b3Friction1(tension);}else 
if(tension > 18 && tension <= 44){
friction = this.b3Friction2(tension);}else 
{
friction = this.b3Friction3(tension);}

return friction;}});



util.extend(SpringConfig,{




fromOrigamiTensionAndFriction:function(tension,friction){
return new SpringConfig(
OrigamiValueConverter.tensionFromOrigamiValue(tension),
OrigamiValueConverter.frictionFromOrigamiValue(friction));},





fromBouncinessAndSpeed:function(bounciness,speed){
var bouncyConversion=new rebound.BouncyConversion(bounciness,speed);
return this.fromOrigamiTensionAndFriction(
bouncyConversion.bouncyTension,
bouncyConversion.bouncyFriction);},




coastingConfigWithOrigamiFriction:function(friction){
return new SpringConfig(
0,
OrigamiValueConverter.frictionFromOrigamiValue(friction));}});




SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG = 
SpringConfig.fromOrigamiTensionAndFriction(40,7);

util.extend(SpringConfig.prototype,{friction:0,tension:0});




var colorCache={};
util.hexToRGB = function(color){
if(colorCache[color]){
return colorCache[color];}

color = color.replace('#','');
if(color.length === 3){
color = color[0] + color[0] + color[1] + color[1] + color[2] + color[2];}

var parts=color.match(/.{2}/g);

var ret={
r:parseInt(parts[0],16),
g:parseInt(parts[1],16),
b:parseInt(parts[2],16)};


colorCache[color] = ret;
return ret;};


util.rgbToHex = function(r,g,b){
r = r.toString(16);
g = g.toString(16);
b = b.toString(16);
r = r.length < 2?'0' + r:r;
g = g.length < 2?'0' + g:g;
b = b.length < 2?'0' + b:b;
return '#' + r + g + b;};


var MathUtil=rebound.MathUtil = {








mapValueInRange:function(value,fromLow,fromHigh,toLow,toHigh){
var fromRangeSize=fromHigh - fromLow;
var toRangeSize=toHigh - toLow;
var valueScale=(value - fromLow) / fromRangeSize;
return toLow + valueScale * toRangeSize;},





interpolateColor:
function(val,startColor,endColor,fromLow,fromHigh,asRGB){
fromLow = fromLow === undefined?0:fromLow;
fromHigh = fromHigh === undefined?1:fromHigh;
startColor = util.hexToRGB(startColor);
endColor = util.hexToRGB(endColor);
var r=Math.floor(
util.mapValueInRange(val,fromLow,fromHigh,startColor.r,endColor.r));

var g=Math.floor(
util.mapValueInRange(val,fromLow,fromHigh,startColor.g,endColor.g));

var b=Math.floor(
util.mapValueInRange(val,fromLow,fromHigh,startColor.b,endColor.b));

if(asRGB){
return 'rgb(' + r + ',' + g + ',' + b + ')';}else 
{
return util.rgbToHex(r,g,b);}},



degreesToRadians:function(deg){
return deg * Math.PI / 180;},


radiansToDegrees:function(rad){
return rad * 180 / Math.PI;}};




util.extend(util,MathUtil);







function removeFirst(array,item){
var idx=array.indexOf(item);
idx != -1 && array.splice(idx,1);}


var _onFrame;
if(typeof window !== 'undefined'){
_onFrame = window.requestAnimationFrame || 
window.webkitRequestAnimationFrame || 
window.mozRequestAnimationFrame || 
window.msRequestAnimationFrame || 
window.oRequestAnimationFrame || 
function(callback){
window.setTimeout(callback,1000 / 60);};}


if(!_onFrame && typeof process !== 'undefined' && process.title === 'node'){
_onFrame = setImmediate;}



util.onFrame = function onFrame(func){
return _onFrame(func);};




if(typeof exports != 'undefined'){
util.extend(exports,rebound);}else 
if(typeof window != 'undefined'){
window.rebound = rebound;}})();
});
__d('noder/app/components/userTopicPage.js',["react-native/Libraries/react-native/react-native.js","moment/moment.js","noder/app/components/topicRow.js","noder/app/scene/topic.js","noder/app/configs/sceneConfig.js","noder/app/configs/config.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var moment=require('moment/moment.js');

var TopicRow=require('noder/app/components/topicRow.js');
var Topic=require('noder/app/scene/topic.js');

var sceneConfig=require('noder/app/configs/sceneConfig.js');
var config=require('noder/app/configs/config.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=









React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;var 


UserTopicPage=(function(_Component){_inherits(UserTopicPage,_Component);
function UserTopicPage(props){_classCallCheck(this,UserTopicPage);
_get(Object.getPrototypeOf(UserTopicPage.prototype),'constructor',this).call(this,props);
this.ds = new ListView.DataSource({rowHasChanged:function(r1,r2){return r1 !== r2;}});
this.data = this.props.data || [];
this.state = {
ds:this.ds.cloneWithRows(this.data)};}_createClass(UserTopicPage,[{key:'componentWillReceiveProps',value:




function componentWillReceiveProps(nextProps){
if(nextProps.data != this.props.data){
this.setState({
ds:this.ds.cloneWithRows(nextProps.data)});}}},{key:'_onRowPress',value:





function _onRowPress(topic){
this.props.router.toTopic({
topic:topic,
from:'user'});}},{key:'_renderRowFooter',value:




function _renderRowFooter(topic){
var date=moment(topic.last_reply_at).startOf('minute').fromNow();
var dateItem=
React.createElement(Text,{
key:'dateText',
style:[styles['topicFooter text'],styles['topicFooter date']]},
date);



var authorItem=
React.createElement(Text,{
key:'authorText',
style:[styles['topicFooter text'],styles['topicFooter author']]},
topic.author.loginname);




return [dateItem,authorItem];}},{key:'_renderRow',value:



function _renderRow(topic){
return (
React.createElement(TopicRow,{
onPress:this._onRowPress.bind(this),
topic:topic,
footer:this._renderRowFooter(topic)}));}},{key:'render',value:





function render(){
return (
React.createElement(View,{style:[styles.container,this.props.style]},
React.createElement(ListView,{
showsVerticalScrollIndicator:true,
initialListSize:10,
pagingEnabled:false,
removeClippedSubviews:true,
dataSource:this.state.ds,
renderRow:this._renderRow.bind(this)})));}}]);return UserTopicPage;})(Component);







var styles=StyleSheet.create({
container:{
width:width},

'topicFooter text':{
'fontSize':11,
'color':'rgba(0, 0, 0, 0.3)'},

'topicFooter date':{
'position':'absolute',
'right':0,
'top':0},

'topicFooter author':{
position:'absolute',
left:0,
top:0}});




module.exports = UserTopicPage;
});
__d('noder/app/components/topicRow.js',["react-native/Libraries/react-native/react-native.js","moment/moment.js","noder/app/configs/config.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var moment=require('moment/moment.js');


var config=require('noder/app/configs/config.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=









React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;var 


TopicRow=(function(_Component){_inherits(TopicRow,_Component);
function TopicRow(props){_classCallCheck(this,TopicRow);
_get(Object.getPrototypeOf(TopicRow.prototype),'constructor',this).call(this,props);}_createClass(TopicRow,[{key:'render',value:


function render(){var _this=this;
var topic=this.props.topic;
var authorImgUri=config.domain + topic.author.avatar_url;
var title=topic.title;
var titleLength=Math.floor((width - 100) / 15) + 2;
if(title.length > titleLength){
title = title.substring(0,titleLength - 3) + '...';}

return (
React.createElement(TouchableHighlight,{
onPress:function(){_this.props.onPress(topic);},
underlayColor:'#3498DB',
key:topic.id},
React.createElement(View,{style:styles.row},
React.createElement(View,{style:styles.imgWrapper},
React.createElement(Image,{
style:styles.img,
source:{uri:authorImgUri}})),




React.createElement(View,{style:[styles.topic]},
React.createElement(Text,{style:[styles.title]},
title),


React.createElement(View,{style:[styles.topicFooter]},

this.props.footer)))));}}]);return TopicRow;})(Component);










var styles=StyleSheet.create({
'row':{
'height':90,
'flexDirection':'row',
'borderBottomColor':'rgba(0, 0, 0, 0.02)',
'borderBottomWidth':1,
'paddingTop':25,
'paddingRight':0,
'paddingBottom':25,
'paddingLeft':20},

'imgWrapper':{
'width':90,
'position':'absolute',
'left':20,
'top':25,
'height':65},

'img':{
'height':40,
'width':40,
'borderRadius':20},

'topic':{
'marginLeft':60,
width:width - 100},

'title':{
'fontSize':15},

'topicFooter':{
'marginTop':12,
'flexDirection':'row'}});




module.exports = TopicRow;
});
__d('noder/app/scene/topic.js',["react-native/Libraries/react-native/react-native.js","noder/app/util/window.js","moment/moment.js","react-native-icons/index.js","noder/app/components/htmlRender/htmlContent.js","noder/app/components/overlay/return.js","noder/app/components/overlay/commentOverlay.js","noder/app/components/likeIcon.js","noder/app/configs/config.js","noder/app/util/genColor.js","noder/app/services/topicService.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}
var React=require('react-native/Libraries/react-native/react-native.js');
var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;
var moment=require('moment/moment.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;



var HtmlContent=require('noder/app/components/htmlRender/htmlContent.js');
var Return=require('noder/app/components/overlay/return.js');
var CommentOverlay=require('noder/app/components/overlay/commentOverlay.js');
var LikeIcon=require('noder/app/components/likeIcon.js');



var config=require('noder/app/configs/config.js');



var genColor=require('noder/app/util/genColor.js');
var topicService=require('noder/app/services/topicService.js');var 



View=











React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;var TouchableOpacity=React.TouchableOpacity;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;


var topicHeaderHeight=100;
var topicAuthorWidth=100;
var headerPaddingTop=20;
var authorImgHeight=40;
var contentPadding=15;


var styles=StyleSheet.create({
container:{
flex:1,
width:width,
backgroundColor:'white',
height:height},

header:{

flex:1,
alignItems:'center',
justifyContent:'space-between',

flexDirection:'row',

paddingRight:20,
paddingLeft:20},

authorTouchable:{},



authorWrapper:{

width:topicAuthorWidth - 40,

flexDirection:'column',
alignItems:'center',
justifyContent:'space-between'},

authorImg:{
width:authorImgHeight,
height:authorImgHeight,
borderRadius:authorImgHeight / 2},

author:{
paddingBottom:12,
color:'rgba(255,255,255,0.7)',
fontSize:12},

titleWrapper:{
width:width - topicAuthorWidth - 20,
flexDirection:'column',
paddingTop:20,
paddingBottom:20},

title:{
color:'rgba(255,255,255,0.9)',
width:width - topicAuthorWidth - 20,
justifyContent:'flex-end',
flex:1,
lineHeight:1.2 * 16},

titleFooter:{
flex:1,
flexDirection:'row',
alignItems:'flex-end',
justifyContent:'space-between',
marginTop:20},

date:{
width:100,
flexDirection:'row'},

dateText:{
color:'rgba(255,255,255,0.5)',
fontSize:12},

dateIcon:{
width:12,
height:16,
marginRight:8},

like:{
width:20,
flexDirection:'row'},

likeIcon:{
width:20,
height:16,
marginRight:8},

content:{
paddingRight:contentPadding,
paddingLeft:contentPadding,
paddingTop:contentPadding,
paddingBottom:contentPadding,
backgroundColor:'white'}});var 





Topic=(function(_Component){_inherits(Topic,_Component);
function Topic(props){_classCallCheck(this,Topic);
_get(Object.getPrototypeOf(Topic.prototype),'constructor',this).call(this,props);
this.headerColor = genColor();
this.state = {
likedLoading:false,
topic:this.props.topic,
isLoading:false,
err:{
shouldShow:false,
content:null},

didFocus:false};}_createClass(Topic,[{key:'componentDidMount',value:




function componentDidMount(){
if(this.props.from == 'user'){
return this._fetchTopic();}}},{key:'componentDidFocus',value:




function componentDidFocus(){
this.setState({
didFocus:true});}},{key:'_fetchTopic',value:




function _fetchTopic(){var _this=this;
this.setState({
isLoading:true});

var id=this.state.topic.id;
topicService.req.getTopicById(id).
then(function(topic){


_this.setState({
isLoading:false,
topic:topic});}).


catch(function(err){
console.warn(err);
_this.setState({
isLoading:false,
err:{
shouldShow:true,
content:''}});}).



done();}},{key:'_onCommentOverlayPress',value:



function _onCommentOverlayPress(){
this.props.router.toComments({
topic:this.props.topic,
from:'topic'});}},{key:'_onAuthorImgPress',value:




function _onAuthorImgPress(authorName){
this.props.router.toUser({
userName:authorName});}},{key:'_renderContent',value:




function _renderContent(content){
if(this.state.didFocus && content){
return (
React.createElement(HtmlContent,{
router:this.props.router,
content:content}));}



return (
React.createElement(ActivityIndicatorIOS,{
size:'large',
animating:true,
style:{marginTop:20,width:width}}));}},{key:'render',value:




function render(){
var topic=this.state.topic;
var domain=config.domain;

var imgUri=domain + topic.author.avatar_url;
var authorName=topic.author.loginname;
var date=moment(topic.create_at).startOf('hour').fromNow();

return (
React.createElement(View,{style:[styles.container]},
React.createElement(ScrollView,null,
React.createElement(View,{style:[styles.header,{backgroundColor:this.headerColor}]},
React.createElement(View,{style:styles.authorTouchable},
React.createElement(View,{style:styles.authorWrapper},
React.createElement(TouchableOpacity,{
onPress:this._onAuthorImgPress.bind(this,authorName)},
React.createElement(Image,{
source:{uri:imgUri},
style:styles.authorImg})))),






React.createElement(View,{style:styles.titleWrapper},
React.createElement(Text,{style:styles.title},
topic.title),


React.createElement(View,{style:styles.titleFooter},
React.createElement(View,{style:styles.date},
React.createElement(Icon,{
name:'ion|clock',
size:12,
color:'rgba(255,255,255,0.5)',
style:styles.dateIcon}),

React.createElement(Text,{style:styles.dateText},
date)),



React.createElement(View,{style:styles.like},
React.createElement(LikeIcon,{
topic:topic,
style:styles.likeIcon,
user:this.props.state.user,
actions:this.props.actions}))))),






React.createElement(View,{style:styles.content},
this._renderContent(topic.content))),


React.createElement(Return,{router:this.props.router}),
React.createElement(CommentOverlay,{
onPress:this._onCommentOverlayPress.bind(this),
topic:topic})));}}]);return Topic;})(Component);






module.exports = Topic;
});
__d('noder/app/components/htmlRender/htmlContent.js',["react-native/Libraries/react-native/react-native.js","react-native-html-render/index.js","noder/app/util/window.js","noder/app/configs/routes.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');

var HtmlRender=require('react-native-html-render/index.js');

var window=require('noder/app/util/window.js');
var routes=require('noder/app/configs/routes.js');var _window$get=


window.get();var width=_window$get.width;var height=_window$get.height;var 


Component=






React.Component;var View=React.View;var Text=React.Text;var StyleSheet=React.StyleSheet;var Image=React.Image;var LinkingIOS=React.LinkingIOS;var Navigator=React.Navigator;

var contentFontSize=16;


var styles=StyleSheet.create({
img:{
width:width - 30,
height:width - 30,
resizeMode:Image.resizeMode.contain}});var 




HtmlContent=(function(_Component){_inherits(HtmlContent,_Component);
function HtmlContent(props){_classCallCheck(this,HtmlContent);
_get(Object.getPrototypeOf(HtmlContent.prototype),'constructor',this).call(this,props);}_createClass(HtmlContent,[{key:'_onLinkPress',value:



function _onLinkPress(url){
if(/^\/user\/\w*/.test(url)){
var authorName=url.replace(/^\/user\//,'');
this.props.router.toUser({
userName:authorName});}



if(/^https?:\/\/.*/.test(url)){
window.link(url);}}},{key:'_renderNode',value:




function _renderNode(node,index,parent,type){
var name=node.name;
if(node.type == 'block' && type == 'block'){
if(name == 'img'){
var uri=node.attribs.src;
if(/^\/\/dn-cnode\.qbox\.me\/.*/.test(uri)){
uri = 'https:' + uri;}

return (
React.createElement(View,{
key:index,
style:styles.imgWrapper},
React.createElement(Image,{source:{uri:uri},
style:styles.img})));}}}},{key:'render',value:








function render(){
return (
React.createElement(HtmlRender,{
value:this.props.content,
stylesheet:this.props.style,
onLinkPress:this._onLinkPress.bind(this),
renderNode:this._renderNode}));}}]);return HtmlContent;})(Component);






module.exports = HtmlContent;
});
__d('react-native-html-render/index.js',["react-native-html-render/lib/htmlRender.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  module.exports = require('react-native-html-render/lib/htmlRender.js');
});
__d('react-native-html-render/lib/htmlRender.js',["react-native/Libraries/react-native/react-native.js","react-native-html-render/lib/htmlParse.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Dimensions=require('Dimensions');


var htmlParse=require('react-native-html-render/lib/htmlParse.js');var _Dimensions$get=


Dimensions.get('window');var height=_Dimensions$get.height;var width=_Dimensions$get.width;var 



StyleSheet=








React.StyleSheet;var Text=React.Text;var View=React.View;var Component=React.Component;var Image=React.Image;var ScrollView=React.ScrollView;var TouchableHighlight=React.TouchableHighlight;var TouchableOpacity=React.TouchableOpacity;var LinkingIOS=React.LinkingIOS;


function rendCodeBlock(codeText,styles){
var codeLines=codeText.split('\n');
return codeLines.map(function(line,index,arr){
var lineNum=index + 1;
if(line == '')line = '\n';
if(index == codeLines.length - 1)return null;
return (
React.createElement(View,{key:'codeRow' + index,style:styles.codeRow},
React.createElement(View,{style:styles.lineNumWrapper},
React.createElement(Text,{style:styles.lineNum},
lineNum + '.')),



React.createElement(View,{style:styles.codeLineWrapper},
React.createElement(Text,{style:styles.codeLine},
line))));});}







function getCodeRowStyle(num,length,styles){
if(num == 1 && length == num){
return [styles.codeRow,styles.codeFirstAndLastRow];}


if(num == 1){
return [styles.codeRow,styles.codeFirstRow];}

if(num == length){
return [styles.codeRow,styles.codeLastRow];}


return styles.codeRow;}



var htmlToElement=function(rawHtml,opts,done){
var styles=opts.styles;

function domToElement(dom,parent,type){var _this=this;
if(!dom)return null;

return dom.map(function(node,index,list){
if(opts.customRenderer){
var rendered=opts.customRenderer(node,index,parent,type);
if(rendered || rendered === null)return rendered;}






var name=node.name;


if(name == 'text' && type == 'inline'){
return (
React.createElement(Text,{key:index,style:styles[parent.name]},
node.text));}




if(node.type == 'inline' && type == 'block')return null;

if(node.type == 'inline'){
uri = node.attribs.href;
if(name == 'a'){
return (
React.createElement(Text,{
onPress:opts.linkHandler.bind(_this,uri),
key:index,style:styles[name]},
domToElement(node.children,node,'inline')));}




return (
React.createElement(Text,{key:index,style:styles[name]},
domToElement(node.children,node,'inline')));}




if(node.type == 'block' && type == 'block'){
if(name == 'img'){
var uri=node.attribs.src;
return (
React.createElement(View,{
key:index,
style:styles.imgWrapper},
React.createElement(Image,{source:{uri:uri},
style:styles.img})));}






if(name == 'code'){
var codeText='';

node.children.forEach(function(code){
codeText = codeText + code.text;});

return (
React.createElement(ScrollView,{
style:styles.codeScrollView,
horizontal:true},
React.createElement(View,{style:styles.codeWrapper},
rendCodeBlock(codeText,styles))));}






return (
React.createElement(View,{key:index,style:styles[name + 'wrapper']},
React.createElement(Text,null,
domToElement(node.children,node,'inline')),

React.createElement(View,{style:styles[name + 'InnerWrapper']},
domToElement(node.children,node,'block'))));}});}








htmlParse(rawHtml,function(dom){
done(null,domToElement(dom,null,'block'));});};var 




HtmlView=(function(_Component){_inherits(HtmlView,_Component);
function HtmlView(props){_classCallCheck(this,HtmlView);
_get(Object.getPrototypeOf(HtmlView.prototype),'constructor',this).call(this,props);
this.state = {
element:null};}_createClass(HtmlView,[{key:'componentWillReceiveProps',value:



function componentWillReceiveProps(){
if(this.state.element)return;
this.startHtmlRender();}},{key:'componentDidMount',value:


function componentDidMount(){
this.startHtmlRender();}},{key:'startHtmlRender',value:


function startHtmlRender(){var _this2=this;
if(!this.props.value)return;
if(this.renderingHtml)return;

var opts={
linkHandler:this.props.onLinkPress,
styles:Object.assign({},baseStyles,this.props.stylesheet),
customRenderer:this.props.renderNode};


this.renderingHtml = true;
htmlToElement(this.props.value,opts,function(err,element){
_this2.renderingHtml = false;

if(err)return (_this2.props.onError || console.error)(err);
_this2.setState({
element:element});});}},{key:'render',value:




function render(){
if(this.state.element){
return React.createElement(View,{children:this.state.element,style:{flex:1}});}

return React.createElement(View,null);}}]);return HtmlView;})(Component);



var fontSize=16;
var titleMargin=15;
var liFontSize=fontSize - 2;

var baseStyles=StyleSheet.create({
img:{
width:width - 30,
height:width - 30,
resizeMode:Image.resizeMode.contain},






p:{
lineHeight:fontSize * 1.5,
fontSize:fontSize,


paddingTop:5,
paddingBottom:5,
color:'rgba(0,0,0,0.8)'},

pwrapper:{
marginTop:15,
marginBottom:15},


a:{
color:'#3498DB',
fontSize:fontSize,
paddingLeft:4,
paddingRight:4,
marginRight:10,
marginLeft:10,
fontFamily:'Courier'},


h1:{
fontSize:fontSize * 1.6,
fontWeight:'bold',
color:'rgba(0,0,0,0.8)'},

h1wrapper:{
marginTop:titleMargin,
marginBottom:titleMargin},

h2:{
fontSize:fontSize * 1.5,
fontWeight:'bold',
color:'rgba(0,0,0,0.85)'},

h2wrapper:{
marginBottom:titleMargin,
marginTop:titleMargin},

h3:{
fontWeight:'bold',
fontSize:fontSize * 1.4,
color:'rgba(0,0,0,0.8)'},

h3wrapper:{
marginBottom:titleMargin - 2,
marginTop:titleMargin - 2},

h4:{
fontSize:fontSize * 1.3,
color:'rgba(0,0,0,0.7)',
fontWeight:'bold'},

h4wrapper:{
marginBottom:titleMargin - 2,
marginTop:titleMargin - 2},

h5:{
fontSize:fontSize * 1.2,
color:'rgba(0,0,0,0.7)',
fontWeight:'bold'},

h5wrapper:{
marginBottom:titleMargin - 3,
marginTop:titleMargin - 3},

h6:{
fontSize:fontSize * 1.1,
color:'rgba(0,0,0,0.7)',
fontWeight:'bold'},

h6wrapper:{
marginBottom:titleMargin - 3,
marginTop:titleMargin - 3},

li:{
fontSize:fontSize * 0.9,
color:'rgba(0,0,0,0.7)'},

liwrapper:{
paddingLeft:20,
marginBottom:10},

strong:{
fontWeight:'bold'},

em:{
fontStyle:'italic'},

code:{
color:'#E74C3C',
paddingLeft:5,
paddingRight:5,
fontFamily:'Courier'},


codeScrollView:{




backgroundColor:'#333',
flexDirection:'column',
marginBottom:15},

codeRow:{
flex:1,
flexDirection:'row',
height:25,
alignItems:'center'},

codeFirstRow:{
paddingTop:20,
height:25 + 20},

codeLastRow:{
paddingBottom:20,
height:25 + 20},

codeFirstAndLastRow:{
paddingBottom:20,
height:25 + 40,
paddingTop:20},

lineNum:{
width:55,
color:'rgba(255,255,255,0.5)'},



lineNumWrapper:{
width:55,
height:25,
backgroundColor:'rgba(0,0,0,0.1)',
flexDirection:'row',
alignItems:'center',
paddingLeft:20},


codeLine:{
color:'#E74C3C',
fontFamily:'Courier'},

codeWrapper:{
flexDirection:'column'},

codeLineWrapper:{
height:25,

flexDirection:'row',
alignItems:'center',
paddingLeft:20,
paddingRight:20},

blockquotewrapper:{
paddingLeft:20,
borderLeftColor:'#3498DB',
borderLeftWidth:3}});



module.exports = HtmlView;
});
__d('react-native-html-render/lib/htmlParse.js',["react-native-html-render/lib/htmlparser2.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var htmlparser=require('react-native-html-render/lib/htmlparser2.js');


var blockTagArr=['div','p','img','address',
'blockquote','dir','dl',
'form','h1','h2','h3','h4','h5','h6',
'menu','ol','pre','table','ul','li','hr'];

var inlineTagArr=['a','abbr','b','big',
'br','cite','code','em','label','span','strong'];


function indexOf(item,arr){
for(var i=0;i < arr.length;i++) {
if(item == arr[i])return true;}

return false;}


function pushText(parent,text){
if(!parent.children)parent.children = [];
parent.children.push({
name:'text',
text:text,
parent:parent,
type:'inline'});}




var parseHtml=function(html,done){



var rootStack=[{
name:'div',
type:'block'}];

var tagStack=[rootStack[0]];

var opts={
recognizeSelfClosing:true,
lowerCaseAttributeNames:true,
lowerCaseTags:true,
decodeEntities:true};


var parser=new htmlparser.Parser({
onopentag:function(name,attribs){



var parent=tagStack[tagStack.length - 1];
if(!parent.children)parent.children = [];

if(indexOf(name,blockTagArr) == 1){
parent.children.push({
name:name,
attribs:attribs,
type:'block',
parent:parent});

tagStack.push(parent.children[parent.children.length - 1]);}else 

{
var type='inline';
if(parent.name == 'pre')type = 'block';


parent.children.push({
name:name,
attribs:attribs,
type:type,
parent:parent});

tagStack.push(parent.children[parent.children.length - 1]);}},


ontext:function(text){
if(text == '\n')return;
var parent=tagStack[tagStack.length - 1];
if(!parent.children)parent.children = [];

parent.children.push({
name:'text',
text:text,
parent:parent,
type:'inline'});},


onclosetag:function(name){
tagStack.pop();},

onend:function(){
done(rootStack[0].children);
var endTime=new Date().getDate();}},


opts);

parser.write(html);
parser.end();};



module.exports = parseHtml;
});
__d('react-native-html-render/lib/htmlparser2.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  (function(f){
if(typeof exports === "object" && typeof module !== "undefined"){
module.exports = f();}else 
if(typeof define === "function" && define.amd){
define([],f);}else 
{
var g;
if(typeof window !== "undefined"){
g = window;}else 
if(typeof global !== "undefined"){
g = global;}else 
if(typeof self !== "undefined"){
g = self;}else 
{
g = this;}

g.htmlparser2 = f();}})(

function(){
var define,module,exports;
return (function e(t,n,r){
function s(o,u){
if(!n[o]){
if(!t[o]){
var a=typeof require == "function" && require;
if(!u && a)return a(o,!0);
if(i)return i(o,!0);
var f=new Error("Cannot find module '" + o + "'");
throw (f.code = "MODULE_NOT_FOUND",f);}

var l=n[o] = {exports:{}};
t[o][0].call(l.exports,function(e){
var n=t[o][1][e];
return s(n?n:e);},
l,l.exports,e,t,n,r);}

return n[o].exports;}


var i=typeof require == "function" && require;
for(var o=0;o < r.length;o++) s(r[o]);
return s;})(
{
1:[function(_dereq_,module,exports){
module.exports = CollectingHandler;

function CollectingHandler(cbs){
this._cbs = cbs || {};
this.events = [];}


var EVENTS=_dereq_("./").EVENTS;
Object.keys(EVENTS).forEach(function(name){
if(EVENTS[name] === 0){
name = "on" + name;
CollectingHandler.prototype[name] = function(){
this.events.push([name]);
if(this._cbs[name])this._cbs[name]();};}else 

if(EVENTS[name] === 1){
name = "on" + name;
CollectingHandler.prototype[name] = function(a){
this.events.push([name,a]);
if(this._cbs[name])this._cbs[name](a);};}else 

if(EVENTS[name] === 2){
name = "on" + name;
CollectingHandler.prototype[name] = function(a,b){
this.events.push([name,a,b]);
if(this._cbs[name])this._cbs[name](a,b);};}else 

{
throw Error("wrong number of arguments");}});



CollectingHandler.prototype.onreset = function(){
this.events = [];
if(this._cbs.onreset)this._cbs.onreset();};


CollectingHandler.prototype.restart = function(){
if(this._cbs.onreset)this._cbs.onreset();

for(var i=0,len=this.events.length;i < len;i++) {
if(this._cbs[this.events[i][0]]){

var num=this.events[i].length;

if(num === 1){
this._cbs[this.events[i][0]]();}else 
if(num === 2){
this._cbs[this.events[i][0]](this.events[i][1]);}else 
{
this._cbs[this.events[i][0]](this.events[i][1],this.events[i][2]);}}}};},





{"./":"htmlparser2"}],
2:[function(_dereq_,module,exports){
var index=_dereq_("./index.js"),
DomHandler=index.DomHandler,
DomUtils=index.DomUtils;


function FeedHandler(callback,options){
this.init(callback,options);}


_dereq_("util").inherits(FeedHandler,DomHandler);

FeedHandler.prototype.init = DomHandler;

function getElements(what,where){
return DomUtils.getElementsByTagName(what,where,true);}


function getOneElement(what,where){
return DomUtils.getElementsByTagName(what,where,true,1)[0];}


function fetch(what,where,recurse){
return DomUtils.getText(
DomUtils.getElementsByTagName(what,where,recurse,1)).
trim();}


function addConditionally(obj,prop,what,where,recurse){
var tmp=fetch(what,where,recurse);
if(tmp)obj[prop] = tmp;}


var isValidFeed=function(value){
return value === "rss" || value === "feed" || value === "rdf:RDF";};


FeedHandler.prototype.onend = function(){
var feed={},
feedRoot=getOneElement(isValidFeed,this.dom),
tmp,childs;

if(feedRoot){
if(feedRoot.name === "feed"){
childs = feedRoot.children;

feed.type = "atom";
addConditionally(feed,"id","id",childs);
addConditionally(feed,"title","title",childs);
if((tmp = getOneElement("link",childs)) && (tmp = tmp.attribs) && (tmp = tmp.href))feed.link = tmp;
addConditionally(feed,"description","subtitle",childs);
if(tmp = fetch("updated",childs))feed.updated = new Date(tmp);
addConditionally(feed,"author","email",childs,true);

feed.items = getElements("entry",childs).map(function(item){
var entry={},tmp;

item = item.children;

addConditionally(entry,"id","id",item);
addConditionally(entry,"title","title",item);
if((tmp = getOneElement("link",item)) && (tmp = tmp.attribs) && (tmp = tmp.href))entry.link = tmp;
if(tmp = fetch("summary",item) || fetch("content",item))entry.description = tmp;
if(tmp = fetch("updated",item))entry.pubDate = new Date(tmp);
return entry;});}else 

{
childs = getOneElement("channel",feedRoot.children).children;

feed.type = feedRoot.name.substr(0,3);
feed.id = "";
addConditionally(feed,"title","title",childs);
addConditionally(feed,"link","link",childs);
addConditionally(feed,"description","description",childs);
if(tmp = fetch("lastBuildDate",childs))feed.updated = new Date(tmp);
addConditionally(feed,"author","managingEditor",childs,true);

feed.items = getElements("item",feedRoot.children).map(function(item){
var entry={},tmp;

item = item.children;

addConditionally(entry,"id","guid",item);
addConditionally(entry,"title","title",item);
addConditionally(entry,"link","link",item);
addConditionally(entry,"description","description",item);
if(tmp = fetch("pubDate",item))entry.pubDate = new Date(tmp);
return entry;});}}



this.dom = feed;
DomHandler.prototype._handleCallback.call(
this,feedRoot?null:Error("couldn't find root of feed"));};



module.exports = FeedHandler;},

{"./index.js":"htmlparser2","util":57}],
3:[function(_dereq_,module,exports){
var Tokenizer=_dereq_("./Tokenizer.js");
























var formTags={
input:true,
option:true,
optgroup:true,
select:true,
button:true,
datalist:true,
textarea:true};


var openImpliesClose={
tr:{tr:true,th:true,td:true},
th:{th:true},
td:{thead:true,td:true},
body:{head:true,link:true,script:true},
li:{li:true},
p:{p:true},
h1:{p:true},
h2:{p:true},
h3:{p:true},
h4:{p:true},
h5:{p:true},
h6:{p:true},
select:formTags,
input:formTags,
output:formTags,
button:formTags,
datalist:formTags,
textarea:formTags,
option:{option:true},
optgroup:{optgroup:true}};


var voidElements={
__proto__:null,
area:true,
base:true,
basefont:true,
br:true,
col:true,
command:true,
embed:true,
frame:true,
hr:true,
img:true,
input:true,
isindex:true,
keygen:true,
link:true,
meta:true,
param:true,
source:true,
track:true,
wbr:true,


path:true,
circle:true,
ellipse:true,
line:true,
rect:true,
use:true,
stop:true,
polyline:true,
polygone:true};


var re_nameEnd=/\s|\//;

function Parser(cbs,options){
this._options = options || {};
this._cbs = cbs || {};

this._tagname = "";
this._attribname = "";
this._attribvalue = "";
this._attribs = null;
this._stack = [];

this.startIndex = 0;
this.endIndex = null;

this._lowerCaseTagNames = "lowerCaseTags" in this._options?
!!this._options.lowerCaseTags:
!this._options.xmlMode;
this._lowerCaseAttributeNames = "lowerCaseAttributeNames" in this._options?
!!this._options.lowerCaseAttributeNames:
!this._options.xmlMode;

this._tokenizer = new Tokenizer(this._options,this);

if(this._cbs.onparserinit)this._cbs.onparserinit(this);}


_dereq_("util").inherits(Parser,_dereq_("events").EventEmitter);

Parser.prototype._updatePosition = function(initialOffset){
if(this.endIndex === null){
if(this._tokenizer._sectionStart <= initialOffset){
this.startIndex = 0;}else 
{
this.startIndex = this._tokenizer._sectionStart - initialOffset;}}else 


this.startIndex = this.endIndex + 1;
this.endIndex = this._tokenizer.getAbsoluteIndex();};



Parser.prototype.ontext = function(data){
this._updatePosition(1);
this.endIndex--;

if(this._cbs.ontext)this._cbs.ontext(data);};


Parser.prototype.onopentagname = function(name){
if(this._lowerCaseTagNames){
name = name.toLowerCase();}


this._tagname = name;

if(!this._options.xmlMode && name in openImpliesClose){
for(
var el;(
(el = this._stack[this._stack.length - 1]) in openImpliesClose[name]);
this.onclosetag(el));}



if(this._options.xmlMode || !(name in voidElements)){
this._stack.push(name);}


if(this._cbs.onopentagname)this._cbs.onopentagname(name);
if(this._cbs.onopentag)this._attribs = {};};


Parser.prototype.onopentagend = function(){
this._updatePosition(1);

if(this._attribs){
if(this._cbs.onopentag)this._cbs.onopentag(this._tagname,this._attribs);
this._attribs = null;}


if(!this._options.xmlMode && this._cbs.onclosetag && this._tagname in voidElements){
this._cbs.onclosetag(this._tagname);}


this._tagname = "";};


Parser.prototype.onclosetag = function(name){
this._updatePosition(1);

if(this._lowerCaseTagNames){
name = name.toLowerCase();}


if(this._stack.length && (!(name in voidElements) || this._options.xmlMode)){
var pos=this._stack.lastIndexOf(name);
if(pos !== -1){
if(this._cbs.onclosetag){
pos = this._stack.length - pos;
while(pos--) this._cbs.onclosetag(this._stack.pop());}else 

this._stack.length = pos;}else 
if(name === "p" && !this._options.xmlMode){
this.onopentagname(name);
this._closeCurrentTag();}}else 

if(!this._options.xmlMode && (name === "br" || name === "p")){
this.onopentagname(name);
this._closeCurrentTag();}};



Parser.prototype.onselfclosingtag = function(){
if(this._options.xmlMode || this._options.recognizeSelfClosing){
this._closeCurrentTag();}else 
{
this.onopentagend();}};



Parser.prototype._closeCurrentTag = function(){
var name=this._tagname;

this.onopentagend();



if(this._stack[this._stack.length - 1] === name){
if(this._cbs.onclosetag){
this._cbs.onclosetag(name);}

this._stack.pop();}};



Parser.prototype.onattribname = function(name){
if(this._lowerCaseAttributeNames){
name = name.toLowerCase();}

this._attribname = name;};


Parser.prototype.onattribdata = function(value){
this._attribvalue += value;};


Parser.prototype.onattribend = function(){
if(this._cbs.onattribute)this._cbs.onattribute(this._attribname,this._attribvalue);
if(
this._attribs && !Object.prototype.hasOwnProperty.call(this._attribs,this._attribname))
{
this._attribs[this._attribname] = this._attribvalue;}

this._attribname = "";
this._attribvalue = "";};


Parser.prototype._getInstructionName = function(value){
var idx=value.search(re_nameEnd),
name=idx < 0?value:value.substr(0,idx);

if(this._lowerCaseTagNames){
name = name.toLowerCase();}


return name;};


Parser.prototype.ondeclaration = function(value){
if(this._cbs.onprocessinginstruction){
var name=this._getInstructionName(value);
this._cbs.onprocessinginstruction("!" + name,"!" + value);}};



Parser.prototype.onprocessinginstruction = function(value){
if(this._cbs.onprocessinginstruction){
var name=this._getInstructionName(value);
this._cbs.onprocessinginstruction("?" + name,"?" + value);}};



Parser.prototype.oncomment = function(value){
this._updatePosition(4);

if(this._cbs.oncomment)this._cbs.oncomment(value);
if(this._cbs.oncommentend)this._cbs.oncommentend();};


Parser.prototype.oncdata = function(value){
this._updatePosition(1);

if(this._options.xmlMode || this._options.recognizeCDATA){
if(this._cbs.oncdatastart)this._cbs.oncdatastart();
if(this._cbs.ontext)this._cbs.ontext(value);
if(this._cbs.oncdataend)this._cbs.oncdataend();}else 
{
this.oncomment("[CDATA[" + value + "]]");}};



Parser.prototype.onerror = function(err){
if(this._cbs.onerror)this._cbs.onerror(err);};


Parser.prototype.onend = function(){
if(this._cbs.onclosetag){
for(
var i=this._stack.length;
i > 0;
this._cbs.onclosetag(this._stack[--i]));}


if(this._cbs.onend)this._cbs.onend();};




Parser.prototype.reset = function(){
if(this._cbs.onreset)this._cbs.onreset();
this._tokenizer.reset();

this._tagname = "";
this._attribname = "";
this._attribs = null;
this._stack = [];

if(this._cbs.onparserinit)this._cbs.onparserinit(this);};



Parser.prototype.parseComplete = function(data){
this.reset();
this.end(data);};


Parser.prototype.write = function(chunk){
this._tokenizer.write(chunk);};


Parser.prototype.end = function(chunk){
this._tokenizer.end(chunk);};


Parser.prototype.pause = function(){
this._tokenizer.pause();};


Parser.prototype.resume = function(){
this._tokenizer.resume();};



Parser.prototype.parseChunk = Parser.prototype.write;
Parser.prototype.done = Parser.prototype.end;

module.exports = Parser;},

{"./Tokenizer.js":6,"events":39,"util":57}],
4:[function(_dereq_,module,exports){
module.exports = ProxyHandler;

function ProxyHandler(cbs){
this._cbs = cbs || {};}


var EVENTS=_dereq_("./").EVENTS;
Object.keys(EVENTS).forEach(function(name){
if(EVENTS[name] === 0){
name = "on" + name;
ProxyHandler.prototype[name] = function(){
if(this._cbs[name])this._cbs[name]();};}else 

if(EVENTS[name] === 1){
name = "on" + name;
ProxyHandler.prototype[name] = function(a){
if(this._cbs[name])this._cbs[name](a);};}else 

if(EVENTS[name] === 2){
name = "on" + name;
ProxyHandler.prototype[name] = function(a,b){
if(this._cbs[name])this._cbs[name](a,b);};}else 

{
throw Error("wrong number of arguments");}});},


{"./":"htmlparser2"}],
5:[function(_dereq_,module,exports){
module.exports = Stream;

var Parser=_dereq_("./WritableStream.js");

function Stream(options){
Parser.call(this,new Cbs(this),options);}


_dereq_("util").inherits(Stream,Parser);

Stream.prototype.readable = true;

function Cbs(scope){
this.scope = scope;}


var EVENTS=_dereq_("../").EVENTS;

Object.keys(EVENTS).forEach(function(name){
if(EVENTS[name] === 0){
Cbs.prototype["on" + name] = function(){
this.scope.emit(name);};}else 

if(EVENTS[name] === 1){
Cbs.prototype["on" + name] = function(a){
this.scope.emit(name,a);};}else 

if(EVENTS[name] === 2){
Cbs.prototype["on" + name] = function(a,b){
this.scope.emit(name,a,b);};}else 

{
throw Error("wrong number of arguments!");}});},


{"../":"htmlparser2","./WritableStream.js":7,"util":57}],
6:[function(_dereq_,module,exports){
module.exports = Tokenizer;

var decodeCodePoint=_dereq_("entities/lib/decode_codepoint.js"),
entityMap=_dereq_("entities/maps/entities.json"),
legacyMap=_dereq_("entities/maps/legacy.json"),
xmlMap=_dereq_("entities/maps/xml.json"),

i=0,

TEXT=i++,
BEFORE_TAG_NAME=i++,
IN_TAG_NAME=i++,
IN_SELF_CLOSING_TAG=i++,
BEFORE_CLOSING_TAG_NAME=i++,
IN_CLOSING_TAG_NAME=i++,
AFTER_CLOSING_TAG_NAME=i++,


BEFORE_ATTRIBUTE_NAME=i++,
IN_ATTRIBUTE_NAME=i++,
AFTER_ATTRIBUTE_NAME=i++,
BEFORE_ATTRIBUTE_VALUE=i++,
IN_ATTRIBUTE_VALUE_DQ=i++,
IN_ATTRIBUTE_VALUE_SQ=i++,
IN_ATTRIBUTE_VALUE_NQ=i++,


BEFORE_DECLARATION=i++,
IN_DECLARATION=i++,


IN_PROCESSING_INSTRUCTION=i++,


BEFORE_COMMENT=i++,
IN_COMMENT=i++,
AFTER_COMMENT_1=i++,
AFTER_COMMENT_2=i++,


BEFORE_CDATA_1=i++,
BEFORE_CDATA_2=i++,
BEFORE_CDATA_3=i++,
BEFORE_CDATA_4=i++,
BEFORE_CDATA_5=i++,
BEFORE_CDATA_6=i++,
IN_CDATA=i++,
AFTER_CDATA_1=i++,
AFTER_CDATA_2=i++,


BEFORE_SPECIAL=i++,
BEFORE_SPECIAL_END=i++,

BEFORE_SCRIPT_1=i++,
BEFORE_SCRIPT_2=i++,
BEFORE_SCRIPT_3=i++,
BEFORE_SCRIPT_4=i++,
BEFORE_SCRIPT_5=i++,
AFTER_SCRIPT_1=i++,
AFTER_SCRIPT_2=i++,
AFTER_SCRIPT_3=i++,
AFTER_SCRIPT_4=i++,
AFTER_SCRIPT_5=i++,

BEFORE_STYLE_1=i++,
BEFORE_STYLE_2=i++,
BEFORE_STYLE_3=i++,
BEFORE_STYLE_4=i++,
AFTER_STYLE_1=i++,
AFTER_STYLE_2=i++,
AFTER_STYLE_3=i++,
AFTER_STYLE_4=i++,

BEFORE_ENTITY=i++,
BEFORE_NUMERIC_ENTITY=i++,
IN_NAMED_ENTITY=i++,
IN_NUMERIC_ENTITY=i++,
IN_HEX_ENTITY=i++,

j=0,

SPECIAL_NONE=j++,
SPECIAL_SCRIPT=j++,
SPECIAL_STYLE=j++;

function whitespace(c){
return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r";}


function characterState(char,SUCCESS){
return function(c){
if(c === char)this._state = SUCCESS;};}



function ifElseState(upper,SUCCESS,FAILURE){
var lower=upper.toLowerCase();

if(upper === lower){
return function(c){
if(c === lower){
this._state = SUCCESS;}else 
{
this._state = FAILURE;
this._index--;}};}else 


{
return function(c){
if(c === lower || c === upper){
this._state = SUCCESS;}else 
{
this._state = FAILURE;
this._index--;}};}}





function consumeSpecialNameChar(upper,NEXT_STATE){
var lower=upper.toLowerCase();

return function(c){
if(c === lower || c === upper){
this._state = NEXT_STATE;}else 
{
this._state = IN_TAG_NAME;
this._index--;}};}




function Tokenizer(options,cbs){
this._state = TEXT;
this._buffer = "";
this._sectionStart = 0;
this._index = 0;
this._bufferOffset = 0;
this._baseState = TEXT;
this._special = SPECIAL_NONE;
this._cbs = cbs;
this._running = true;
this._ended = false;
this._xmlMode = !!(options && options.xmlMode);
this._decodeEntities = !!(options && options.decodeEntities);}


Tokenizer.prototype._stateText = function(c){
if(c === "<"){
if(this._index > this._sectionStart){
this._cbs.ontext(this._getSection());}

this._state = BEFORE_TAG_NAME;
this._sectionStart = this._index;}else 
if(this._decodeEntities && this._special === SPECIAL_NONE && c === "&"){
if(this._index > this._sectionStart){
this._cbs.ontext(this._getSection());}

this._baseState = TEXT;
this._state = BEFORE_ENTITY;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateBeforeTagName = function(c){
if(c === "/"){
this._state = BEFORE_CLOSING_TAG_NAME;}else 
if(c === ">" || this._special !== SPECIAL_NONE || whitespace(c)){
this._state = TEXT;}else 
if(c === "!"){
this._state = BEFORE_DECLARATION;
this._sectionStart = this._index + 1;}else 
if(c === "?"){
this._state = IN_PROCESSING_INSTRUCTION;
this._sectionStart = this._index + 1;}else 
if(c === "<"){
this._cbs.ontext(this._getSection());
this._sectionStart = this._index;}else 
{
this._state = !this._xmlMode && (c === "s" || c === "S")?
BEFORE_SPECIAL:IN_TAG_NAME;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateInTagName = function(c){
if(c === "/" || c === ">" || whitespace(c)){
this._emitToken("onopentagname");
this._state = BEFORE_ATTRIBUTE_NAME;
this._index--;}};



Tokenizer.prototype._stateBeforeCloseingTagName = function(c){
if(whitespace(c));else 
if(c === ">"){
this._state = TEXT;}else 
if(this._special !== SPECIAL_NONE){
if(c === "s" || c === "S"){
this._state = BEFORE_SPECIAL_END;}else 
{
this._state = TEXT;
this._index--;}}else 

{
this._state = IN_CLOSING_TAG_NAME;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateInCloseingTagName = function(c){
if(c === ">" || whitespace(c)){
this._emitToken("onclosetag");
this._state = AFTER_CLOSING_TAG_NAME;
this._index--;}};



Tokenizer.prototype._stateAfterCloseingTagName = function(c){

if(c === ">"){
this._state = TEXT;
this._sectionStart = this._index + 1;}};



Tokenizer.prototype._stateBeforeAttributeName = function(c){
if(c === ">"){
this._cbs.onopentagend();
this._state = TEXT;
this._sectionStart = this._index + 1;}else 
if(c === "/"){
this._state = IN_SELF_CLOSING_TAG;}else 
if(!whitespace(c)){
this._state = IN_ATTRIBUTE_NAME;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateInSelfClosingTag = function(c){
if(c === ">"){
this._cbs.onselfclosingtag();
this._state = TEXT;
this._sectionStart = this._index + 1;}else 
if(!whitespace(c)){
this._state = BEFORE_ATTRIBUTE_NAME;
this._index--;}};



Tokenizer.prototype._stateInAttributeName = function(c){
if(c === "=" || c === "/" || c === ">" || whitespace(c)){
this._cbs.onattribname(this._getSection());
this._sectionStart = -1;
this._state = AFTER_ATTRIBUTE_NAME;
this._index--;}};



Tokenizer.prototype._stateAfterAttributeName = function(c){
if(c === "="){
this._state = BEFORE_ATTRIBUTE_VALUE;}else 
if(c === "/" || c === ">"){
this._cbs.onattribend();
this._state = BEFORE_ATTRIBUTE_NAME;
this._index--;}else 
if(!whitespace(c)){
this._cbs.onattribend();
this._state = IN_ATTRIBUTE_NAME;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateBeforeAttributeValue = function(c){
if(c === "\""){
this._state = IN_ATTRIBUTE_VALUE_DQ;
this._sectionStart = this._index + 1;}else 
if(c === "'"){
this._state = IN_ATTRIBUTE_VALUE_SQ;
this._sectionStart = this._index + 1;}else 
if(!whitespace(c)){
this._state = IN_ATTRIBUTE_VALUE_NQ;
this._sectionStart = this._index;
this._index--;}};



Tokenizer.prototype._stateInAttributeValueDoubleQuotes = function(c){
if(c === "\""){
this._emitToken("onattribdata");
this._cbs.onattribend();
this._state = BEFORE_ATTRIBUTE_NAME;}else 
if(this._decodeEntities && c === "&"){
this._emitToken("onattribdata");
this._baseState = this._state;
this._state = BEFORE_ENTITY;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateInAttributeValueSingleQuotes = function(c){
if(c === "'"){
this._emitToken("onattribdata");
this._cbs.onattribend();
this._state = BEFORE_ATTRIBUTE_NAME;}else 
if(this._decodeEntities && c === "&"){
this._emitToken("onattribdata");
this._baseState = this._state;
this._state = BEFORE_ENTITY;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateInAttributeValueNoQuotes = function(c){
if(whitespace(c) || c === ">"){
this._emitToken("onattribdata");
this._cbs.onattribend();
this._state = BEFORE_ATTRIBUTE_NAME;
this._index--;}else 
if(this._decodeEntities && c === "&"){
this._emitToken("onattribdata");
this._baseState = this._state;
this._state = BEFORE_ENTITY;
this._sectionStart = this._index;}};



Tokenizer.prototype._stateBeforeDeclaration = function(c){
this._state = c === "["?BEFORE_CDATA_1:
c === "-"?BEFORE_COMMENT:
IN_DECLARATION;};


Tokenizer.prototype._stateInDeclaration = function(c){
if(c === ">"){
this._cbs.ondeclaration(this._getSection());
this._state = TEXT;
this._sectionStart = this._index + 1;}};



Tokenizer.prototype._stateInProcessingInstruction = function(c){
if(c === ">"){
this._cbs.onprocessinginstruction(this._getSection());
this._state = TEXT;
this._sectionStart = this._index + 1;}};



Tokenizer.prototype._stateBeforeComment = function(c){
if(c === "-"){
this._state = IN_COMMENT;
this._sectionStart = this._index + 1;}else 
{
this._state = IN_DECLARATION;}};



Tokenizer.prototype._stateInComment = function(c){
if(c === "-")this._state = AFTER_COMMENT_1;};


Tokenizer.prototype._stateAfterComment1 = function(c){
if(c === "-"){
this._state = AFTER_COMMENT_2;}else 
{
this._state = IN_COMMENT;}};



Tokenizer.prototype._stateAfterComment2 = function(c){
if(c === ">"){

this._cbs.oncomment(this._buffer.substring(this._sectionStart,this._index - 2));
this._state = TEXT;
this._sectionStart = this._index + 1;}else 
if(c !== "-"){
this._state = IN_COMMENT;}};




Tokenizer.prototype._stateBeforeCdata1 = ifElseState("C",BEFORE_CDATA_2,IN_DECLARATION);
Tokenizer.prototype._stateBeforeCdata2 = ifElseState("D",BEFORE_CDATA_3,IN_DECLARATION);
Tokenizer.prototype._stateBeforeCdata3 = ifElseState("A",BEFORE_CDATA_4,IN_DECLARATION);
Tokenizer.prototype._stateBeforeCdata4 = ifElseState("T",BEFORE_CDATA_5,IN_DECLARATION);
Tokenizer.prototype._stateBeforeCdata5 = ifElseState("A",BEFORE_CDATA_6,IN_DECLARATION);

Tokenizer.prototype._stateBeforeCdata6 = function(c){
if(c === "["){
this._state = IN_CDATA;
this._sectionStart = this._index + 1;}else 
{
this._state = IN_DECLARATION;
this._index--;}};



Tokenizer.prototype._stateInCdata = function(c){
if(c === "]")this._state = AFTER_CDATA_1;};


Tokenizer.prototype._stateAfterCdata1 = characterState("]",AFTER_CDATA_2);

Tokenizer.prototype._stateAfterCdata2 = function(c){
if(c === ">"){

this._cbs.oncdata(this._buffer.substring(this._sectionStart,this._index - 2));
this._state = TEXT;
this._sectionStart = this._index + 1;}else 
if(c !== "]"){
this._state = IN_CDATA;}};




Tokenizer.prototype._stateBeforeSpecial = function(c){
if(c === "c" || c === "C"){
this._state = BEFORE_SCRIPT_1;}else 
if(c === "t" || c === "T"){
this._state = BEFORE_STYLE_1;}else 
{
this._state = IN_TAG_NAME;
this._index--;}};



Tokenizer.prototype._stateBeforeSpecialEnd = function(c){
if(this._special === SPECIAL_SCRIPT && (c === "c" || c === "C")){
this._state = AFTER_SCRIPT_1;}else 
if(this._special === SPECIAL_STYLE && (c === "t" || c === "T")){
this._state = AFTER_STYLE_1;}else 

this._state = TEXT;};


Tokenizer.prototype._stateBeforeScript1 = consumeSpecialNameChar("R",BEFORE_SCRIPT_2);
Tokenizer.prototype._stateBeforeScript2 = consumeSpecialNameChar("I",BEFORE_SCRIPT_3);
Tokenizer.prototype._stateBeforeScript3 = consumeSpecialNameChar("P",BEFORE_SCRIPT_4);
Tokenizer.prototype._stateBeforeScript4 = consumeSpecialNameChar("T",BEFORE_SCRIPT_5);

Tokenizer.prototype._stateBeforeScript5 = function(c){
if(c === "/" || c === ">" || whitespace(c)){
this._special = SPECIAL_SCRIPT;}

this._state = IN_TAG_NAME;
this._index--;};


Tokenizer.prototype._stateAfterScript1 = ifElseState("R",AFTER_SCRIPT_2,TEXT);
Tokenizer.prototype._stateAfterScript2 = ifElseState("I",AFTER_SCRIPT_3,TEXT);
Tokenizer.prototype._stateAfterScript3 = ifElseState("P",AFTER_SCRIPT_4,TEXT);
Tokenizer.prototype._stateAfterScript4 = ifElseState("T",AFTER_SCRIPT_5,TEXT);

Tokenizer.prototype._stateAfterScript5 = function(c){
if(c === ">" || whitespace(c)){
this._special = SPECIAL_NONE;
this._state = IN_CLOSING_TAG_NAME;
this._sectionStart = this._index - 6;
this._index--;}else 

this._state = TEXT;};


Tokenizer.prototype._stateBeforeStyle1 = consumeSpecialNameChar("Y",BEFORE_STYLE_2);
Tokenizer.prototype._stateBeforeStyle2 = consumeSpecialNameChar("L",BEFORE_STYLE_3);
Tokenizer.prototype._stateBeforeStyle3 = consumeSpecialNameChar("E",BEFORE_STYLE_4);

Tokenizer.prototype._stateBeforeStyle4 = function(c){
if(c === "/" || c === ">" || whitespace(c)){
this._special = SPECIAL_STYLE;}

this._state = IN_TAG_NAME;
this._index--;};


Tokenizer.prototype._stateAfterStyle1 = ifElseState("Y",AFTER_STYLE_2,TEXT);
Tokenizer.prototype._stateAfterStyle2 = ifElseState("L",AFTER_STYLE_3,TEXT);
Tokenizer.prototype._stateAfterStyle3 = ifElseState("E",AFTER_STYLE_4,TEXT);

Tokenizer.prototype._stateAfterStyle4 = function(c){
if(c === ">" || whitespace(c)){
this._special = SPECIAL_NONE;
this._state = IN_CLOSING_TAG_NAME;
this._sectionStart = this._index - 5;
this._index--;}else 

this._state = TEXT;};


Tokenizer.prototype._stateBeforeEntity = ifElseState("#",BEFORE_NUMERIC_ENTITY,IN_NAMED_ENTITY);
Tokenizer.prototype._stateBeforeNumericEntity = ifElseState("X",IN_HEX_ENTITY,IN_NUMERIC_ENTITY);


Tokenizer.prototype._parseNamedEntityStrict = function(){

if(this._sectionStart + 1 < this._index){
var entity=this._buffer.substring(this._sectionStart + 1,this._index),
map=this._xmlMode?xmlMap:entityMap;

if(map.hasOwnProperty(entity)){
this._emitPartial(map[entity]);
this._sectionStart = this._index + 1;}}};






Tokenizer.prototype._parseLegacyEntity = function(){
var start=this._sectionStart + 1,
limit=this._index - start;

if(limit > 6)limit = 6;

while(limit >= 2) {
var entity=this._buffer.substr(start,limit);

if(legacyMap.hasOwnProperty(entity)){
this._emitPartial(legacyMap[entity]);
this._sectionStart += limit + 1;
return;}else 
{
limit--;}}};




Tokenizer.prototype._stateInNamedEntity = function(c){
if(c === ";"){
this._parseNamedEntityStrict();
if(this._sectionStart + 1 < this._index && !this._xmlMode){
this._parseLegacyEntity();}

this._state = this._baseState;}else 
if((c < "a" || c > "z") && (c < "A" || c > "Z") && (c < "0" || c > "9")){
if(this._xmlMode);else 
if(this._sectionStart + 1 === this._index);else 
if(this._baseState !== TEXT){
if(c !== "="){
this._parseNamedEntityStrict();}}else 

{
this._parseLegacyEntity();}


this._state = this._baseState;
this._index--;}};



Tokenizer.prototype._decodeNumericEntity = function(offset,base){
var sectionStart=this._sectionStart + offset;

if(sectionStart !== this._index){

var entity=this._buffer.substring(sectionStart,this._index);
var parsed=parseInt(entity,base);

this._emitPartial(decodeCodePoint(parsed));
this._sectionStart = this._index;}else 
{
this._sectionStart--;}


this._state = this._baseState;};


Tokenizer.prototype._stateInNumericEntity = function(c){
if(c === ";"){
this._decodeNumericEntity(2,10);
this._sectionStart++;}else 
if(c < "0" || c > "9"){
if(!this._xmlMode){
this._decodeNumericEntity(2,10);}else 
{
this._state = this._baseState;}

this._index--;}};



Tokenizer.prototype._stateInHexEntity = function(c){
if(c === ";"){
this._decodeNumericEntity(3,16);
this._sectionStart++;}else 
if((c < "a" || c > "f") && (c < "A" || c > "F") && (c < "0" || c > "9")){
if(!this._xmlMode){
this._decodeNumericEntity(3,16);}else 
{
this._state = this._baseState;}

this._index--;}};



Tokenizer.prototype._cleanup = function(){
if(this._sectionStart < 0){
this._buffer = "";
this._index = 0;
this._bufferOffset += this._index;}else 
if(this._running){
if(this._state === TEXT){
if(this._sectionStart !== this._index){
this._cbs.ontext(this._buffer.substr(this._sectionStart));}

this._buffer = "";
this._index = 0;
this._bufferOffset += this._index;}else 
if(this._sectionStart === this._index){

this._buffer = "";
this._index = 0;
this._bufferOffset += this._index;}else 
{

this._buffer = this._buffer.substr(this._sectionStart);
this._index -= this._sectionStart;
this._bufferOffset += this._sectionStart;}


this._sectionStart = 0;}};




Tokenizer.prototype.write = function(chunk){
if(this._ended)this._cbs.onerror(Error(".write() after done!"));

this._buffer += chunk;
this._parse();};


Tokenizer.prototype._parse = function(){
while(this._index < this._buffer.length && this._running) {
var c=this._buffer.charAt(this._index);
if(this._state === TEXT){
this._stateText(c);}else 
if(this._state === BEFORE_TAG_NAME){
this._stateBeforeTagName(c);}else 
if(this._state === IN_TAG_NAME){
this._stateInTagName(c);}else 
if(this._state === BEFORE_CLOSING_TAG_NAME){
this._stateBeforeCloseingTagName(c);}else 
if(this._state === IN_CLOSING_TAG_NAME){
this._stateInCloseingTagName(c);}else 
if(this._state === AFTER_CLOSING_TAG_NAME){
this._stateAfterCloseingTagName(c);}else 
if(this._state === IN_SELF_CLOSING_TAG){
this._stateInSelfClosingTag(c);}else 





if(this._state === BEFORE_ATTRIBUTE_NAME){
this._stateBeforeAttributeName(c);}else 
if(this._state === IN_ATTRIBUTE_NAME){
this._stateInAttributeName(c);}else 
if(this._state === AFTER_ATTRIBUTE_NAME){
this._stateAfterAttributeName(c);}else 
if(this._state === BEFORE_ATTRIBUTE_VALUE){
this._stateBeforeAttributeValue(c);}else 
if(this._state === IN_ATTRIBUTE_VALUE_DQ){
this._stateInAttributeValueDoubleQuotes(c);}else 
if(this._state === IN_ATTRIBUTE_VALUE_SQ){
this._stateInAttributeValueSingleQuotes(c);}else 
if(this._state === IN_ATTRIBUTE_VALUE_NQ){
this._stateInAttributeValueNoQuotes(c);}else 





if(this._state === BEFORE_DECLARATION){
this._stateBeforeDeclaration(c);}else 
if(this._state === IN_DECLARATION){
this._stateInDeclaration(c);}else 





if(this._state === IN_PROCESSING_INSTRUCTION){
this._stateInProcessingInstruction(c);}else 





if(this._state === BEFORE_COMMENT){
this._stateBeforeComment(c);}else 
if(this._state === IN_COMMENT){
this._stateInComment(c);}else 
if(this._state === AFTER_COMMENT_1){
this._stateAfterComment1(c);}else 
if(this._state === AFTER_COMMENT_2){
this._stateAfterComment2(c);}else 





if(this._state === BEFORE_CDATA_1){
this._stateBeforeCdata1(c);}else 
if(this._state === BEFORE_CDATA_2){
this._stateBeforeCdata2(c);}else 
if(this._state === BEFORE_CDATA_3){
this._stateBeforeCdata3(c);}else 
if(this._state === BEFORE_CDATA_4){
this._stateBeforeCdata4(c);}else 
if(this._state === BEFORE_CDATA_5){
this._stateBeforeCdata5(c);}else 
if(this._state === BEFORE_CDATA_6){
this._stateBeforeCdata6(c);}else 
if(this._state === IN_CDATA){
this._stateInCdata(c);}else 
if(this._state === AFTER_CDATA_1){
this._stateAfterCdata1(c);}else 
if(this._state === AFTER_CDATA_2){
this._stateAfterCdata2(c);}else 





if(this._state === BEFORE_SPECIAL){
this._stateBeforeSpecial(c);}else 
if(this._state === BEFORE_SPECIAL_END){
this._stateBeforeSpecialEnd(c);}else 





if(this._state === BEFORE_SCRIPT_1){
this._stateBeforeScript1(c);}else 
if(this._state === BEFORE_SCRIPT_2){
this._stateBeforeScript2(c);}else 
if(this._state === BEFORE_SCRIPT_3){
this._stateBeforeScript3(c);}else 
if(this._state === BEFORE_SCRIPT_4){
this._stateBeforeScript4(c);}else 
if(this._state === BEFORE_SCRIPT_5){
this._stateBeforeScript5(c);}else 


if(this._state === AFTER_SCRIPT_1){
this._stateAfterScript1(c);}else 
if(this._state === AFTER_SCRIPT_2){
this._stateAfterScript2(c);}else 
if(this._state === AFTER_SCRIPT_3){
this._stateAfterScript3(c);}else 
if(this._state === AFTER_SCRIPT_4){
this._stateAfterScript4(c);}else 
if(this._state === AFTER_SCRIPT_5){
this._stateAfterScript5(c);}else 





if(this._state === BEFORE_STYLE_1){
this._stateBeforeStyle1(c);}else 
if(this._state === BEFORE_STYLE_2){
this._stateBeforeStyle2(c);}else 
if(this._state === BEFORE_STYLE_3){
this._stateBeforeStyle3(c);}else 
if(this._state === BEFORE_STYLE_4){
this._stateBeforeStyle4(c);}else 


if(this._state === AFTER_STYLE_1){
this._stateAfterStyle1(c);}else 
if(this._state === AFTER_STYLE_2){
this._stateAfterStyle2(c);}else 
if(this._state === AFTER_STYLE_3){
this._stateAfterStyle3(c);}else 
if(this._state === AFTER_STYLE_4){
this._stateAfterStyle4(c);}else 





if(this._state === BEFORE_ENTITY){
this._stateBeforeEntity(c);}else 
if(this._state === BEFORE_NUMERIC_ENTITY){
this._stateBeforeNumericEntity(c);}else 
if(this._state === IN_NAMED_ENTITY){
this._stateInNamedEntity(c);}else 
if(this._state === IN_NUMERIC_ENTITY){
this._stateInNumericEntity(c);}else 
if(this._state === IN_HEX_ENTITY){
this._stateInHexEntity(c);}else 


{
this._cbs.onerror(Error("unknown _state"),this._state);}


this._index++;}


this._cleanup();};


Tokenizer.prototype.pause = function(){
this._running = false;};

Tokenizer.prototype.resume = function(){
this._running = true;

if(this._index < this._buffer.length){
this._parse();}

if(this._ended){
this._finish();}};



Tokenizer.prototype.end = function(chunk){
if(this._ended)this._cbs.onerror(Error(".end() after done!"));
if(chunk)this.write(chunk);

this._ended = true;

if(this._running)this._finish();};


Tokenizer.prototype._finish = function(){

if(this._sectionStart < this._index){
this._handleTrailingData();}


this._cbs.onend();};


Tokenizer.prototype._handleTrailingData = function(){
var data=this._buffer.substr(this._sectionStart);

if(this._state === IN_CDATA || this._state === AFTER_CDATA_1 || this._state === AFTER_CDATA_2){
this._cbs.oncdata(data);}else 
if(this._state === IN_COMMENT || this._state === AFTER_COMMENT_1 || this._state === AFTER_COMMENT_2){
this._cbs.oncomment(data);}else 
if(this._state === IN_NAMED_ENTITY && !this._xmlMode){
this._parseLegacyEntity();
if(this._sectionStart < this._index){
this._state = this._baseState;
this._handleTrailingData();}}else 

if(this._state === IN_NUMERIC_ENTITY && !this._xmlMode){
this._decodeNumericEntity(2,10);
if(this._sectionStart < this._index){
this._state = this._baseState;
this._handleTrailingData();}}else 

if(this._state === IN_HEX_ENTITY && !this._xmlMode){
this._decodeNumericEntity(3,16);
if(this._sectionStart < this._index){
this._state = this._baseState;
this._handleTrailingData();}}else 

if(
this._state !== IN_TAG_NAME && 
this._state !== BEFORE_ATTRIBUTE_NAME && 
this._state !== BEFORE_ATTRIBUTE_VALUE && 
this._state !== AFTER_ATTRIBUTE_NAME && 
this._state !== IN_ATTRIBUTE_NAME && 
this._state !== IN_ATTRIBUTE_VALUE_SQ && 
this._state !== IN_ATTRIBUTE_VALUE_DQ && 
this._state !== IN_ATTRIBUTE_VALUE_NQ && 
this._state !== IN_CLOSING_TAG_NAME)
{
this._cbs.ontext(data);}};





Tokenizer.prototype.reset = function(){
Tokenizer.call(this,{xmlMode:this._xmlMode,decodeEntities:this._decodeEntities},this._cbs);};


Tokenizer.prototype.getAbsoluteIndex = function(){
return this._bufferOffset + this._index;};


Tokenizer.prototype._getSection = function(){
return this._buffer.substring(this._sectionStart,this._index);};


Tokenizer.prototype._emitToken = function(name){
this._cbs[name](this._getSection());
this._sectionStart = -1;};


Tokenizer.prototype._emitPartial = function(value){
if(this._baseState !== TEXT){
this._cbs.onattribdata(value);}else 
{
this._cbs.ontext(value);}};},



{
"entities/lib/decode_codepoint.js":29,
"entities/maps/entities.json":31,
"entities/maps/legacy.json":32,
"entities/maps/xml.json":33}],

7:[function(_dereq_,module,exports){
module.exports = Stream;

var Parser=_dereq_("./Parser.js"),
WritableStream=_dereq_("stream").Writable || _dereq_("readable-stream").Writable;

function Stream(cbs,options){
var parser=this._parser = new Parser(cbs,options);

WritableStream.call(this,{decodeStrings:false});

this.once("finish",function(){
parser.end();});}



_dereq_("util").inherits(Stream,WritableStream);

WritableStream.prototype._write = function(chunk,encoding,cb){
this._parser.write(chunk);
cb();};},

{"./Parser.js":3,"readable-stream":34,"stream":54,"util":57}],
8:[function(_dereq_,module,exports){

module.exports = {
Text:"text",
Directive:"directive",
Comment:"comment",
Script:"script",
Style:"style",
Tag:"tag",
CDATA:"cdata",
Doctype:"doctype",

isTag:function(elem){
return elem.type === "tag" || elem.type === "script" || elem.type === "style";}};},



{}],
9:[function(_dereq_,module,exports){
var ElementType=_dereq_("domelementtype");

var re_whitespace=/\s+/g;
var NodePrototype=_dereq_("./lib/node");
var ElementPrototype=_dereq_("./lib/element");

function DomHandler(callback,options,elementCB){
if(typeof callback === "object"){
elementCB = options;
options = callback;
callback = null;}else 
if(typeof options === "function"){
elementCB = options;
options = defaultOpts;}

this._callback = callback;
this._options = options || defaultOpts;
this._elementCB = elementCB;
this.dom = [];
this._done = false;
this._tagStack = [];
this._parser = this._parser || null;}



var defaultOpts={
normalizeWhitespace:false,
withStartIndices:false};


DomHandler.prototype.onparserinit = function(parser){
this._parser = parser;};



DomHandler.prototype.onreset = function(){
DomHandler.call(this,this._callback,this._options,this._elementCB);};



DomHandler.prototype.onend = function(){
if(this._done)return;
this._done = true;
this._parser = null;
this._handleCallback(null);};


DomHandler.prototype._handleCallback = 
DomHandler.prototype.onerror = function(error){
if(typeof this._callback === "function"){
this._callback(error,this.dom);}else 
{
if(error)throw error;}};



DomHandler.prototype.onclosetag = function(){

var elem=this._tagStack.pop();
if(this._elementCB)this._elementCB(elem);};


DomHandler.prototype._addDomElement = function(element){
var parent=this._tagStack[this._tagStack.length - 1];
var siblings=parent?parent.children:this.dom;
var previousSibling=siblings[siblings.length - 1];

element.next = null;

if(this._options.withStartIndices){
element.startIndex = this._parser.startIndex;}


if(this._options.withDomLvl1){
element.__proto__ = element.type === "tag"?ElementPrototype:NodePrototype;}


if(previousSibling){
element.prev = previousSibling;
previousSibling.next = element;}else 
{
element.prev = null;}


siblings.push(element);
element.parent = parent || null;};


DomHandler.prototype.onopentag = function(name,attribs){
var element={
type:name === "script"?ElementType.Script:name === "style"?ElementType.Style:ElementType.Tag,
name:name,
attribs:attribs,
children:[]};


this._addDomElement(element);

this._tagStack.push(element);};


DomHandler.prototype.ontext = function(data){


var normalize=this._options.normalizeWhitespace || this._options.ignoreWhitespace;

var lastTag;

if(!this._tagStack.length && this.dom.length && (lastTag = this.dom[this.dom.length - 1]).type === ElementType.Text){
if(normalize){
lastTag.data = (lastTag.data + data).replace(re_whitespace," ");}else 
{
lastTag.data += data;}}else 

{
if(
this._tagStack.length && (
lastTag = this._tagStack[this._tagStack.length - 1]) && (
lastTag = lastTag.children[lastTag.children.length - 1]) && 
lastTag.type === ElementType.Text)
{
if(normalize){
lastTag.data = (lastTag.data + data).replace(re_whitespace," ");}else 
{
lastTag.data += data;}}else 

{
if(normalize){
data = data.replace(re_whitespace," ");}


this._addDomElement({
data:data,
type:ElementType.Text});}}};





DomHandler.prototype.oncomment = function(data){
var lastTag=this._tagStack[this._tagStack.length - 1];

if(lastTag && lastTag.type === ElementType.Comment){
lastTag.data += data;
return;}


var element={
data:data,
type:ElementType.Comment};


this._addDomElement(element);
this._tagStack.push(element);};


DomHandler.prototype.oncdatastart = function(){
var element={
children:[{
data:"",
type:ElementType.Text}],

type:ElementType.CDATA};


this._addDomElement(element);
this._tagStack.push(element);};


DomHandler.prototype.oncommentend = DomHandler.prototype.oncdataend = function(){
this._tagStack.pop();};


DomHandler.prototype.onprocessinginstruction = function(name,data){
this._addDomElement({
name:name,
data:data,
type:ElementType.Directive});};



module.exports = DomHandler;},

{"./lib/element":10,"./lib/node":11,"domelementtype":8}],
10:[function(_dereq_,module,exports){

var NodePrototype=_dereq_("./node");
var ElementPrototype=module.exports = Object.create(NodePrototype);

var domLvl1={
tagName:"name"};


Object.keys(domLvl1).forEach(function(key){
var shorthand=domLvl1[key];
Object.defineProperty(ElementPrototype,key,{
get:function(){
return this[shorthand] || null;},

set:function(val){
this[shorthand] = val;
return val;}});});},




{"./node":11}],
11:[function(_dereq_,module,exports){


var NodePrototype=module.exports = {
get firstChild(){
var children=this.children;
return children && children[0] || null;},

get lastChild(){
var children=this.children;
return children && children[children.length - 1] || null;},

get nodeType(){
return nodeTypes[this.type] || nodeTypes.element;}};



var domLvl1={
tagName:"name",
childNodes:"children",
parentNode:"parent",
previousSibling:"prev",
nextSibling:"next",
nodeValue:"data"};


var nodeTypes={
element:1,
text:3,
cdata:4,
comment:8};


Object.keys(domLvl1).forEach(function(key){
var shorthand=domLvl1[key];
Object.defineProperty(NodePrototype,key,{
get:function(){
return this[shorthand] || null;},

set:function(val){
this[shorthand] = val;
return val;}});});},




{}],
12:[function(_dereq_,module,exports){
var DomUtils=module.exports;

[
_dereq_("./lib/stringify"),
_dereq_("./lib/traversal"),
_dereq_("./lib/manipulation"),
_dereq_("./lib/querying"),
_dereq_("./lib/legacy"),
_dereq_("./lib/helpers")].
forEach(function(ext){
Object.keys(ext).forEach(function(key){
DomUtils[key] = ext[key].bind(DomUtils);});});},



{
"./lib/helpers":13,
"./lib/legacy":14,
"./lib/manipulation":15,
"./lib/querying":16,
"./lib/stringify":17,
"./lib/traversal":18}],

13:[function(_dereq_,module,exports){


exports.removeSubsets = function(nodes){
var idx=nodes.length,node,ancestor,replace;



while(--idx > -1) {
node = ancestor = nodes[idx];


nodes[idx] = null;
replace = true;

while(ancestor) {
if(nodes.indexOf(ancestor) > -1){
replace = false;
nodes.splice(idx,1);
break;}

ancestor = ancestor.parent;}



if(replace){
nodes[idx] = node;}}



return nodes;};



var POSITION={
DISCONNECTED:1,
PRECEDING:2,
FOLLOWING:4,
CONTAINS:8,
CONTAINED_BY:16};
























var comparePos=exports.compareDocumentPosition = function(nodeA,nodeB){
var aParents=[];
var bParents=[];
var current,sharedParent,siblings,aSibling,bSibling,idx;

if(nodeA === nodeB){
return 0;}


current = nodeA;
while(current) {
aParents.unshift(current);
current = current.parent;}

current = nodeB;
while(current) {
bParents.unshift(current);
current = current.parent;}


idx = 0;
while(aParents[idx] === bParents[idx]) {
idx++;}


if(idx === 0){
return POSITION.DISCONNECTED;}


sharedParent = aParents[idx - 1];
siblings = sharedParent.children;
aSibling = aParents[idx];
bSibling = bParents[idx];

if(siblings.indexOf(aSibling) > siblings.indexOf(bSibling)){
if(sharedParent === nodeB){
return POSITION.FOLLOWING | POSITION.CONTAINED_BY;}

return POSITION.FOLLOWING;}else 
{
if(sharedParent === nodeA){
return POSITION.PRECEDING | POSITION.CONTAINS;}

return POSITION.PRECEDING;}};










exports.uniqueSort = function(nodes){
var idx=nodes.length,node,position;

nodes = nodes.slice();

while(--idx > -1) {
node = nodes[idx];
position = nodes.indexOf(node);
if(position > -1 && position < idx){
nodes.splice(idx,1);}}


nodes.sort(function(a,b){
var relative=comparePos(a,b);
if(relative & POSITION.PRECEDING){
return -1;}else 
if(relative & POSITION.FOLLOWING){
return 1;}

return 0;});


return nodes;};},


{}],
14:[function(_dereq_,module,exports){
var ElementType=_dereq_("domelementtype");
var isTag=exports.isTag = ElementType.isTag;

exports.testElement = function(options,element){
for(var key in options) {
if(!options.hasOwnProperty(key));else 
if(key === "tag_name"){
if(!isTag(element) || !options.tag_name(element.name)){
return false;}}else 

if(key === "tag_type"){
if(!options.tag_type(element.type))return false;}else 
if(key === "tag_contains"){
if(isTag(element) || !options.tag_contains(element.data)){
return false;}}else 

if(!element.attribs || !options[key](element.attribs[key])){
return false;}}


return true;};


var Checks={
tag_name:function(name){
if(typeof name === "function"){
return function(elem){
return isTag(elem) && name(elem.name);};}else 

if(name === "*"){
return isTag;}else 
{
return function(elem){
return isTag(elem) && elem.name === name;};}},



tag_type:function(type){
if(typeof type === "function"){
return function(elem){
return type(elem.type);};}else 

{
return function(elem){
return elem.type === type;};}},



tag_contains:function(data){
if(typeof data === "function"){
return function(elem){
return !isTag(elem) && data(elem.data);};}else 

{
return function(elem){
return !isTag(elem) && elem.data === data;};}}};





function getAttribCheck(attrib,value){
if(typeof value === "function"){
return function(elem){
return elem.attribs && value(elem.attribs[attrib]);};}else 

{
return function(elem){
return elem.attribs && elem.attribs[attrib] === value;};}}




function combineFuncs(a,b){
return function(elem){
return a(elem) || b(elem);};}



exports.getElements = function(options,element,recurse,limit){
var funcs=Object.keys(options).map(function(key){
var value=options[key];
return key in Checks?Checks[key](value):getAttribCheck(key,value);});


return funcs.length === 0?[]:this.filter(
funcs.reduce(combineFuncs),
element,recurse,limit);};



exports.getElementById = function(id,element,recurse){
if(!Array.isArray(element))element = [element];
return this.findOne(getAttribCheck("id",id),element,recurse !== false);};


exports.getElementsByTagName = function(name,element,recurse,limit){
return this.filter(Checks.tag_name(name),element,recurse,limit);};


exports.getElementsByTagType = function(type,element,recurse,limit){
return this.filter(Checks.tag_type(type),element,recurse,limit);};},


{"domelementtype":8}],
15:[function(_dereq_,module,exports){
exports.removeElement = function(elem){
if(elem.prev)elem.prev.next = elem.next;
if(elem.next)elem.next.prev = elem.prev;

if(elem.parent){
var childs=elem.parent.children;
childs.splice(childs.lastIndexOf(elem),1);}};



exports.replaceElement = function(elem,replacement){
var prev=replacement.prev = elem.prev;
if(prev){
prev.next = replacement;}


var next=replacement.next = elem.next;
if(next){
next.prev = replacement;}


var parent=replacement.parent = elem.parent;
if(parent){
var childs=parent.children;
childs[childs.lastIndexOf(elem)] = replacement;}};



exports.appendChild = function(elem,child){
child.parent = elem;

if(elem.children.push(child) !== 1){
var sibling=elem.children[elem.children.length - 2];
sibling.next = child;
child.prev = sibling;
child.next = null;}};



exports.append = function(elem,next){
var parent=elem.parent,
currNext=elem.next;

next.next = currNext;
next.prev = elem;
elem.next = next;
next.parent = parent;

if(currNext){
currNext.prev = next;
if(parent){
var childs=parent.children;
childs.splice(childs.lastIndexOf(currNext),0,next);}}else 

if(parent){
parent.children.push(next);}};



exports.prepend = function(elem,prev){
var parent=elem.parent;
if(parent){
var childs=parent.children;
childs.splice(childs.lastIndexOf(elem),0,prev);}


if(elem.prev){
elem.prev.next = prev;}


prev.parent = parent;
prev.prev = elem.prev;
prev.next = elem;
elem.prev = prev;};},



{}],
16:[function(_dereq_,module,exports){
var isTag=_dereq_("domelementtype").isTag;

module.exports = {
filter:filter,
find:find,
findOneChild:findOneChild,
findOne:findOne,
existsOne:existsOne,
findAll:findAll};


function filter(test,element,recurse,limit){
if(!Array.isArray(element))element = [element];

if(typeof limit !== "number" || !isFinite(limit)){
limit = Infinity;}

return find(test,element,recurse !== false,limit);}


function find(test,elems,recurse,limit){
var result=[],childs;

for(var i=0,j=elems.length;i < j;i++) {
if(test(elems[i])){
result.push(elems[i]);
if(--limit <= 0)break;}


childs = elems[i].children;
if(recurse && childs && childs.length > 0){
childs = find(test,childs,recurse,limit);
result = result.concat(childs);
limit -= childs.length;
if(limit <= 0)break;}}



return result;}


function findOneChild(test,elems){
for(var i=0,l=elems.length;i < l;i++) {
if(test(elems[i]))return elems[i];}


return null;}


function findOne(test,elems){
var elem=null;

for(var i=0,l=elems.length;i < l && !elem;i++) {
if(!isTag(elems[i])){
continue;}else 
if(test(elems[i])){
elem = elems[i];}else 
if(elems[i].children.length > 0){
elem = findOne(test,elems[i].children);}}



return elem;}


function existsOne(test,elems){
for(var i=0,l=elems.length;i < l;i++) {
if(
isTag(elems[i]) && (
test(elems[i]) || 
elems[i].children.length > 0 && 
existsOne(test,elems[i].children)))


{
return true;}}



return false;}


function findAll(test,elems){
var result=[];
for(var i=0,j=elems.length;i < j;i++) {
if(!isTag(elems[i]))continue;
if(test(elems[i]))result.push(elems[i]);

if(elems[i].children.length > 0){
result = result.concat(findAll(test,elems[i].children));}}


return result;}},


{"domelementtype":8}],
17:[function(_dereq_,module,exports){
var ElementType=_dereq_("domelementtype"),
getOuterHTML=_dereq_("dom-serializer"),
isTag=ElementType.isTag;

module.exports = {
getInnerHTML:getInnerHTML,
getOuterHTML:getOuterHTML,
getText:getText};


function getInnerHTML(elem,opts){
return elem.children?elem.children.map(function(elem){
return getOuterHTML(elem,opts);}).
join(""):"";}


function getText(elem){
if(Array.isArray(elem))return elem.map(getText).join("");
if(isTag(elem) || elem.type === ElementType.CDATA)return getText(elem.children);
if(elem.type === ElementType.Text)return elem.data;
return "";}},


{"dom-serializer":19,"domelementtype":8}],
18:[function(_dereq_,module,exports){
var getChildren=exports.getChildren = function(elem){
return elem.children;};


var getParent=exports.getParent = function(elem){
return elem.parent;};


exports.getSiblings = function(elem){
var parent=getParent(elem);
return parent?getChildren(parent):[elem];};


exports.getAttributeValue = function(elem,name){
return elem.attribs && elem.attribs[name];};


exports.hasAttrib = function(elem,name){
return !!elem.attribs && hasOwnProperty.call(elem.attribs,name);};


exports.getName = function(elem){
return elem.name;};},


{}],
19:[function(_dereq_,module,exports){



var ElementType=_dereq_("domelementtype");
var entities=_dereq_("entities");




var booleanAttributes={
__proto__:null,
allowfullscreen:true,
async:true,
autofocus:true,
autoplay:true,
checked:true,
controls:true,
default:true,
defer:true,
disabled:true,
hidden:true,
ismap:true,
loop:true,
multiple:true,
muted:true,
open:true,
readonly:true,
required:true,
reversed:true,
scoped:true,
seamless:true,
selected:true,
typemustmatch:true};


var unencodedElements={
__proto__:null,
style:true,
script:true,
xmp:true,
iframe:true,
noembed:true,
noframes:true,
plaintext:true,
noscript:true};





function formatAttrs(attributes,opts){
if(!attributes)return;

var output="",
value;


for(var key in attributes) {
value = attributes[key];
if(output){
output += " ";}


if(!value && booleanAttributes[key]){
output += key;}else 
{
output += key + "=\"" + (opts.decodeEntities?entities.encodeXML(value):value) + "\"";}}



return output;}





var singleTag={
__proto__:null,
area:true,
base:true,
basefont:true,
br:true,
col:true,
command:true,
embed:true,
frame:true,
hr:true,
img:true,
input:true,
isindex:true,
keygen:true,
link:true,
meta:true,
param:true,
source:true,
track:true,
wbr:true};



var render=module.exports = function(dom,opts){
if(!Array.isArray(dom) && !dom.cheerio)dom = [dom];
opts = opts || {};

var output="";

for(var i=0;i < dom.length;i++) {
var elem=dom[i];

if(elem.type === "root")
output += render(elem.children,opts);else 
if(ElementType.isTag(elem))
output += renderTag(elem,opts);else 
if(elem.type === ElementType.Directive)
output += renderDirective(elem);else 
if(elem.type === ElementType.Comment)
output += renderComment(elem);else 
if(elem.type === ElementType.CDATA)
output += renderCdata(elem);else 

output += renderText(elem,opts);}


return output;};


function renderTag(elem,opts){

if(elem.name === "svg")opts = {decodeEntities:opts.decodeEntities,xmlMode:true};

var tag="<" + elem.name,
attribs=formatAttrs(elem.attribs,opts);

if(attribs){
tag += " " + attribs;}


if(
opts.xmlMode && (
!elem.children || elem.children.length === 0))
{
tag += "/>";}else 
{
tag += ">";
if(elem.children){
tag += render(elem.children,opts);}


if(!singleTag[elem.name] || opts.xmlMode){
tag += "</" + elem.name + ">";}}



return tag;}


function renderDirective(elem){
return "<" + elem.data + ">";}


function renderText(elem,opts){
var data=elem.data || "";


if(opts.decodeEntities && !(elem.parent && elem.parent.name in unencodedElements)){
data = entities.encodeXML(data);}


return data;}


function renderCdata(elem){
return "<![CDATA[" + elem.children[0].data + "]]>";}


function renderComment(elem){
return "<!--" + elem.data + "-->";}},


{"domelementtype":20,"entities":21}],
20:[function(_dereq_,module,exports){

module.exports = {
Text:"text",
Directive:"directive",
Comment:"comment",
Script:"script",
Style:"style",
Tag:"tag",
CDATA:"cdata",

isTag:function(elem){
return elem.type === "tag" || elem.type === "script" || elem.type === "style";}};},


{}],
21:[function(_dereq_,module,exports){
var encode=_dereq_("./lib/encode.js"),
decode=_dereq_("./lib/decode.js");

exports.decode = function(data,level){
return (!level || level <= 0?decode.XML:decode.HTML)(data);};


exports.decodeStrict = function(data,level){
return (!level || level <= 0?decode.XML:decode.HTMLStrict)(data);};


exports.encode = function(data,level){
return (!level || level <= 0?encode.XML:encode.HTML)(data);};


exports.encodeXML = encode.XML;

exports.encodeHTML4 = 
exports.encodeHTML5 = 
exports.encodeHTML = encode.HTML;

exports.decodeXML = 
exports.decodeXMLStrict = decode.XML;

exports.decodeHTML4 = 
exports.decodeHTML5 = 
exports.decodeHTML = decode.HTML;

exports.decodeHTML4Strict = 
exports.decodeHTML5Strict = 
exports.decodeHTMLStrict = decode.HTMLStrict;

exports.escape = encode.escape;},

{"./lib/decode.js":22,"./lib/encode.js":24}],
22:[function(_dereq_,module,exports){
var entityMap=_dereq_("../maps/entities.json"),
legacyMap=_dereq_("../maps/legacy.json"),
xmlMap=_dereq_("../maps/xml.json"),
decodeCodePoint=_dereq_("./decode_codepoint.js");

var decodeXMLStrict=getStrictDecoder(xmlMap),
decodeHTMLStrict=getStrictDecoder(entityMap);

function getStrictDecoder(map){
var keys=Object.keys(map).join("|"),
replace=getReplacer(map);

keys += "|#[xX][\\da-fA-F]+|#\\d+";

var re=new RegExp("&(?:" + keys + ");","g");

return function(str){
return String(str).replace(re,replace);};}



var decodeHTML=(function(){
var legacy=Object.keys(legacyMap).
sort(sorter);

var keys=Object.keys(entityMap).
sort(sorter);

for(var i=0,j=0;i < keys.length;i++) {
if(legacy[j] === keys[i]){
keys[i] += ";?";
j++;}else 
{
keys[i] += ";";}}



var re=new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)","g"),
replace=getReplacer(entityMap);

function replacer(str){
if(str.substr(-1) !== ";")str += ";";
return replace(str);}



return function(str){
return String(str).replace(re,replacer);};})();



function sorter(a,b){
return a < b?1:-1;}


function getReplacer(map){
return function replace(str){
if(str.charAt(1) === "#"){
if(str.charAt(2) === "X" || str.charAt(2) === "x"){
return decodeCodePoint(parseInt(str.substr(3),16));}

return decodeCodePoint(parseInt(str.substr(2),10));}

return map[str.slice(1,-1)];};}



module.exports = {
XML:decodeXMLStrict,
HTML:decodeHTML,
HTMLStrict:decodeHTMLStrict};},

{
"../maps/entities.json":26,
"../maps/legacy.json":27,
"../maps/xml.json":28,
"./decode_codepoint.js":23}],

23:[function(_dereq_,module,exports){
var decodeMap=_dereq_("../maps/decode.json");

module.exports = decodeCodePoint;


function decodeCodePoint(codePoint){

if(codePoint >= 0xD800 && codePoint <= 0xDFFF || codePoint > 0x10FFFF){
return "�";}


if(codePoint in decodeMap){
codePoint = decodeMap[codePoint];}


var output="";

if(codePoint > 0xFFFF){
codePoint -= 0x10000;
output += String.fromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
codePoint = 0xDC00 | codePoint & 0x3FF;}


output += String.fromCharCode(codePoint);
return output;}},


{"../maps/decode.json":25}],
24:[function(_dereq_,module,exports){
var inverseXML=getInverseObj(_dereq_("../maps/xml.json")),
xmlReplacer=getInverseReplacer(inverseXML);

exports.XML = getInverse(inverseXML,xmlReplacer);

var inverseHTML=getInverseObj(_dereq_("../maps/entities.json")),
htmlReplacer=getInverseReplacer(inverseHTML);

exports.HTML = getInverse(inverseHTML,htmlReplacer);

function getInverseObj(obj){
return Object.keys(obj).sort().reduce(function(inverse,name){
inverse[obj[name]] = "&" + name + ";";
return inverse;},
{});}


function getInverseReplacer(inverse){
var single=[],
multiple=[];

Object.keys(inverse).forEach(function(k){
if(k.length === 1){
single.push("\\" + k);}else 
{
multiple.push(k);}});




multiple.unshift("[" + single.join("") + "]");

return new RegExp(multiple.join("|"),"g");}


var re_nonASCII=/[^\0-\x7F]/g,
re_astralSymbols=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g;

function singleCharReplacer(c){
return "&#x" + c.charCodeAt(0).toString(16).toUpperCase() + ";";}


function astralReplacer(c){

var high=c.charCodeAt(0);
var low=c.charCodeAt(1);
var codePoint=(high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
return "&#x" + codePoint.toString(16).toUpperCase() + ";";}


function getInverse(inverse,re){
function func(name){
return inverse[name];}


return function(data){
return data.
replace(re,func).
replace(re_astralSymbols,astralReplacer).
replace(re_nonASCII,singleCharReplacer);};}



var re_xmlChars=getInverseReplacer(inverseXML);

function escapeXML(data){
return data.
replace(re_xmlChars,singleCharReplacer).
replace(re_astralSymbols,astralReplacer).
replace(re_nonASCII,singleCharReplacer);}


exports.escape = escapeXML;},

{"../maps/entities.json":26,"../maps/xml.json":28}],
25:[function(_dereq_,module,exports){
module.exports = {
"0":65533,
"128":8364,
"130":8218,
"131":402,
"132":8222,
"133":8230,
"134":8224,
"135":8225,
"136":710,
"137":8240,
"138":352,
"139":8249,
"140":338,
"142":381,
"145":8216,
"146":8217,
"147":8220,
"148":8221,
"149":8226,
"150":8211,
"151":8212,
"152":732,
"153":8482,
"154":353,
"155":8250,
"156":339,
"158":382,
"159":376};},

{}],
26:[function(_dereq_,module,exports){
module.exports = {
"Aacute":"Á",
"aacute":"á",
"Abreve":"Ă",
"abreve":"ă",
"ac":"∾",
"acd":"∿",
"acE":"∾̳",
"Acirc":"Â",
"acirc":"â",
"acute":"´",
"Acy":"А",
"acy":"а",
"AElig":"Æ",
"aelig":"æ",
"af":"⁡",
"Afr":"𝔄",
"afr":"𝔞",
"Agrave":"À",
"agrave":"à",
"alefsym":"ℵ",
"aleph":"ℵ",
"Alpha":"Α",
"alpha":"α",
"Amacr":"Ā",
"amacr":"ā",
"amalg":"⨿",
"amp":"&",
"AMP":"&",
"andand":"⩕",
"And":"⩓",
"and":"∧",
"andd":"⩜",
"andslope":"⩘",
"andv":"⩚",
"ang":"∠",
"ange":"⦤",
"angle":"∠",
"angmsdaa":"⦨",
"angmsdab":"⦩",
"angmsdac":"⦪",
"angmsdad":"⦫",
"angmsdae":"⦬",
"angmsdaf":"⦭",
"angmsdag":"⦮",
"angmsdah":"⦯",
"angmsd":"∡",
"angrt":"∟",
"angrtvb":"⊾",
"angrtvbd":"⦝",
"angsph":"∢",
"angst":"Å",
"angzarr":"⍼",
"Aogon":"Ą",
"aogon":"ą",
"Aopf":"𝔸",
"aopf":"𝕒",
"apacir":"⩯",
"ap":"≈",
"apE":"⩰",
"ape":"≊",
"apid":"≋",
"apos":"'",
"ApplyFunction":"⁡",
"approx":"≈",
"approxeq":"≊",
"Aring":"Å",
"aring":"å",
"Ascr":"𝒜",
"ascr":"𝒶",
"Assign":"≔",
"ast":"*",
"asymp":"≈",
"asympeq":"≍",
"Atilde":"Ã",
"atilde":"ã",
"Auml":"Ä",
"auml":"ä",
"awconint":"∳",
"awint":"⨑",
"backcong":"≌",
"backepsilon":"϶",
"backprime":"‵",
"backsim":"∽",
"backsimeq":"⋍",
"Backslash":"∖",
"Barv":"⫧",
"barvee":"⊽",
"barwed":"⌅",
"Barwed":"⌆",
"barwedge":"⌅",
"bbrk":"⎵",
"bbrktbrk":"⎶",
"bcong":"≌",
"Bcy":"Б",
"bcy":"б",
"bdquo":"„",
"becaus":"∵",
"because":"∵",
"Because":"∵",
"bemptyv":"⦰",
"bepsi":"϶",
"bernou":"ℬ",
"Bernoullis":"ℬ",
"Beta":"Β",
"beta":"β",
"beth":"ℶ",
"between":"≬",
"Bfr":"𝔅",
"bfr":"𝔟",
"bigcap":"⋂",
"bigcirc":"◯",
"bigcup":"⋃",
"bigodot":"⨀",
"bigoplus":"⨁",
"bigotimes":"⨂",
"bigsqcup":"⨆",
"bigstar":"★",
"bigtriangledown":"▽",
"bigtriangleup":"△",
"biguplus":"⨄",
"bigvee":"⋁",
"bigwedge":"⋀",
"bkarow":"⤍",
"blacklozenge":"⧫",
"blacksquare":"▪",
"blacktriangle":"▴",
"blacktriangledown":"▾",
"blacktriangleleft":"◂",
"blacktriangleright":"▸",
"blank":"␣",
"blk12":"▒",
"blk14":"░",
"blk34":"▓",
"block":"█",
"bne":"=⃥",
"bnequiv":"≡⃥",
"bNot":"⫭",
"bnot":"⌐",
"Bopf":"𝔹",
"bopf":"𝕓",
"bot":"⊥",
"bottom":"⊥",
"bowtie":"⋈",
"boxbox":"⧉",
"boxdl":"┐",
"boxdL":"╕",
"boxDl":"╖",
"boxDL":"╗",
"boxdr":"┌",
"boxdR":"╒",
"boxDr":"╓",
"boxDR":"╔",
"boxh":"─",
"boxH":"═",
"boxhd":"┬",
"boxHd":"╤",
"boxhD":"╥",
"boxHD":"╦",
"boxhu":"┴",
"boxHu":"╧",
"boxhU":"╨",
"boxHU":"╩",
"boxminus":"⊟",
"boxplus":"⊞",
"boxtimes":"⊠",
"boxul":"┘",
"boxuL":"╛",
"boxUl":"╜",
"boxUL":"╝",
"boxur":"└",
"boxuR":"╘",
"boxUr":"╙",
"boxUR":"╚",
"boxv":"│",
"boxV":"║",
"boxvh":"┼",
"boxvH":"╪",
"boxVh":"╫",
"boxVH":"╬",
"boxvl":"┤",
"boxvL":"╡",
"boxVl":"╢",
"boxVL":"╣",
"boxvr":"├",
"boxvR":"╞",
"boxVr":"╟",
"boxVR":"╠",
"bprime":"‵",
"breve":"˘",
"Breve":"˘",
"brvbar":"¦",
"bscr":"𝒷",
"Bscr":"ℬ",
"bsemi":"⁏",
"bsim":"∽",
"bsime":"⋍",
"bsolb":"⧅",
"bsol":"\\",
"bsolhsub":"⟈",
"bull":"•",
"bullet":"•",
"bump":"≎",
"bumpE":"⪮",
"bumpe":"≏",
"Bumpeq":"≎",
"bumpeq":"≏",
"Cacute":"Ć",
"cacute":"ć",
"capand":"⩄",
"capbrcup":"⩉",
"capcap":"⩋",
"cap":"∩",
"Cap":"⋒",
"capcup":"⩇",
"capdot":"⩀",
"CapitalDifferentialD":"ⅅ",
"caps":"∩︀",
"caret":"⁁",
"caron":"ˇ",
"Cayleys":"ℭ",
"ccaps":"⩍",
"Ccaron":"Č",
"ccaron":"č",
"Ccedil":"Ç",
"ccedil":"ç",
"Ccirc":"Ĉ",
"ccirc":"ĉ",
"Cconint":"∰",
"ccups":"⩌",
"ccupssm":"⩐",
"Cdot":"Ċ",
"cdot":"ċ",
"cedil":"¸",
"Cedilla":"¸",
"cemptyv":"⦲",
"cent":"¢",
"centerdot":"·",
"CenterDot":"·",
"cfr":"𝔠",
"Cfr":"ℭ",
"CHcy":"Ч",
"chcy":"ч",
"check":"✓",
"checkmark":"✓",
"Chi":"Χ",
"chi":"χ",
"circ":"ˆ",
"circeq":"≗",
"circlearrowleft":"↺",
"circlearrowright":"↻",
"circledast":"⊛",
"circledcirc":"⊚",
"circleddash":"⊝",
"CircleDot":"⊙",
"circledR":"®",
"circledS":"Ⓢ",
"CircleMinus":"⊖",
"CirclePlus":"⊕",
"CircleTimes":"⊗",
"cir":"○",
"cirE":"⧃",
"cire":"≗",
"cirfnint":"⨐",
"cirmid":"⫯",
"cirscir":"⧂",
"ClockwiseContourIntegral":"∲",
"CloseCurlyDoubleQuote":"”",
"CloseCurlyQuote":"’",
"clubs":"♣",
"clubsuit":"♣",
"colon":":",
"Colon":"∷",
"Colone":"⩴",
"colone":"≔",
"coloneq":"≔",
"comma":",",
"commat":"@",
"comp":"∁",
"compfn":"∘",
"complement":"∁",
"complexes":"ℂ",
"cong":"≅",
"congdot":"⩭",
"Congruent":"≡",
"conint":"∮",
"Conint":"∯",
"ContourIntegral":"∮",
"copf":"𝕔",
"Copf":"ℂ",
"coprod":"∐",
"Coproduct":"∐",
"copy":"©",
"COPY":"©",
"copysr":"℗",
"CounterClockwiseContourIntegral":"∳",
"crarr":"↵",
"cross":"✗",
"Cross":"⨯",
"Cscr":"𝒞",
"cscr":"𝒸",
"csub":"⫏",
"csube":"⫑",
"csup":"⫐",
"csupe":"⫒",
"ctdot":"⋯",
"cudarrl":"⤸",
"cudarrr":"⤵",
"cuepr":"⋞",
"cuesc":"⋟",
"cularr":"↶",
"cularrp":"⤽",
"cupbrcap":"⩈",
"cupcap":"⩆",
"CupCap":"≍",
"cup":"∪",
"Cup":"⋓",
"cupcup":"⩊",
"cupdot":"⊍",
"cupor":"⩅",
"cups":"∪︀",
"curarr":"↷",
"curarrm":"⤼",
"curlyeqprec":"⋞",
"curlyeqsucc":"⋟",
"curlyvee":"⋎",
"curlywedge":"⋏",
"curren":"¤",
"curvearrowleft":"↶",
"curvearrowright":"↷",
"cuvee":"⋎",
"cuwed":"⋏",
"cwconint":"∲",
"cwint":"∱",
"cylcty":"⌭",
"dagger":"†",
"Dagger":"‡",
"daleth":"ℸ",
"darr":"↓",
"Darr":"↡",
"dArr":"⇓",
"dash":"‐",
"Dashv":"⫤",
"dashv":"⊣",
"dbkarow":"⤏",
"dblac":"˝",
"Dcaron":"Ď",
"dcaron":"ď",
"Dcy":"Д",
"dcy":"д",
"ddagger":"‡",
"ddarr":"⇊",
"DD":"ⅅ",
"dd":"ⅆ",
"DDotrahd":"⤑",
"ddotseq":"⩷",
"deg":"°",
"Del":"∇",
"Delta":"Δ",
"delta":"δ",
"demptyv":"⦱",
"dfisht":"⥿",
"Dfr":"𝔇",
"dfr":"𝔡",
"dHar":"⥥",
"dharl":"⇃",
"dharr":"⇂",
"DiacriticalAcute":"´",
"DiacriticalDot":"˙",
"DiacriticalDoubleAcute":"˝",
"DiacriticalGrave":"`",
"DiacriticalTilde":"˜",
"diam":"⋄",
"diamond":"⋄",
"Diamond":"⋄",
"diamondsuit":"♦",
"diams":"♦",
"die":"¨",
"DifferentialD":"ⅆ",
"digamma":"ϝ",
"disin":"⋲",
"div":"÷",
"divide":"÷",
"divideontimes":"⋇",
"divonx":"⋇",
"DJcy":"Ђ",
"djcy":"ђ",
"dlcorn":"⌞",
"dlcrop":"⌍",
"dollar":"$",
"Dopf":"𝔻",
"dopf":"𝕕",
"Dot":"¨",
"dot":"˙",
"DotDot":"⃜",
"doteq":"≐",
"doteqdot":"≑",
"DotEqual":"≐",
"dotminus":"∸",
"dotplus":"∔",
"dotsquare":"⊡",
"doublebarwedge":"⌆",
"DoubleContourIntegral":"∯",
"DoubleDot":"¨",
"DoubleDownArrow":"⇓",
"DoubleLeftArrow":"⇐",
"DoubleLeftRightArrow":"⇔",
"DoubleLeftTee":"⫤",
"DoubleLongLeftArrow":"⟸",
"DoubleLongLeftRightArrow":"⟺",
"DoubleLongRightArrow":"⟹",
"DoubleRightArrow":"⇒",
"DoubleRightTee":"⊨",
"DoubleUpArrow":"⇑",
"DoubleUpDownArrow":"⇕",
"DoubleVerticalBar":"∥",
"DownArrowBar":"⤓",
"downarrow":"↓",
"DownArrow":"↓",
"Downarrow":"⇓",
"DownArrowUpArrow":"⇵",
"DownBreve":"̑",
"downdownarrows":"⇊",
"downharpoonleft":"⇃",
"downharpoonright":"⇂",
"DownLeftRightVector":"⥐",
"DownLeftTeeVector":"⥞",
"DownLeftVectorBar":"⥖",
"DownLeftVector":"↽",
"DownRightTeeVector":"⥟",
"DownRightVectorBar":"⥗",
"DownRightVector":"⇁",
"DownTeeArrow":"↧",
"DownTee":"⊤",
"drbkarow":"⤐",
"drcorn":"⌟",
"drcrop":"⌌",
"Dscr":"𝒟",
"dscr":"𝒹",
"DScy":"Ѕ",
"dscy":"ѕ",
"dsol":"⧶",
"Dstrok":"Đ",
"dstrok":"đ",
"dtdot":"⋱",
"dtri":"▿",
"dtrif":"▾",
"duarr":"⇵",
"duhar":"⥯",
"dwangle":"⦦",
"DZcy":"Џ",
"dzcy":"џ",
"dzigrarr":"⟿",
"Eacute":"É",
"eacute":"é",
"easter":"⩮",
"Ecaron":"Ě",
"ecaron":"ě",
"Ecirc":"Ê",
"ecirc":"ê",
"ecir":"≖",
"ecolon":"≕",
"Ecy":"Э",
"ecy":"э",
"eDDot":"⩷",
"Edot":"Ė",
"edot":"ė",
"eDot":"≑",
"ee":"ⅇ",
"efDot":"≒",
"Efr":"𝔈",
"efr":"𝔢",
"eg":"⪚",
"Egrave":"È",
"egrave":"è",
"egs":"⪖",
"egsdot":"⪘",
"el":"⪙",
"Element":"∈",
"elinters":"⏧",
"ell":"ℓ",
"els":"⪕",
"elsdot":"⪗",
"Emacr":"Ē",
"emacr":"ē",
"empty":"∅",
"emptyset":"∅",
"EmptySmallSquare":"◻",
"emptyv":"∅",
"EmptyVerySmallSquare":"▫",
"emsp13":" ",
"emsp14":" ",
"emsp":" ",
"ENG":"Ŋ",
"eng":"ŋ",
"ensp":" ",
"Eogon":"Ę",
"eogon":"ę",
"Eopf":"𝔼",
"eopf":"𝕖",
"epar":"⋕",
"eparsl":"⧣",
"eplus":"⩱",
"epsi":"ε",
"Epsilon":"Ε",
"epsilon":"ε",
"epsiv":"ϵ",
"eqcirc":"≖",
"eqcolon":"≕",
"eqsim":"≂",
"eqslantgtr":"⪖",
"eqslantless":"⪕",
"Equal":"⩵",
"equals":"=",
"EqualTilde":"≂",
"equest":"≟",
"Equilibrium":"⇌",
"equiv":"≡",
"equivDD":"⩸",
"eqvparsl":"⧥",
"erarr":"⥱",
"erDot":"≓",
"escr":"ℯ",
"Escr":"ℰ",
"esdot":"≐",
"Esim":"⩳",
"esim":"≂",
"Eta":"Η",
"eta":"η",
"ETH":"Ð",
"eth":"ð",
"Euml":"Ë",
"euml":"ë",
"euro":"€",
"excl":"!",
"exist":"∃",
"Exists":"∃",
"expectation":"ℰ",
"exponentiale":"ⅇ",
"ExponentialE":"ⅇ",
"fallingdotseq":"≒",
"Fcy":"Ф",
"fcy":"ф",
"female":"♀",
"ffilig":"ffi",
"fflig":"ff",
"ffllig":"ffl",
"Ffr":"𝔉",
"ffr":"𝔣",
"filig":"fi",
"FilledSmallSquare":"◼",
"FilledVerySmallSquare":"▪",
"fjlig":"fj",
"flat":"♭",
"fllig":"fl",
"fltns":"▱",
"fnof":"ƒ",
"Fopf":"𝔽",
"fopf":"𝕗",
"forall":"∀",
"ForAll":"∀",
"fork":"⋔",
"forkv":"⫙",
"Fouriertrf":"ℱ",
"fpartint":"⨍",
"frac12":"½",
"frac13":"⅓",
"frac14":"¼",
"frac15":"⅕",
"frac16":"⅙",
"frac18":"⅛",
"frac23":"⅔",
"frac25":"⅖",
"frac34":"¾",
"frac35":"⅗",
"frac38":"⅜",
"frac45":"⅘",
"frac56":"⅚",
"frac58":"⅝",
"frac78":"⅞",
"frasl":"⁄",
"frown":"⌢",
"fscr":"𝒻",
"Fscr":"ℱ",
"gacute":"ǵ",
"Gamma":"Γ",
"gamma":"γ",
"Gammad":"Ϝ",
"gammad":"ϝ",
"gap":"⪆",
"Gbreve":"Ğ",
"gbreve":"ğ",
"Gcedil":"Ģ",
"Gcirc":"Ĝ",
"gcirc":"ĝ",
"Gcy":"Г",
"gcy":"г",
"Gdot":"Ġ",
"gdot":"ġ",
"ge":"≥",
"gE":"≧",
"gEl":"⪌",
"gel":"⋛",
"geq":"≥",
"geqq":"≧",
"geqslant":"⩾",
"gescc":"⪩",
"ges":"⩾",
"gesdot":"⪀",
"gesdoto":"⪂",
"gesdotol":"⪄",
"gesl":"⋛︀",
"gesles":"⪔",
"Gfr":"𝔊",
"gfr":"𝔤",
"gg":"≫",
"Gg":"⋙",
"ggg":"⋙",
"gimel":"ℷ",
"GJcy":"Ѓ",
"gjcy":"ѓ",
"gla":"⪥",
"gl":"≷",
"glE":"⪒",
"glj":"⪤",
"gnap":"⪊",
"gnapprox":"⪊",
"gne":"⪈",
"gnE":"≩",
"gneq":"⪈",
"gneqq":"≩",
"gnsim":"⋧",
"Gopf":"𝔾",
"gopf":"𝕘",
"grave":"`",
"GreaterEqual":"≥",
"GreaterEqualLess":"⋛",
"GreaterFullEqual":"≧",
"GreaterGreater":"⪢",
"GreaterLess":"≷",
"GreaterSlantEqual":"⩾",
"GreaterTilde":"≳",
"Gscr":"𝒢",
"gscr":"ℊ",
"gsim":"≳",
"gsime":"⪎",
"gsiml":"⪐",
"gtcc":"⪧",
"gtcir":"⩺",
"gt":">",
"GT":">",
"Gt":"≫",
"gtdot":"⋗",
"gtlPar":"⦕",
"gtquest":"⩼",
"gtrapprox":"⪆",
"gtrarr":"⥸",
"gtrdot":"⋗",
"gtreqless":"⋛",
"gtreqqless":"⪌",
"gtrless":"≷",
"gtrsim":"≳",
"gvertneqq":"≩︀",
"gvnE":"≩︀",
"Hacek":"ˇ",
"hairsp":" ",
"half":"½",
"hamilt":"ℋ",
"HARDcy":"Ъ",
"hardcy":"ъ",
"harrcir":"⥈",
"harr":"↔",
"hArr":"⇔",
"harrw":"↭",
"Hat":"^",
"hbar":"ℏ",
"Hcirc":"Ĥ",
"hcirc":"ĥ",
"hearts":"♥",
"heartsuit":"♥",
"hellip":"…",
"hercon":"⊹",
"hfr":"𝔥",
"Hfr":"ℌ",
"HilbertSpace":"ℋ",
"hksearow":"⤥",
"hkswarow":"⤦",
"hoarr":"⇿",
"homtht":"∻",
"hookleftarrow":"↩",
"hookrightarrow":"↪",
"hopf":"𝕙",
"Hopf":"ℍ",
"horbar":"―",
"HorizontalLine":"─",
"hscr":"𝒽",
"Hscr":"ℋ",
"hslash":"ℏ",
"Hstrok":"Ħ",
"hstrok":"ħ",
"HumpDownHump":"≎",
"HumpEqual":"≏",
"hybull":"⁃",
"hyphen":"‐",
"Iacute":"Í",
"iacute":"í",
"ic":"⁣",
"Icirc":"Î",
"icirc":"î",
"Icy":"И",
"icy":"и",
"Idot":"İ",
"IEcy":"Е",
"iecy":"е",
"iexcl":"¡",
"iff":"⇔",
"ifr":"𝔦",
"Ifr":"ℑ",
"Igrave":"Ì",
"igrave":"ì",
"ii":"ⅈ",
"iiiint":"⨌",
"iiint":"∭",
"iinfin":"⧜",
"iiota":"℩",
"IJlig":"IJ",
"ijlig":"ij",
"Imacr":"Ī",
"imacr":"ī",
"image":"ℑ",
"ImaginaryI":"ⅈ",
"imagline":"ℐ",
"imagpart":"ℑ",
"imath":"ı",
"Im":"ℑ",
"imof":"⊷",
"imped":"Ƶ",
"Implies":"⇒",
"incare":"℅",
"in":"∈",
"infin":"∞",
"infintie":"⧝",
"inodot":"ı",
"intcal":"⊺",
"int":"∫",
"Int":"∬",
"integers":"ℤ",
"Integral":"∫",
"intercal":"⊺",
"Intersection":"⋂",
"intlarhk":"⨗",
"intprod":"⨼",
"InvisibleComma":"⁣",
"InvisibleTimes":"⁢",
"IOcy":"Ё",
"iocy":"ё",
"Iogon":"Į",
"iogon":"į",
"Iopf":"𝕀",
"iopf":"𝕚",
"Iota":"Ι",
"iota":"ι",
"iprod":"⨼",
"iquest":"¿",
"iscr":"𝒾",
"Iscr":"ℐ",
"isin":"∈",
"isindot":"⋵",
"isinE":"⋹",
"isins":"⋴",
"isinsv":"⋳",
"isinv":"∈",
"it":"⁢",
"Itilde":"Ĩ",
"itilde":"ĩ",
"Iukcy":"І",
"iukcy":"і",
"Iuml":"Ï",
"iuml":"ï",
"Jcirc":"Ĵ",
"jcirc":"ĵ",
"Jcy":"Й",
"jcy":"й",
"Jfr":"𝔍",
"jfr":"𝔧",
"jmath":"ȷ",
"Jopf":"𝕁",
"jopf":"𝕛",
"Jscr":"𝒥",
"jscr":"𝒿",
"Jsercy":"Ј",
"jsercy":"ј",
"Jukcy":"Є",
"jukcy":"є",
"Kappa":"Κ",
"kappa":"κ",
"kappav":"ϰ",
"Kcedil":"Ķ",
"kcedil":"ķ",
"Kcy":"К",
"kcy":"к",
"Kfr":"𝔎",
"kfr":"𝔨",
"kgreen":"ĸ",
"KHcy":"Х",
"khcy":"х",
"KJcy":"Ќ",
"kjcy":"ќ",
"Kopf":"𝕂",
"kopf":"𝕜",
"Kscr":"𝒦",
"kscr":"𝓀",
"lAarr":"⇚",
"Lacute":"Ĺ",
"lacute":"ĺ",
"laemptyv":"⦴",
"lagran":"ℒ",
"Lambda":"Λ",
"lambda":"λ",
"lang":"⟨",
"Lang":"⟪",
"langd":"⦑",
"langle":"⟨",
"lap":"⪅",
"Laplacetrf":"ℒ",
"laquo":"«",
"larrb":"⇤",
"larrbfs":"⤟",
"larr":"←",
"Larr":"↞",
"lArr":"⇐",
"larrfs":"⤝",
"larrhk":"↩",
"larrlp":"↫",
"larrpl":"⤹",
"larrsim":"⥳",
"larrtl":"↢",
"latail":"⤙",
"lAtail":"⤛",
"lat":"⪫",
"late":"⪭",
"lates":"⪭︀",
"lbarr":"⤌",
"lBarr":"⤎",
"lbbrk":"❲",
"lbrace":"{",
"lbrack":"[",
"lbrke":"⦋",
"lbrksld":"⦏",
"lbrkslu":"⦍",
"Lcaron":"Ľ",
"lcaron":"ľ",
"Lcedil":"Ļ",
"lcedil":"ļ",
"lceil":"⌈",
"lcub":"{",
"Lcy":"Л",
"lcy":"л",
"ldca":"⤶",
"ldquo":"“",
"ldquor":"„",
"ldrdhar":"⥧",
"ldrushar":"⥋",
"ldsh":"↲",
"le":"≤",
"lE":"≦",
"LeftAngleBracket":"⟨",
"LeftArrowBar":"⇤",
"leftarrow":"←",
"LeftArrow":"←",
"Leftarrow":"⇐",
"LeftArrowRightArrow":"⇆",
"leftarrowtail":"↢",
"LeftCeiling":"⌈",
"LeftDoubleBracket":"⟦",
"LeftDownTeeVector":"⥡",
"LeftDownVectorBar":"⥙",
"LeftDownVector":"⇃",
"LeftFloor":"⌊",
"leftharpoondown":"↽",
"leftharpoonup":"↼",
"leftleftarrows":"⇇",
"leftrightarrow":"↔",
"LeftRightArrow":"↔",
"Leftrightarrow":"⇔",
"leftrightarrows":"⇆",
"leftrightharpoons":"⇋",
"leftrightsquigarrow":"↭",
"LeftRightVector":"⥎",
"LeftTeeArrow":"↤",
"LeftTee":"⊣",
"LeftTeeVector":"⥚",
"leftthreetimes":"⋋",
"LeftTriangleBar":"⧏",
"LeftTriangle":"⊲",
"LeftTriangleEqual":"⊴",
"LeftUpDownVector":"⥑",
"LeftUpTeeVector":"⥠",
"LeftUpVectorBar":"⥘",
"LeftUpVector":"↿",
"LeftVectorBar":"⥒",
"LeftVector":"↼",
"lEg":"⪋",
"leg":"⋚",
"leq":"≤",
"leqq":"≦",
"leqslant":"⩽",
"lescc":"⪨",
"les":"⩽",
"lesdot":"⩿",
"lesdoto":"⪁",
"lesdotor":"⪃",
"lesg":"⋚︀",
"lesges":"⪓",
"lessapprox":"⪅",
"lessdot":"⋖",
"lesseqgtr":"⋚",
"lesseqqgtr":"⪋",
"LessEqualGreater":"⋚",
"LessFullEqual":"≦",
"LessGreater":"≶",
"lessgtr":"≶",
"LessLess":"⪡",
"lesssim":"≲",
"LessSlantEqual":"⩽",
"LessTilde":"≲",
"lfisht":"⥼",
"lfloor":"⌊",
"Lfr":"𝔏",
"lfr":"𝔩",
"lg":"≶",
"lgE":"⪑",
"lHar":"⥢",
"lhard":"↽",
"lharu":"↼",
"lharul":"⥪",
"lhblk":"▄",
"LJcy":"Љ",
"ljcy":"љ",
"llarr":"⇇",
"ll":"≪",
"Ll":"⋘",
"llcorner":"⌞",
"Lleftarrow":"⇚",
"llhard":"⥫",
"lltri":"◺",
"Lmidot":"Ŀ",
"lmidot":"ŀ",
"lmoustache":"⎰",
"lmoust":"⎰",
"lnap":"⪉",
"lnapprox":"⪉",
"lne":"⪇",
"lnE":"≨",
"lneq":"⪇",
"lneqq":"≨",
"lnsim":"⋦",
"loang":"⟬",
"loarr":"⇽",
"lobrk":"⟦",
"longleftarrow":"⟵",
"LongLeftArrow":"⟵",
"Longleftarrow":"⟸",
"longleftrightarrow":"⟷",
"LongLeftRightArrow":"⟷",
"Longleftrightarrow":"⟺",
"longmapsto":"⟼",
"longrightarrow":"⟶",
"LongRightArrow":"⟶",
"Longrightarrow":"⟹",
"looparrowleft":"↫",
"looparrowright":"↬",
"lopar":"⦅",
"Lopf":"𝕃",
"lopf":"𝕝",
"loplus":"⨭",
"lotimes":"⨴",
"lowast":"∗",
"lowbar":"_",
"LowerLeftArrow":"↙",
"LowerRightArrow":"↘",
"loz":"◊",
"lozenge":"◊",
"lozf":"⧫",
"lpar":"(",
"lparlt":"⦓",
"lrarr":"⇆",
"lrcorner":"⌟",
"lrhar":"⇋",
"lrhard":"⥭",
"lrm":"‎",
"lrtri":"⊿",
"lsaquo":"‹",
"lscr":"𝓁",
"Lscr":"ℒ",
"lsh":"↰",
"Lsh":"↰",
"lsim":"≲",
"lsime":"⪍",
"lsimg":"⪏",
"lsqb":"[",
"lsquo":"‘",
"lsquor":"‚",
"Lstrok":"Ł",
"lstrok":"ł",
"ltcc":"⪦",
"ltcir":"⩹",
"lt":"<",
"LT":"<",
"Lt":"≪",
"ltdot":"⋖",
"lthree":"⋋",
"ltimes":"⋉",
"ltlarr":"⥶",
"ltquest":"⩻",
"ltri":"◃",
"ltrie":"⊴",
"ltrif":"◂",
"ltrPar":"⦖",
"lurdshar":"⥊",
"luruhar":"⥦",
"lvertneqq":"≨︀",
"lvnE":"≨︀",
"macr":"¯",
"male":"♂",
"malt":"✠",
"maltese":"✠",
"Map":"⤅",
"map":"↦",
"mapsto":"↦",
"mapstodown":"↧",
"mapstoleft":"↤",
"mapstoup":"↥",
"marker":"▮",
"mcomma":"⨩",
"Mcy":"М",
"mcy":"м",
"mdash":"—",
"mDDot":"∺",
"measuredangle":"∡",
"MediumSpace":" ",
"Mellintrf":"ℳ",
"Mfr":"𝔐",
"mfr":"𝔪",
"mho":"℧",
"micro":"µ",
"midast":"*",
"midcir":"⫰",
"mid":"∣",
"middot":"·",
"minusb":"⊟",
"minus":"−",
"minusd":"∸",
"minusdu":"⨪",
"MinusPlus":"∓",
"mlcp":"⫛",
"mldr":"…",
"mnplus":"∓",
"models":"⊧",
"Mopf":"𝕄",
"mopf":"𝕞",
"mp":"∓",
"mscr":"𝓂",
"Mscr":"ℳ",
"mstpos":"∾",
"Mu":"Μ",
"mu":"μ",
"multimap":"⊸",
"mumap":"⊸",
"nabla":"∇",
"Nacute":"Ń",
"nacute":"ń",
"nang":"∠⃒",
"nap":"≉",
"napE":"⩰̸",
"napid":"≋̸",
"napos":"ʼn",
"napprox":"≉",
"natural":"♮",
"naturals":"ℕ",
"natur":"♮",
"nbsp":" ",
"nbump":"≎̸",
"nbumpe":"≏̸",
"ncap":"⩃",
"Ncaron":"Ň",
"ncaron":"ň",
"Ncedil":"Ņ",
"ncedil":"ņ",
"ncong":"≇",
"ncongdot":"⩭̸",
"ncup":"⩂",
"Ncy":"Н",
"ncy":"н",
"ndash":"–",
"nearhk":"⤤",
"nearr":"↗",
"neArr":"⇗",
"nearrow":"↗",
"ne":"≠",
"nedot":"≐̸",
"NegativeMediumSpace":"​",
"NegativeThickSpace":"​",
"NegativeThinSpace":"​",
"NegativeVeryThinSpace":"​",
"nequiv":"≢",
"nesear":"⤨",
"nesim":"≂̸",
"NestedGreaterGreater":"≫",
"NestedLessLess":"≪",
"NewLine":"\n",
"nexist":"∄",
"nexists":"∄",
"Nfr":"𝔑",
"nfr":"𝔫",
"ngE":"≧̸",
"nge":"≱",
"ngeq":"≱",
"ngeqq":"≧̸",
"ngeqslant":"⩾̸",
"nges":"⩾̸",
"nGg":"⋙̸",
"ngsim":"≵",
"nGt":"≫⃒",
"ngt":"≯",
"ngtr":"≯",
"nGtv":"≫̸",
"nharr":"↮",
"nhArr":"⇎",
"nhpar":"⫲",
"ni":"∋",
"nis":"⋼",
"nisd":"⋺",
"niv":"∋",
"NJcy":"Њ",
"njcy":"њ",
"nlarr":"↚",
"nlArr":"⇍",
"nldr":"‥",
"nlE":"≦̸",
"nle":"≰",
"nleftarrow":"↚",
"nLeftarrow":"⇍",
"nleftrightarrow":"↮",
"nLeftrightarrow":"⇎",
"nleq":"≰",
"nleqq":"≦̸",
"nleqslant":"⩽̸",
"nles":"⩽̸",
"nless":"≮",
"nLl":"⋘̸",
"nlsim":"≴",
"nLt":"≪⃒",
"nlt":"≮",
"nltri":"⋪",
"nltrie":"⋬",
"nLtv":"≪̸",
"nmid":"∤",
"NoBreak":"⁠",
"NonBreakingSpace":" ",
"nopf":"𝕟",
"Nopf":"ℕ",
"Not":"⫬",
"not":"¬",
"NotCongruent":"≢",
"NotCupCap":"≭",
"NotDoubleVerticalBar":"∦",
"NotElement":"∉",
"NotEqual":"≠",
"NotEqualTilde":"≂̸",
"NotExists":"∄",
"NotGreater":"≯",
"NotGreaterEqual":"≱",
"NotGreaterFullEqual":"≧̸",
"NotGreaterGreater":"≫̸",
"NotGreaterLess":"≹",
"NotGreaterSlantEqual":"⩾̸",
"NotGreaterTilde":"≵",
"NotHumpDownHump":"≎̸",
"NotHumpEqual":"≏̸",
"notin":"∉",
"notindot":"⋵̸",
"notinE":"⋹̸",
"notinva":"∉",
"notinvb":"⋷",
"notinvc":"⋶",
"NotLeftTriangleBar":"⧏̸",
"NotLeftTriangle":"⋪",
"NotLeftTriangleEqual":"⋬",
"NotLess":"≮",
"NotLessEqual":"≰",
"NotLessGreater":"≸",
"NotLessLess":"≪̸",
"NotLessSlantEqual":"⩽̸",
"NotLessTilde":"≴",
"NotNestedGreaterGreater":"⪢̸",
"NotNestedLessLess":"⪡̸",
"notni":"∌",
"notniva":"∌",
"notnivb":"⋾",
"notnivc":"⋽",
"NotPrecedes":"⊀",
"NotPrecedesEqual":"⪯̸",
"NotPrecedesSlantEqual":"⋠",
"NotReverseElement":"∌",
"NotRightTriangleBar":"⧐̸",
"NotRightTriangle":"⋫",
"NotRightTriangleEqual":"⋭",
"NotSquareSubset":"⊏̸",
"NotSquareSubsetEqual":"⋢",
"NotSquareSuperset":"⊐̸",
"NotSquareSupersetEqual":"⋣",
"NotSubset":"⊂⃒",
"NotSubsetEqual":"⊈",
"NotSucceeds":"⊁",
"NotSucceedsEqual":"⪰̸",
"NotSucceedsSlantEqual":"⋡",
"NotSucceedsTilde":"≿̸",
"NotSuperset":"⊃⃒",
"NotSupersetEqual":"⊉",
"NotTilde":"≁",
"NotTildeEqual":"≄",
"NotTildeFullEqual":"≇",
"NotTildeTilde":"≉",
"NotVerticalBar":"∤",
"nparallel":"∦",
"npar":"∦",
"nparsl":"⫽⃥",
"npart":"∂̸",
"npolint":"⨔",
"npr":"⊀",
"nprcue":"⋠",
"nprec":"⊀",
"npreceq":"⪯̸",
"npre":"⪯̸",
"nrarrc":"⤳̸",
"nrarr":"↛",
"nrArr":"⇏",
"nrarrw":"↝̸",
"nrightarrow":"↛",
"nRightarrow":"⇏",
"nrtri":"⋫",
"nrtrie":"⋭",
"nsc":"⊁",
"nsccue":"⋡",
"nsce":"⪰̸",
"Nscr":"𝒩",
"nscr":"𝓃",
"nshortmid":"∤",
"nshortparallel":"∦",
"nsim":"≁",
"nsime":"≄",
"nsimeq":"≄",
"nsmid":"∤",
"nspar":"∦",
"nsqsube":"⋢",
"nsqsupe":"⋣",
"nsub":"⊄",
"nsubE":"⫅̸",
"nsube":"⊈",
"nsubset":"⊂⃒",
"nsubseteq":"⊈",
"nsubseteqq":"⫅̸",
"nsucc":"⊁",
"nsucceq":"⪰̸",
"nsup":"⊅",
"nsupE":"⫆̸",
"nsupe":"⊉",
"nsupset":"⊃⃒",
"nsupseteq":"⊉",
"nsupseteqq":"⫆̸",
"ntgl":"≹",
"Ntilde":"Ñ",
"ntilde":"ñ",
"ntlg":"≸",
"ntriangleleft":"⋪",
"ntrianglelefteq":"⋬",
"ntriangleright":"⋫",
"ntrianglerighteq":"⋭",
"Nu":"Ν",
"nu":"ν",
"num":"#",
"numero":"№",
"numsp":" ",
"nvap":"≍⃒",
"nvdash":"⊬",
"nvDash":"⊭",
"nVdash":"⊮",
"nVDash":"⊯",
"nvge":"≥⃒",
"nvgt":">⃒",
"nvHarr":"⤄",
"nvinfin":"⧞",
"nvlArr":"⤂",
"nvle":"≤⃒",
"nvlt":"<⃒",
"nvltrie":"⊴⃒",
"nvrArr":"⤃",
"nvrtrie":"⊵⃒",
"nvsim":"∼⃒",
"nwarhk":"⤣",
"nwarr":"↖",
"nwArr":"⇖",
"nwarrow":"↖",
"nwnear":"⤧",
"Oacute":"Ó",
"oacute":"ó",
"oast":"⊛",
"Ocirc":"Ô",
"ocirc":"ô",
"ocir":"⊚",
"Ocy":"О",
"ocy":"о",
"odash":"⊝",
"Odblac":"Ő",
"odblac":"ő",
"odiv":"⨸",
"odot":"⊙",
"odsold":"⦼",
"OElig":"Œ",
"oelig":"œ",
"ofcir":"⦿",
"Ofr":"𝔒",
"ofr":"𝔬",
"ogon":"˛",
"Ograve":"Ò",
"ograve":"ò",
"ogt":"⧁",
"ohbar":"⦵",
"ohm":"Ω",
"oint":"∮",
"olarr":"↺",
"olcir":"⦾",
"olcross":"⦻",
"oline":"‾",
"olt":"⧀",
"Omacr":"Ō",
"omacr":"ō",
"Omega":"Ω",
"omega":"ω",
"Omicron":"Ο",
"omicron":"ο",
"omid":"⦶",
"ominus":"⊖",
"Oopf":"𝕆",
"oopf":"𝕠",
"opar":"⦷",
"OpenCurlyDoubleQuote":"“",
"OpenCurlyQuote":"‘",
"operp":"⦹",
"oplus":"⊕",
"orarr":"↻",
"Or":"⩔",
"or":"∨",
"ord":"⩝",
"order":"ℴ",
"orderof":"ℴ",
"ordf":"ª",
"ordm":"º",
"origof":"⊶",
"oror":"⩖",
"orslope":"⩗",
"orv":"⩛",
"oS":"Ⓢ",
"Oscr":"𝒪",
"oscr":"ℴ",
"Oslash":"Ø",
"oslash":"ø",
"osol":"⊘",
"Otilde":"Õ",
"otilde":"õ",
"otimesas":"⨶",
"Otimes":"⨷",
"otimes":"⊗",
"Ouml":"Ö",
"ouml":"ö",
"ovbar":"⌽",
"OverBar":"‾",
"OverBrace":"⏞",
"OverBracket":"⎴",
"OverParenthesis":"⏜",
"para":"¶",
"parallel":"∥",
"par":"∥",
"parsim":"⫳",
"parsl":"⫽",
"part":"∂",
"PartialD":"∂",
"Pcy":"П",
"pcy":"п",
"percnt":"%",
"period":".",
"permil":"‰",
"perp":"⊥",
"pertenk":"‱",
"Pfr":"𝔓",
"pfr":"𝔭",
"Phi":"Φ",
"phi":"φ",
"phiv":"ϕ",
"phmmat":"ℳ",
"phone":"☎",
"Pi":"Π",
"pi":"π",
"pitchfork":"⋔",
"piv":"ϖ",
"planck":"ℏ",
"planckh":"ℎ",
"plankv":"ℏ",
"plusacir":"⨣",
"plusb":"⊞",
"pluscir":"⨢",
"plus":"+",
"plusdo":"∔",
"plusdu":"⨥",
"pluse":"⩲",
"PlusMinus":"±",
"plusmn":"±",
"plussim":"⨦",
"plustwo":"⨧",
"pm":"±",
"Poincareplane":"ℌ",
"pointint":"⨕",
"popf":"𝕡",
"Popf":"ℙ",
"pound":"£",
"prap":"⪷",
"Pr":"⪻",
"pr":"≺",
"prcue":"≼",
"precapprox":"⪷",
"prec":"≺",
"preccurlyeq":"≼",
"Precedes":"≺",
"PrecedesEqual":"⪯",
"PrecedesSlantEqual":"≼",
"PrecedesTilde":"≾",
"preceq":"⪯",
"precnapprox":"⪹",
"precneqq":"⪵",
"precnsim":"⋨",
"pre":"⪯",
"prE":"⪳",
"precsim":"≾",
"prime":"′",
"Prime":"″",
"primes":"ℙ",
"prnap":"⪹",
"prnE":"⪵",
"prnsim":"⋨",
"prod":"∏",
"Product":"∏",
"profalar":"⌮",
"profline":"⌒",
"profsurf":"⌓",
"prop":"∝",
"Proportional":"∝",
"Proportion":"∷",
"propto":"∝",
"prsim":"≾",
"prurel":"⊰",
"Pscr":"𝒫",
"pscr":"𝓅",
"Psi":"Ψ",
"psi":"ψ",
"puncsp":" ",
"Qfr":"𝔔",
"qfr":"𝔮",
"qint":"⨌",
"qopf":"𝕢",
"Qopf":"ℚ",
"qprime":"⁗",
"Qscr":"𝒬",
"qscr":"𝓆",
"quaternions":"ℍ",
"quatint":"⨖",
"quest":"?",
"questeq":"≟",
"quot":"\"",
"QUOT":"\"",
"rAarr":"⇛",
"race":"∽̱",
"Racute":"Ŕ",
"racute":"ŕ",
"radic":"√",
"raemptyv":"⦳",
"rang":"⟩",
"Rang":"⟫",
"rangd":"⦒",
"range":"⦥",
"rangle":"⟩",
"raquo":"»",
"rarrap":"⥵",
"rarrb":"⇥",
"rarrbfs":"⤠",
"rarrc":"⤳",
"rarr":"→",
"Rarr":"↠",
"rArr":"⇒",
"rarrfs":"⤞",
"rarrhk":"↪",
"rarrlp":"↬",
"rarrpl":"⥅",
"rarrsim":"⥴",
"Rarrtl":"⤖",
"rarrtl":"↣",
"rarrw":"↝",
"ratail":"⤚",
"rAtail":"⤜",
"ratio":"∶",
"rationals":"ℚ",
"rbarr":"⤍",
"rBarr":"⤏",
"RBarr":"⤐",
"rbbrk":"❳",
"rbrace":"}",
"rbrack":"]",
"rbrke":"⦌",
"rbrksld":"⦎",
"rbrkslu":"⦐",
"Rcaron":"Ř",
"rcaron":"ř",
"Rcedil":"Ŗ",
"rcedil":"ŗ",
"rceil":"⌉",
"rcub":"}",
"Rcy":"Р",
"rcy":"р",
"rdca":"⤷",
"rdldhar":"⥩",
"rdquo":"”",
"rdquor":"”",
"rdsh":"↳",
"real":"ℜ",
"realine":"ℛ",
"realpart":"ℜ",
"reals":"ℝ",
"Re":"ℜ",
"rect":"▭",
"reg":"®",
"REG":"®",
"ReverseElement":"∋",
"ReverseEquilibrium":"⇋",
"ReverseUpEquilibrium":"⥯",
"rfisht":"⥽",
"rfloor":"⌋",
"rfr":"𝔯",
"Rfr":"ℜ",
"rHar":"⥤",
"rhard":"⇁",
"rharu":"⇀",
"rharul":"⥬",
"Rho":"Ρ",
"rho":"ρ",
"rhov":"ϱ",
"RightAngleBracket":"⟩",
"RightArrowBar":"⇥",
"rightarrow":"→",
"RightArrow":"→",
"Rightarrow":"⇒",
"RightArrowLeftArrow":"⇄",
"rightarrowtail":"↣",
"RightCeiling":"⌉",
"RightDoubleBracket":"⟧",
"RightDownTeeVector":"⥝",
"RightDownVectorBar":"⥕",
"RightDownVector":"⇂",
"RightFloor":"⌋",
"rightharpoondown":"⇁",
"rightharpoonup":"⇀",
"rightleftarrows":"⇄",
"rightleftharpoons":"⇌",
"rightrightarrows":"⇉",
"rightsquigarrow":"↝",
"RightTeeArrow":"↦",
"RightTee":"⊢",
"RightTeeVector":"⥛",
"rightthreetimes":"⋌",
"RightTriangleBar":"⧐",
"RightTriangle":"⊳",
"RightTriangleEqual":"⊵",
"RightUpDownVector":"⥏",
"RightUpTeeVector":"⥜",
"RightUpVectorBar":"⥔",
"RightUpVector":"↾",
"RightVectorBar":"⥓",
"RightVector":"⇀",
"ring":"˚",
"risingdotseq":"≓",
"rlarr":"⇄",
"rlhar":"⇌",
"rlm":"‏",
"rmoustache":"⎱",
"rmoust":"⎱",
"rnmid":"⫮",
"roang":"⟭",
"roarr":"⇾",
"robrk":"⟧",
"ropar":"⦆",
"ropf":"𝕣",
"Ropf":"ℝ",
"roplus":"⨮",
"rotimes":"⨵",
"RoundImplies":"⥰",
"rpar":")",
"rpargt":"⦔",
"rppolint":"⨒",
"rrarr":"⇉",
"Rrightarrow":"⇛",
"rsaquo":"›",
"rscr":"𝓇",
"Rscr":"ℛ",
"rsh":"↱",
"Rsh":"↱",
"rsqb":"]",
"rsquo":"’",
"rsquor":"’",
"rthree":"⋌",
"rtimes":"⋊",
"rtri":"▹",
"rtrie":"⊵",
"rtrif":"▸",
"rtriltri":"⧎",
"RuleDelayed":"⧴",
"ruluhar":"⥨",
"rx":"℞",
"Sacute":"Ś",
"sacute":"ś",
"sbquo":"‚",
"scap":"⪸",
"Scaron":"Š",
"scaron":"š",
"Sc":"⪼",
"sc":"≻",
"sccue":"≽",
"sce":"⪰",
"scE":"⪴",
"Scedil":"Ş",
"scedil":"ş",
"Scirc":"Ŝ",
"scirc":"ŝ",
"scnap":"⪺",
"scnE":"⪶",
"scnsim":"⋩",
"scpolint":"⨓",
"scsim":"≿",
"Scy":"С",
"scy":"с",
"sdotb":"⊡",
"sdot":"⋅",
"sdote":"⩦",
"searhk":"⤥",
"searr":"↘",
"seArr":"⇘",
"searrow":"↘",
"sect":"§",
"semi":";",
"seswar":"⤩",
"setminus":"∖",
"setmn":"∖",
"sext":"✶",
"Sfr":"𝔖",
"sfr":"𝔰",
"sfrown":"⌢",
"sharp":"♯",
"SHCHcy":"Щ",
"shchcy":"щ",
"SHcy":"Ш",
"shcy":"ш",
"ShortDownArrow":"↓",
"ShortLeftArrow":"←",
"shortmid":"∣",
"shortparallel":"∥",
"ShortRightArrow":"→",
"ShortUpArrow":"↑",
"shy":"­",
"Sigma":"Σ",
"sigma":"σ",
"sigmaf":"ς",
"sigmav":"ς",
"sim":"∼",
"simdot":"⩪",
"sime":"≃",
"simeq":"≃",
"simg":"⪞",
"simgE":"⪠",
"siml":"⪝",
"simlE":"⪟",
"simne":"≆",
"simplus":"⨤",
"simrarr":"⥲",
"slarr":"←",
"SmallCircle":"∘",
"smallsetminus":"∖",
"smashp":"⨳",
"smeparsl":"⧤",
"smid":"∣",
"smile":"⌣",
"smt":"⪪",
"smte":"⪬",
"smtes":"⪬︀",
"SOFTcy":"Ь",
"softcy":"ь",
"solbar":"⌿",
"solb":"⧄",
"sol":"/",
"Sopf":"𝕊",
"sopf":"𝕤",
"spades":"♠",
"spadesuit":"♠",
"spar":"∥",
"sqcap":"⊓",
"sqcaps":"⊓︀",
"sqcup":"⊔",
"sqcups":"⊔︀",
"Sqrt":"√",
"sqsub":"⊏",
"sqsube":"⊑",
"sqsubset":"⊏",
"sqsubseteq":"⊑",
"sqsup":"⊐",
"sqsupe":"⊒",
"sqsupset":"⊐",
"sqsupseteq":"⊒",
"square":"□",
"Square":"□",
"SquareIntersection":"⊓",
"SquareSubset":"⊏",
"SquareSubsetEqual":"⊑",
"SquareSuperset":"⊐",
"SquareSupersetEqual":"⊒",
"SquareUnion":"⊔",
"squarf":"▪",
"squ":"□",
"squf":"▪",
"srarr":"→",
"Sscr":"𝒮",
"sscr":"𝓈",
"ssetmn":"∖",
"ssmile":"⌣",
"sstarf":"⋆",
"Star":"⋆",
"star":"☆",
"starf":"★",
"straightepsilon":"ϵ",
"straightphi":"ϕ",
"strns":"¯",
"sub":"⊂",
"Sub":"⋐",
"subdot":"⪽",
"subE":"⫅",
"sube":"⊆",
"subedot":"⫃",
"submult":"⫁",
"subnE":"⫋",
"subne":"⊊",
"subplus":"⪿",
"subrarr":"⥹",
"subset":"⊂",
"Subset":"⋐",
"subseteq":"⊆",
"subseteqq":"⫅",
"SubsetEqual":"⊆",
"subsetneq":"⊊",
"subsetneqq":"⫋",
"subsim":"⫇",
"subsub":"⫕",
"subsup":"⫓",
"succapprox":"⪸",
"succ":"≻",
"succcurlyeq":"≽",
"Succeeds":"≻",
"SucceedsEqual":"⪰",
"SucceedsSlantEqual":"≽",
"SucceedsTilde":"≿",
"succeq":"⪰",
"succnapprox":"⪺",
"succneqq":"⪶",
"succnsim":"⋩",
"succsim":"≿",
"SuchThat":"∋",
"sum":"∑",
"Sum":"∑",
"sung":"♪",
"sup1":"¹",
"sup2":"²",
"sup3":"³",
"sup":"⊃",
"Sup":"⋑",
"supdot":"⪾",
"supdsub":"⫘",
"supE":"⫆",
"supe":"⊇",
"supedot":"⫄",
"Superset":"⊃",
"SupersetEqual":"⊇",
"suphsol":"⟉",
"suphsub":"⫗",
"suplarr":"⥻",
"supmult":"⫂",
"supnE":"⫌",
"supne":"⊋",
"supplus":"⫀",
"supset":"⊃",
"Supset":"⋑",
"supseteq":"⊇",
"supseteqq":"⫆",
"supsetneq":"⊋",
"supsetneqq":"⫌",
"supsim":"⫈",
"supsub":"⫔",
"supsup":"⫖",
"swarhk":"⤦",
"swarr":"↙",
"swArr":"⇙",
"swarrow":"↙",
"swnwar":"⤪",
"szlig":"ß",
"Tab":"\t",
"target":"⌖",
"Tau":"Τ",
"tau":"τ",
"tbrk":"⎴",
"Tcaron":"Ť",
"tcaron":"ť",
"Tcedil":"Ţ",
"tcedil":"ţ",
"Tcy":"Т",
"tcy":"т",
"tdot":"⃛",
"telrec":"⌕",
"Tfr":"𝔗",
"tfr":"𝔱",
"there4":"∴",
"therefore":"∴",
"Therefore":"∴",
"Theta":"Θ",
"theta":"θ",
"thetasym":"ϑ",
"thetav":"ϑ",
"thickapprox":"≈",
"thicksim":"∼",
"ThickSpace":"  ",
"ThinSpace":" ",
"thinsp":" ",
"thkap":"≈",
"thksim":"∼",
"THORN":"Þ",
"thorn":"þ",
"tilde":"˜",
"Tilde":"∼",
"TildeEqual":"≃",
"TildeFullEqual":"≅",
"TildeTilde":"≈",
"timesbar":"⨱",
"timesb":"⊠",
"times":"×",
"timesd":"⨰",
"tint":"∭",
"toea":"⤨",
"topbot":"⌶",
"topcir":"⫱",
"top":"⊤",
"Topf":"𝕋",
"topf":"𝕥",
"topfork":"⫚",
"tosa":"⤩",
"tprime":"‴",
"trade":"™",
"TRADE":"™",
"triangle":"▵",
"triangledown":"▿",
"triangleleft":"◃",
"trianglelefteq":"⊴",
"triangleq":"≜",
"triangleright":"▹",
"trianglerighteq":"⊵",
"tridot":"◬",
"trie":"≜",
"triminus":"⨺",
"TripleDot":"⃛",
"triplus":"⨹",
"trisb":"⧍",
"tritime":"⨻",
"trpezium":"⏢",
"Tscr":"𝒯",
"tscr":"𝓉",
"TScy":"Ц",
"tscy":"ц",
"TSHcy":"Ћ",
"tshcy":"ћ",
"Tstrok":"Ŧ",
"tstrok":"ŧ",
"twixt":"≬",
"twoheadleftarrow":"↞",
"twoheadrightarrow":"↠",
"Uacute":"Ú",
"uacute":"ú",
"uarr":"↑",
"Uarr":"↟",
"uArr":"⇑",
"Uarrocir":"⥉",
"Ubrcy":"Ў",
"ubrcy":"ў",
"Ubreve":"Ŭ",
"ubreve":"ŭ",
"Ucirc":"Û",
"ucirc":"û",
"Ucy":"У",
"ucy":"у",
"udarr":"⇅",
"Udblac":"Ű",
"udblac":"ű",
"udhar":"⥮",
"ufisht":"⥾",
"Ufr":"𝔘",
"ufr":"𝔲",
"Ugrave":"Ù",
"ugrave":"ù",
"uHar":"⥣",
"uharl":"↿",
"uharr":"↾",
"uhblk":"▀",
"ulcorn":"⌜",
"ulcorner":"⌜",
"ulcrop":"⌏",
"ultri":"◸",
"Umacr":"Ū",
"umacr":"ū",
"uml":"¨",
"UnderBar":"_",
"UnderBrace":"⏟",
"UnderBracket":"⎵",
"UnderParenthesis":"⏝",
"Union":"⋃",
"UnionPlus":"⊎",
"Uogon":"Ų",
"uogon":"ų",
"Uopf":"𝕌",
"uopf":"𝕦",
"UpArrowBar":"⤒",
"uparrow":"↑",
"UpArrow":"↑",
"Uparrow":"⇑",
"UpArrowDownArrow":"⇅",
"updownarrow":"↕",
"UpDownArrow":"↕",
"Updownarrow":"⇕",
"UpEquilibrium":"⥮",
"upharpoonleft":"↿",
"upharpoonright":"↾",
"uplus":"⊎",
"UpperLeftArrow":"↖",
"UpperRightArrow":"↗",
"upsi":"υ",
"Upsi":"ϒ",
"upsih":"ϒ",
"Upsilon":"Υ",
"upsilon":"υ",
"UpTeeArrow":"↥",
"UpTee":"⊥",
"upuparrows":"⇈",
"urcorn":"⌝",
"urcorner":"⌝",
"urcrop":"⌎",
"Uring":"Ů",
"uring":"ů",
"urtri":"◹",
"Uscr":"𝒰",
"uscr":"𝓊",
"utdot":"⋰",
"Utilde":"Ũ",
"utilde":"ũ",
"utri":"▵",
"utrif":"▴",
"uuarr":"⇈",
"Uuml":"Ü",
"uuml":"ü",
"uwangle":"⦧",
"vangrt":"⦜",
"varepsilon":"ϵ",
"varkappa":"ϰ",
"varnothing":"∅",
"varphi":"ϕ",
"varpi":"ϖ",
"varpropto":"∝",
"varr":"↕",
"vArr":"⇕",
"varrho":"ϱ",
"varsigma":"ς",
"varsubsetneq":"⊊︀",
"varsubsetneqq":"⫋︀",
"varsupsetneq":"⊋︀",
"varsupsetneqq":"⫌︀",
"vartheta":"ϑ",
"vartriangleleft":"⊲",
"vartriangleright":"⊳",
"vBar":"⫨",
"Vbar":"⫫",
"vBarv":"⫩",
"Vcy":"В",
"vcy":"в",
"vdash":"⊢",
"vDash":"⊨",
"Vdash":"⊩",
"VDash":"⊫",
"Vdashl":"⫦",
"veebar":"⊻",
"vee":"∨",
"Vee":"⋁",
"veeeq":"≚",
"vellip":"⋮",
"verbar":"|",
"Verbar":"‖",
"vert":"|",
"Vert":"‖",
"VerticalBar":"∣",
"VerticalLine":"|",
"VerticalSeparator":"❘",
"VerticalTilde":"≀",
"VeryThinSpace":" ",
"Vfr":"𝔙",
"vfr":"𝔳",
"vltri":"⊲",
"vnsub":"⊂⃒",
"vnsup":"⊃⃒",
"Vopf":"𝕍",
"vopf":"𝕧",
"vprop":"∝",
"vrtri":"⊳",
"Vscr":"𝒱",
"vscr":"𝓋",
"vsubnE":"⫋︀",
"vsubne":"⊊︀",
"vsupnE":"⫌︀",
"vsupne":"⊋︀",
"Vvdash":"⊪",
"vzigzag":"⦚",
"Wcirc":"Ŵ",
"wcirc":"ŵ",
"wedbar":"⩟",
"wedge":"∧",
"Wedge":"⋀",
"wedgeq":"≙",
"weierp":"℘",
"Wfr":"𝔚",
"wfr":"𝔴",
"Wopf":"𝕎",
"wopf":"𝕨",
"wp":"℘",
"wr":"≀",
"wreath":"≀",
"Wscr":"𝒲",
"wscr":"𝓌",
"xcap":"⋂",
"xcirc":"◯",
"xcup":"⋃",
"xdtri":"▽",
"Xfr":"𝔛",
"xfr":"𝔵",
"xharr":"⟷",
"xhArr":"⟺",
"Xi":"Ξ",
"xi":"ξ",
"xlarr":"⟵",
"xlArr":"⟸",
"xmap":"⟼",
"xnis":"⋻",
"xodot":"⨀",
"Xopf":"𝕏",
"xopf":"𝕩",
"xoplus":"⨁",
"xotime":"⨂",
"xrarr":"⟶",
"xrArr":"⟹",
"Xscr":"𝒳",
"xscr":"𝓍",
"xsqcup":"⨆",
"xuplus":"⨄",
"xutri":"△",
"xvee":"⋁",
"xwedge":"⋀",
"Yacute":"Ý",
"yacute":"ý",
"YAcy":"Я",
"yacy":"я",
"Ycirc":"Ŷ",
"ycirc":"ŷ",
"Ycy":"Ы",
"ycy":"ы",
"yen":"¥",
"Yfr":"𝔜",
"yfr":"𝔶",
"YIcy":"Ї",
"yicy":"ї",
"Yopf":"𝕐",
"yopf":"𝕪",
"Yscr":"𝒴",
"yscr":"𝓎",
"YUcy":"Ю",
"yucy":"ю",
"yuml":"ÿ",
"Yuml":"Ÿ",
"Zacute":"Ź",
"zacute":"ź",
"Zcaron":"Ž",
"zcaron":"ž",
"Zcy":"З",
"zcy":"з",
"Zdot":"Ż",
"zdot":"ż",
"zeetrf":"ℨ",
"ZeroWidthSpace":"​",
"Zeta":"Ζ",
"zeta":"ζ",
"zfr":"𝔷",
"Zfr":"ℨ",
"ZHcy":"Ж",
"zhcy":"ж",
"zigrarr":"⇝",
"zopf":"𝕫",
"Zopf":"ℤ",
"Zscr":"𝒵",
"zscr":"𝓏",
"zwj":"‍",
"zwnj":"‌"};},

{}],
27:[function(_dereq_,module,exports){
module.exports = {
"Aacute":"Á",
"aacute":"á",
"Acirc":"Â",
"acirc":"â",
"acute":"´",
"AElig":"Æ",
"aelig":"æ",
"Agrave":"À",
"agrave":"à",
"amp":"&",
"AMP":"&",
"Aring":"Å",
"aring":"å",
"Atilde":"Ã",
"atilde":"ã",
"Auml":"Ä",
"auml":"ä",
"brvbar":"¦",
"Ccedil":"Ç",
"ccedil":"ç",
"cedil":"¸",
"cent":"¢",
"copy":"©",
"COPY":"©",
"curren":"¤",
"deg":"°",
"divide":"÷",
"Eacute":"É",
"eacute":"é",
"Ecirc":"Ê",
"ecirc":"ê",
"Egrave":"È",
"egrave":"è",
"ETH":"Ð",
"eth":"ð",
"Euml":"Ë",
"euml":"ë",
"frac12":"½",
"frac14":"¼",
"frac34":"¾",
"gt":">",
"GT":">",
"Iacute":"Í",
"iacute":"í",
"Icirc":"Î",
"icirc":"î",
"iexcl":"¡",
"Igrave":"Ì",
"igrave":"ì",
"iquest":"¿",
"Iuml":"Ï",
"iuml":"ï",
"laquo":"«",
"lt":"<",
"LT":"<",
"macr":"¯",
"micro":"µ",
"middot":"·",
"nbsp":" ",
"not":"¬",
"Ntilde":"Ñ",
"ntilde":"ñ",
"Oacute":"Ó",
"oacute":"ó",
"Ocirc":"Ô",
"ocirc":"ô",
"Ograve":"Ò",
"ograve":"ò",
"ordf":"ª",
"ordm":"º",
"Oslash":"Ø",
"oslash":"ø",
"Otilde":"Õ",
"otilde":"õ",
"Ouml":"Ö",
"ouml":"ö",
"para":"¶",
"plusmn":"±",
"pound":"£",
"quot":"\"",
"QUOT":"\"",
"raquo":"»",
"reg":"®",
"REG":"®",
"sect":"§",
"shy":"­",
"sup1":"¹",
"sup2":"²",
"sup3":"³",
"szlig":"ß",
"THORN":"Þ",
"thorn":"þ",
"times":"×",
"Uacute":"Ú",
"uacute":"ú",
"Ucirc":"Û",
"ucirc":"û",
"Ugrave":"Ù",
"ugrave":"ù",
"uml":"¨",
"Uuml":"Ü",
"uuml":"ü",
"Yacute":"Ý",
"yacute":"ý",
"yen":"¥",
"yuml":"ÿ"};},

{}],
28:[function(_dereq_,module,exports){
module.exports = {"amp":"&","apos":"'","gt":">","lt":"<","quot":"\""};},

{}],
29:[function(_dereq_,module,exports){
arguments[4][23][0].apply(exports,arguments);},
{"../maps/decode.json":30,"dup":23}],
30:[function(_dereq_,module,exports){
arguments[4][25][0].apply(exports,arguments);},
{"dup":25}],
31:[function(_dereq_,module,exports){
arguments[4][26][0].apply(exports,arguments);},
{"dup":26}],
32:[function(_dereq_,module,exports){
arguments[4][27][0].apply(exports,arguments);},
{"dup":27}],
33:[function(_dereq_,module,exports){
arguments[4][28][0].apply(exports,arguments);},
{"dup":28}],
34:[function(_dereq_,module,exports){},

{}],
35:[function(_dereq_,module,exports){







var base64=_dereq_("base64-js");
var ieee754=_dereq_("ieee754");
var isArray=_dereq_("is-array");

exports.Buffer = Buffer;
exports.SlowBuffer = SlowBuffer;
exports.INSPECT_MAX_BYTES = 50;
Buffer.poolSize = 8192;

var kMaxLength=0x3fffffff;
var rootParent={};























Buffer.TYPED_ARRAY_SUPPORT = (function(){
try{
var buf=new ArrayBuffer(0);
var arr=new Uint8Array(buf);
arr.foo = function(){
return 42;};

return arr.foo() === 42 && 
typeof arr.subarray === "function" && 
new Uint8Array(1).subarray(1,1).byteLength === 0;}
catch(e) {
return false;}})();















function Buffer(subject,encoding){
var self=this;
if(!(self instanceof Buffer))return new Buffer(subject,encoding);

var type=typeof subject;
var length;

if(type === "number"){
length = +subject;}else 
if(type === "string"){
length = Buffer.byteLength(subject,encoding);}else 
if(type === "object" && subject !== null){

if(subject.type === "Buffer" && isArray(subject.data))subject = subject.data;
length = +subject.length;}else 
{
throw new TypeError("must start with number, buffer, array or string");}


if(length > kMaxLength){
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + 
kMaxLength.toString(16) + " bytes");}


if(length < 0)length = 0;else 
length >>>= 0;

if(Buffer.TYPED_ARRAY_SUPPORT){

self = Buffer._augment(new Uint8Array(length));}else 
{

self.length = length;
self._isBuffer = true;}


var i;
if(Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === "number"){

self._set(subject);}else 
if(isArrayish(subject)){

if(Buffer.isBuffer(subject)){
for(i = 0;i < length;i++) {
self[i] = subject.readUInt8(i);}}else 

{
for(i = 0;i < length;i++) {
self[i] = (subject[i] % 256 + 256) % 256;}}}else 


if(type === "string"){
self.write(subject,0,encoding);}else 
if(type === "number" && !Buffer.TYPED_ARRAY_SUPPORT){
for(i = 0;i < length;i++) {
self[i] = 0;}}



if(length > 0 && length <= Buffer.poolSize)self.parent = rootParent;

return self;}


function SlowBuffer(subject,encoding){
if(!(this instanceof SlowBuffer))return new SlowBuffer(subject,encoding);

var buf=new Buffer(subject,encoding);
delete buf.parent;
return buf;}


Buffer.isBuffer = function isBuffer(b){
return !!(b != null && b._isBuffer);};


Buffer.compare = function compare(a,b){
if(!Buffer.isBuffer(a) || !Buffer.isBuffer(b)){
throw new TypeError("Arguments must be Buffers");}


if(a === b)return 0;

var x=a.length;
var y=b.length;
for(var i=0,len=Math.min(x,y);i < len && a[i] === b[i];i++) {}

if(i !== len){
x = a[i];
y = b[i];}

if(x < y)return -1;
if(y < x)return 1;
return 0;};


Buffer.isEncoding = function isEncoding(encoding){
switch(String(encoding).toLowerCase()){
case "hex":
case "utf8":
case "utf-8":
case "ascii":
case "binary":
case "base64":
case "raw":
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return true;
default:
return false;}};



Buffer.concat = function concat(list,totalLength){
if(!isArray(list))throw new TypeError("list argument must be an Array of Buffers.");

if(list.length === 0){
return new Buffer(0);}else 
if(list.length === 1){
return list[0];}


var i;
if(totalLength === undefined){
totalLength = 0;
for(i = 0;i < list.length;i++) {
totalLength += list[i].length;}}



var buf=new Buffer(totalLength);
var pos=0;
for(i = 0;i < list.length;i++) {
var item=list[i];
item.copy(buf,pos);
pos += item.length;}

return buf;};


Buffer.byteLength = function byteLength(str,encoding){
var ret;
str = str + "";
switch(encoding || "utf8"){
case "ascii":
case "binary":
case "raw":
ret = str.length;
break;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
ret = str.length * 2;
break;
case "hex":
ret = str.length >>> 1;
break;
case "utf8":
case "utf-8":
ret = utf8ToBytes(str).length;
break;
case "base64":
ret = base64ToBytes(str).length;
break;
default:
ret = str.length;}

return ret;};



Buffer.prototype.length = undefined;
Buffer.prototype.parent = undefined;


Buffer.prototype.toString = function toString(encoding,start,end){
var loweredCase=false;

start = start >>> 0;
end = end === undefined || end === Infinity?this.length:end >>> 0;

if(!encoding)encoding = "utf8";
if(start < 0)start = 0;
if(end > this.length)end = this.length;
if(end <= start)return "";

while(true) {
switch(encoding){
case "hex":
return hexSlice(this,start,end);

case "utf8":
case "utf-8":
return utf8Slice(this,start,end);

case "ascii":
return asciiSlice(this,start,end);

case "binary":
return binarySlice(this,start,end);

case "base64":
return base64Slice(this,start,end);

case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
return utf16leSlice(this,start,end);

default:
if(loweredCase)throw new TypeError("Unknown encoding: " + encoding);
encoding = (encoding + "").toLowerCase();
loweredCase = true;}}};




Buffer.prototype.equals = function equals(b){
if(!Buffer.isBuffer(b))throw new TypeError("Argument must be a Buffer");
if(this === b)return true;
return Buffer.compare(this,b) === 0;};


Buffer.prototype.inspect = function inspect(){
var str="";
var max=exports.INSPECT_MAX_BYTES;
if(this.length > 0){
str = this.toString("hex",0,max).match(/.{2}/g).join(" ");
if(this.length > max)str += " ... ";}

return "<Buffer " + str + ">";};


Buffer.prototype.compare = function compare(b){
if(!Buffer.isBuffer(b))throw new TypeError("Argument must be a Buffer");
if(this === b)return 0;
return Buffer.compare(this,b);};


Buffer.prototype.indexOf = function indexOf(val,byteOffset){
if(byteOffset > 0x7fffffff)byteOffset = 0x7fffffff;else 
if(byteOffset < -0x80000000)byteOffset = -0x80000000;
byteOffset >>= 0;

if(this.length === 0)return -1;
if(byteOffset >= this.length)return -1;


if(byteOffset < 0)byteOffset = Math.max(this.length + byteOffset,0);

if(typeof val === "string"){
if(val.length === 0)return -1;
return String.prototype.indexOf.call(this,val,byteOffset);}

if(Buffer.isBuffer(val)){
return arrayIndexOf(this,val,byteOffset);}

if(typeof val === "number"){
if(Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === "function"){
return Uint8Array.prototype.indexOf.call(this,val,byteOffset);}

return arrayIndexOf(this,[val],byteOffset);}


function arrayIndexOf(arr,val,byteOffset){
var foundIndex=-1;
for(var i=0;byteOffset + i < arr.length;i++) {
if(arr[byteOffset + i] === val[foundIndex === -1?0:i - foundIndex]){
if(foundIndex === -1)foundIndex = i;
if(i - foundIndex + 1 === val.length)return byteOffset + foundIndex;}else 
{
foundIndex = -1;}}


return -1;}


throw new TypeError("val must be string, number or Buffer");};



Buffer.prototype.get = function get(offset){
console.log(".get() is deprecated. Access using array indexes instead.");
return this.readUInt8(offset);};



Buffer.prototype.set = function set(v,offset){
console.log(".set() is deprecated. Access using array indexes instead.");
return this.writeUInt8(v,offset);};


function hexWrite(buf,string,offset,length){
offset = Number(offset) || 0;
var remaining=buf.length - offset;
if(!length){
length = remaining;}else 
{
length = Number(length);
if(length > remaining){
length = remaining;}}




var strLen=string.length;
if(strLen % 2 !== 0)throw new Error("Invalid hex string");

if(length > strLen / 2){
length = strLen / 2;}

for(var i=0;i < length;i++) {
var parsed=parseInt(string.substr(i * 2,2),16);
if(isNaN(parsed))throw new Error("Invalid hex string");
buf[offset + i] = parsed;}

return i;}


function utf8Write(buf,string,offset,length){
var charsWritten=blitBuffer(utf8ToBytes(string,buf.length - offset),buf,offset,length);
return charsWritten;}


function asciiWrite(buf,string,offset,length){
var charsWritten=blitBuffer(asciiToBytes(string),buf,offset,length);
return charsWritten;}


function binaryWrite(buf,string,offset,length){
return asciiWrite(buf,string,offset,length);}


function base64Write(buf,string,offset,length){
var charsWritten=blitBuffer(base64ToBytes(string),buf,offset,length);
return charsWritten;}


function utf16leWrite(buf,string,offset,length){
var charsWritten=blitBuffer(utf16leToBytes(string,buf.length - offset),buf,offset,length);
return charsWritten;}


Buffer.prototype.write = function write(string,offset,length,encoding){


if(isFinite(offset)){
if(!isFinite(length)){
encoding = length;
length = undefined;}}else 

{
var swap=encoding;
encoding = offset;
offset = length;
length = swap;}


offset = Number(offset) || 0;

if(length < 0 || offset < 0 || offset > this.length){
throw new RangeError("attempt to write outside buffer bounds");}


var remaining=this.length - offset;
if(!length){
length = remaining;}else 
{
length = Number(length);
if(length > remaining){
length = remaining;}}


encoding = String(encoding || "utf8").toLowerCase();

var ret;
switch(encoding){
case "hex":
ret = hexWrite(this,string,offset,length);
break;
case "utf8":
case "utf-8":
ret = utf8Write(this,string,offset,length);
break;
case "ascii":
ret = asciiWrite(this,string,offset,length);
break;
case "binary":
ret = binaryWrite(this,string,offset,length);
break;
case "base64":
ret = base64Write(this,string,offset,length);
break;
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
ret = utf16leWrite(this,string,offset,length);
break;
default:
throw new TypeError("Unknown encoding: " + encoding);}

return ret;};


Buffer.prototype.toJSON = function toJSON(){
return {
type:"Buffer",
data:Array.prototype.slice.call(this._arr || this,0)};};



function base64Slice(buf,start,end){
if(start === 0 && end === buf.length){
return base64.fromByteArray(buf);}else 
{
return base64.fromByteArray(buf.slice(start,end));}}



function utf8Slice(buf,start,end){
var res="";
var tmp="";
end = Math.min(buf.length,end);

for(var i=start;i < end;i++) {
if(buf[i] <= 0x7F){
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i]);
tmp = "";}else 
{
tmp += "%" + buf[i].toString(16);}}



return res + decodeUtf8Char(tmp);}


function asciiSlice(buf,start,end){
var ret="";
end = Math.min(buf.length,end);

for(var i=start;i < end;i++) {
ret += String.fromCharCode(buf[i] & 0x7F);}

return ret;}


function binarySlice(buf,start,end){
var ret="";
end = Math.min(buf.length,end);

for(var i=start;i < end;i++) {
ret += String.fromCharCode(buf[i]);}

return ret;}


function hexSlice(buf,start,end){
var len=buf.length;

if(!start || start < 0)start = 0;
if(!end || end < 0 || end > len)end = len;

var out="";
for(var i=start;i < end;i++) {
out += toHex(buf[i]);}

return out;}


function utf16leSlice(buf,start,end){
var bytes=buf.slice(start,end);
var res="";
for(var i=0;i < bytes.length;i += 2) {
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);}

return res;}


Buffer.prototype.slice = function slice(start,end){
var len=this.length;
start = ~ ~start;
end = end === undefined?len:~ ~end;

if(start < 0){
start += len;
if(start < 0)start = 0;}else 
if(start > len){
start = len;}


if(end < 0){
end += len;
if(end < 0)end = 0;}else 
if(end > len){
end = len;}


if(end < start)end = start;

var newBuf;
if(Buffer.TYPED_ARRAY_SUPPORT){
newBuf = Buffer._augment(this.subarray(start,end));}else 
{
var sliceLen=end - start;
newBuf = new Buffer(sliceLen,undefined);
for(var i=0;i < sliceLen;i++) {
newBuf[i] = this[i + start];}}



if(newBuf.length)newBuf.parent = this.parent || this;

return newBuf;};





function checkOffset(offset,ext,length){
if(offset % 1 !== 0 || offset < 0)throw new RangeError("offset is not uint");
if(offset + ext > length)throw new RangeError("Trying to access beyond buffer length");}


Buffer.prototype.readUIntLE = function readUIntLE(offset,byteLength,noAssert){
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if(!noAssert)checkOffset(offset,byteLength,this.length);

var val=this[offset];
var mul=1;
var i=0;
while(++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul;}


return val;};


Buffer.prototype.readUIntBE = function readUIntBE(offset,byteLength,noAssert){
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if(!noAssert){
checkOffset(offset,byteLength,this.length);}


var val=this[offset + --byteLength];
var mul=1;
while(byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul;}


return val;};


Buffer.prototype.readUInt8 = function readUInt8(offset,noAssert){
if(!noAssert)checkOffset(offset,1,this.length);
return this[offset];};


Buffer.prototype.readUInt16LE = function readUInt16LE(offset,noAssert){
if(!noAssert)checkOffset(offset,2,this.length);
return this[offset] | this[offset + 1] << 8;};


Buffer.prototype.readUInt16BE = function readUInt16BE(offset,noAssert){
if(!noAssert)checkOffset(offset,2,this.length);
return this[offset] << 8 | this[offset + 1];};


Buffer.prototype.readUInt32LE = function readUInt32LE(offset,noAssert){
if(!noAssert)checkOffset(offset,4,this.length);

return (this[offset] | 
this[offset + 1] << 8 | 
this[offset + 2] << 16) + 
this[offset + 3] * 0x1000000;};


Buffer.prototype.readUInt32BE = function readUInt32BE(offset,noAssert){
if(!noAssert)checkOffset(offset,4,this.length);

return this[offset] * 0x1000000 + (
this[offset + 1] << 16 | 
this[offset + 2] << 8 | 
this[offset + 3]);};


Buffer.prototype.readIntLE = function readIntLE(offset,byteLength,noAssert){
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if(!noAssert)checkOffset(offset,byteLength,this.length);

var val=this[offset];
var mul=1;
var i=0;
while(++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul;}

mul *= 0x80;

if(val >= mul)val -= Math.pow(2,8 * byteLength);

return val;};


Buffer.prototype.readIntBE = function readIntBE(offset,byteLength,noAssert){
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if(!noAssert)checkOffset(offset,byteLength,this.length);

var i=byteLength;
var mul=1;
var val=this[offset + --i];
while(i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul;}

mul *= 0x80;

if(val >= mul)val -= Math.pow(2,8 * byteLength);

return val;};


Buffer.prototype.readInt8 = function readInt8(offset,noAssert){
if(!noAssert)checkOffset(offset,1,this.length);
if(!(this[offset] & 0x80))return this[offset];
return (0xff - this[offset] + 1) * -1;};


Buffer.prototype.readInt16LE = function readInt16LE(offset,noAssert){
if(!noAssert)checkOffset(offset,2,this.length);
var val=this[offset] | this[offset + 1] << 8;
return val & 0x8000?val | 0xFFFF0000:val;};


Buffer.prototype.readInt16BE = function readInt16BE(offset,noAssert){
if(!noAssert)checkOffset(offset,2,this.length);
var val=this[offset + 1] | this[offset] << 8;
return val & 0x8000?val | 0xFFFF0000:val;};


Buffer.prototype.readInt32LE = function readInt32LE(offset,noAssert){
if(!noAssert)checkOffset(offset,4,this.length);

return this[offset] | 
this[offset + 1] << 8 | 
this[offset + 2] << 16 | 
this[offset + 3] << 24;};


Buffer.prototype.readInt32BE = function readInt32BE(offset,noAssert){
if(!noAssert)checkOffset(offset,4,this.length);

return this[offset] << 24 | 
this[offset + 1] << 16 | 
this[offset + 2] << 8 | 
this[offset + 3];};


Buffer.prototype.readFloatLE = function readFloatLE(offset,noAssert){
if(!noAssert)checkOffset(offset,4,this.length);
return ieee754.read(this,offset,true,23,4);};


Buffer.prototype.readFloatBE = function readFloatBE(offset,noAssert){
if(!noAssert)checkOffset(offset,4,this.length);
return ieee754.read(this,offset,false,23,4);};


Buffer.prototype.readDoubleLE = function readDoubleLE(offset,noAssert){
if(!noAssert)checkOffset(offset,8,this.length);
return ieee754.read(this,offset,true,52,8);};


Buffer.prototype.readDoubleBE = function readDoubleBE(offset,noAssert){
if(!noAssert)checkOffset(offset,8,this.length);
return ieee754.read(this,offset,false,52,8);};


function checkInt(buf,value,offset,ext,max,min){
if(!Buffer.isBuffer(buf))throw new TypeError("buffer must be a Buffer instance");
if(value > max || value < min)throw new RangeError("value is out of bounds");
if(offset + ext > buf.length)throw new RangeError("index out of range");}


Buffer.prototype.writeUIntLE = function writeUIntLE(value,offset,byteLength,noAssert){
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if(!noAssert)checkInt(this,value,offset,byteLength,Math.pow(2,8 * byteLength),0);

var mul=1;
var i=0;
this[offset] = value & 0xFF;
while(++i < byteLength && (mul *= 0x100)) {
this[offset + i] = value / mul >>> 0 & 0xFF;}


return offset + byteLength;};


Buffer.prototype.writeUIntBE = function writeUIntBE(value,offset,byteLength,noAssert){
value = +value;
offset = offset >>> 0;
byteLength = byteLength >>> 0;
if(!noAssert)checkInt(this,value,offset,byteLength,Math.pow(2,8 * byteLength),0);

var i=byteLength - 1;
var mul=1;
this[offset + i] = value & 0xFF;
while(--i >= 0 && (mul *= 0x100)) {
this[offset + i] = value / mul >>> 0 & 0xFF;}


return offset + byteLength;};


Buffer.prototype.writeUInt8 = function writeUInt8(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,1,0xff,0);
if(!Buffer.TYPED_ARRAY_SUPPORT)value = Math.floor(value);
this[offset] = value;
return offset + 1;};


function objectWriteUInt16(buf,value,offset,littleEndian){
if(value < 0)value = 0xffff + value + 1;
for(var i=0,j=Math.min(buf.length - offset,2);i < j;i++) {
buf[offset + i] = (value & 0xff << 8 * (littleEndian?i:1 - i)) >>> 
(littleEndian?i:1 - i) * 8;}}



Buffer.prototype.writeUInt16LE = function writeUInt16LE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,2,0xffff,0);
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset] = value;
this[offset + 1] = value >>> 8;}else 
{
objectWriteUInt16(this,value,offset,true);}

return offset + 2;};


Buffer.prototype.writeUInt16BE = function writeUInt16BE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,2,0xffff,0);
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset] = value >>> 8;
this[offset + 1] = value;}else 
{
objectWriteUInt16(this,value,offset,false);}

return offset + 2;};


function objectWriteUInt32(buf,value,offset,littleEndian){
if(value < 0)value = 0xffffffff + value + 1;
for(var i=0,j=Math.min(buf.length - offset,4);i < j;i++) {
buf[offset + i] = value >>> (littleEndian?i:3 - i) * 8 & 0xff;}}



Buffer.prototype.writeUInt32LE = function writeUInt32LE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,4,0xffffffff,0);
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset + 3] = value >>> 24;
this[offset + 2] = value >>> 16;
this[offset + 1] = value >>> 8;
this[offset] = value;}else 
{
objectWriteUInt32(this,value,offset,true);}

return offset + 4;};


Buffer.prototype.writeUInt32BE = function writeUInt32BE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,4,0xffffffff,0);
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value;}else 
{
objectWriteUInt32(this,value,offset,false);}

return offset + 4;};


Buffer.prototype.writeIntLE = function writeIntLE(value,offset,byteLength,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert){
checkInt(
this,value,offset,byteLength,
Math.pow(2,8 * byteLength - 1) - 1,
-Math.pow(2,8 * byteLength - 1));}



var i=0;
var mul=1;
var sub=value < 0?1:0;
this[offset] = value & 0xFF;
while(++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul >> 0) - sub & 0xFF;}


return offset + byteLength;};


Buffer.prototype.writeIntBE = function writeIntBE(value,offset,byteLength,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert){
checkInt(
this,value,offset,byteLength,
Math.pow(2,8 * byteLength - 1) - 1,
-Math.pow(2,8 * byteLength - 1));}



var i=byteLength - 1;
var mul=1;
var sub=value < 0?1:0;
this[offset + i] = value & 0xFF;
while(--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul >> 0) - sub & 0xFF;}


return offset + byteLength;};


Buffer.prototype.writeInt8 = function writeInt8(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,1,0x7f,-0x80);
if(!Buffer.TYPED_ARRAY_SUPPORT)value = Math.floor(value);
if(value < 0)value = 0xff + value + 1;
this[offset] = value;
return offset + 1;};


Buffer.prototype.writeInt16LE = function writeInt16LE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,2,0x7fff,-0x8000);
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset] = value;
this[offset + 1] = value >>> 8;}else 
{
objectWriteUInt16(this,value,offset,true);}

return offset + 2;};


Buffer.prototype.writeInt16BE = function writeInt16BE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,2,0x7fff,-0x8000);
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset] = value >>> 8;
this[offset + 1] = value;}else 
{
objectWriteUInt16(this,value,offset,false);}

return offset + 2;};


Buffer.prototype.writeInt32LE = function writeInt32LE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,4,0x7fffffff,-0x80000000);
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset] = value;
this[offset + 1] = value >>> 8;
this[offset + 2] = value >>> 16;
this[offset + 3] = value >>> 24;}else 
{
objectWriteUInt32(this,value,offset,true);}

return offset + 4;};


Buffer.prototype.writeInt32BE = function writeInt32BE(value,offset,noAssert){
value = +value;
offset = offset >>> 0;
if(!noAssert)checkInt(this,value,offset,4,0x7fffffff,-0x80000000);
if(value < 0)value = 0xffffffff + value + 1;
if(Buffer.TYPED_ARRAY_SUPPORT){
this[offset] = value >>> 24;
this[offset + 1] = value >>> 16;
this[offset + 2] = value >>> 8;
this[offset + 3] = value;}else 
{
objectWriteUInt32(this,value,offset,false);}

return offset + 4;};


function checkIEEE754(buf,value,offset,ext,max,min){
if(value > max || value < min)throw new RangeError("value is out of bounds");
if(offset + ext > buf.length)throw new RangeError("index out of range");
if(offset < 0)throw new RangeError("index out of range");}


function writeFloat(buf,value,offset,littleEndian,noAssert){
if(!noAssert){
checkIEEE754(buf,value,offset,4,3.4028234663852886e+38,-3.4028234663852886e+38);}

ieee754.write(buf,value,offset,littleEndian,23,4);
return offset + 4;}


Buffer.prototype.writeFloatLE = function writeFloatLE(value,offset,noAssert){
return writeFloat(this,value,offset,true,noAssert);};


Buffer.prototype.writeFloatBE = function writeFloatBE(value,offset,noAssert){
return writeFloat(this,value,offset,false,noAssert);};


function writeDouble(buf,value,offset,littleEndian,noAssert){
if(!noAssert){
checkIEEE754(buf,value,offset,8,1.7976931348623157E+308,-1.7976931348623157E+308);}

ieee754.write(buf,value,offset,littleEndian,52,8);
return offset + 8;}


Buffer.prototype.writeDoubleLE = function writeDoubleLE(value,offset,noAssert){
return writeDouble(this,value,offset,true,noAssert);};


Buffer.prototype.writeDoubleBE = function writeDoubleBE(value,offset,noAssert){
return writeDouble(this,value,offset,false,noAssert);};



Buffer.prototype.copy = function copy(target,target_start,start,end){
if(!start)start = 0;
if(!end && end !== 0)end = this.length;
if(target_start >= target.length)target_start = target.length;
if(!target_start)target_start = 0;
if(end > 0 && end < start)end = start;


if(end === start)return 0;
if(target.length === 0 || this.length === 0)return 0;


if(target_start < 0){
throw new RangeError("targetStart out of bounds");}

if(start < 0 || start >= this.length)throw new RangeError("sourceStart out of bounds");
if(end < 0)throw new RangeError("sourceEnd out of bounds");


if(end > this.length)end = this.length;
if(target.length - target_start < end - start){
end = target.length - target_start + start;}


var len=end - start;

if(len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT){
for(var i=0;i < len;i++) {
target[i + target_start] = this[i + start];}}else 

{
target._set(this.subarray(start,start + len),target_start);}


return len;};



Buffer.prototype.fill = function fill(value,start,end){
if(!value)value = 0;
if(!start)start = 0;
if(!end)end = this.length;

if(end < start)throw new RangeError("end < start");


if(end === start)return;
if(this.length === 0)return;

if(start < 0 || start >= this.length)throw new RangeError("start out of bounds");
if(end < 0 || end > this.length)throw new RangeError("end out of bounds");

var i;
if(typeof value === "number"){
for(i = start;i < end;i++) {
this[i] = value;}}else 

{
var bytes=utf8ToBytes(value.toString());
var len=bytes.length;
for(i = start;i < end;i++) {
this[i] = bytes[i % len];}}



return this;};






Buffer.prototype.toArrayBuffer = function toArrayBuffer(){
if(typeof Uint8Array !== "undefined"){
if(Buffer.TYPED_ARRAY_SUPPORT){
return new Buffer(this).buffer;}else 
{
var buf=new Uint8Array(this.length);
for(var i=0,len=buf.length;i < len;i += 1) {
buf[i] = this[i];}

return buf.buffer;}}else 

{
throw new TypeError("Buffer.toArrayBuffer not supported in this browser");}};






var BP=Buffer.prototype;




Buffer._augment = function _augment(arr){
arr.constructor = Buffer;
arr._isBuffer = true;


arr._set = arr.set;


arr.get = BP.get;
arr.set = BP.set;

arr.write = BP.write;
arr.toString = BP.toString;
arr.toLocaleString = BP.toString;
arr.toJSON = BP.toJSON;
arr.equals = BP.equals;
arr.compare = BP.compare;
arr.indexOf = BP.indexOf;
arr.copy = BP.copy;
arr.slice = BP.slice;
arr.readUIntLE = BP.readUIntLE;
arr.readUIntBE = BP.readUIntBE;
arr.readUInt8 = BP.readUInt8;
arr.readUInt16LE = BP.readUInt16LE;
arr.readUInt16BE = BP.readUInt16BE;
arr.readUInt32LE = BP.readUInt32LE;
arr.readUInt32BE = BP.readUInt32BE;
arr.readIntLE = BP.readIntLE;
arr.readIntBE = BP.readIntBE;
arr.readInt8 = BP.readInt8;
arr.readInt16LE = BP.readInt16LE;
arr.readInt16BE = BP.readInt16BE;
arr.readInt32LE = BP.readInt32LE;
arr.readInt32BE = BP.readInt32BE;
arr.readFloatLE = BP.readFloatLE;
arr.readFloatBE = BP.readFloatBE;
arr.readDoubleLE = BP.readDoubleLE;
arr.readDoubleBE = BP.readDoubleBE;
arr.writeUInt8 = BP.writeUInt8;
arr.writeUIntLE = BP.writeUIntLE;
arr.writeUIntBE = BP.writeUIntBE;
arr.writeUInt16LE = BP.writeUInt16LE;
arr.writeUInt16BE = BP.writeUInt16BE;
arr.writeUInt32LE = BP.writeUInt32LE;
arr.writeUInt32BE = BP.writeUInt32BE;
arr.writeIntLE = BP.writeIntLE;
arr.writeIntBE = BP.writeIntBE;
arr.writeInt8 = BP.writeInt8;
arr.writeInt16LE = BP.writeInt16LE;
arr.writeInt16BE = BP.writeInt16BE;
arr.writeInt32LE = BP.writeInt32LE;
arr.writeInt32BE = BP.writeInt32BE;
arr.writeFloatLE = BP.writeFloatLE;
arr.writeFloatBE = BP.writeFloatBE;
arr.writeDoubleLE = BP.writeDoubleLE;
arr.writeDoubleBE = BP.writeDoubleBE;
arr.fill = BP.fill;
arr.inspect = BP.inspect;
arr.toArrayBuffer = BP.toArrayBuffer;

return arr;};


var INVALID_BASE64_RE=/[^+\/0-9A-z\-]/g;

function base64clean(str){

str = stringtrim(str).replace(INVALID_BASE64_RE,"");

if(str.length < 2)return "";

while(str.length % 4 !== 0) {
str = str + "=";}

return str;}


function stringtrim(str){
if(str.trim)return str.trim();
return str.replace(/^\s+|\s+$/g,"");}


function isArrayish(subject){
return isArray(subject) || Buffer.isBuffer(subject) || 
subject && typeof subject === "object" && 
typeof subject.length === "number";}


function toHex(n){
if(n < 16)return "0" + n.toString(16);
return n.toString(16);}


function utf8ToBytes(string,units){
units = units || Infinity;
var codePoint;
var length=string.length;
var leadSurrogate=null;
var bytes=[];
var i=0;

for(;i < length;i++) {
codePoint = string.charCodeAt(i);


if(codePoint > 0xD7FF && codePoint < 0xE000){

if(leadSurrogate){

if(codePoint < 0xDC00){
if((units -= 3) > -1)bytes.push(0xEF,0xBF,0xBD);
leadSurrogate = codePoint;
continue;}else 
{

codePoint = leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00 | 0x10000;
leadSurrogate = null;}}else 

{


if(codePoint > 0xDBFF){

if((units -= 3) > -1)bytes.push(0xEF,0xBF,0xBD);
continue;}else 
if(i + 1 === length){

if((units -= 3) > -1)bytes.push(0xEF,0xBF,0xBD);
continue;}else 
{

leadSurrogate = codePoint;
continue;}}}else 


if(leadSurrogate){

if((units -= 3) > -1)bytes.push(0xEF,0xBF,0xBD);
leadSurrogate = null;}



if(codePoint < 0x80){
if((units -= 1) < 0)break;
bytes.push(codePoint);}else 
if(codePoint < 0x800){
if((units -= 2) < 0)break;
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80);}else 

if(codePoint < 0x10000){
if((units -= 3) < 0)break;
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80);}else 

if(codePoint < 0x200000){
if((units -= 4) < 0)break;
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80);}else 

{
throw new Error("Invalid code point");}}



return bytes;}


function asciiToBytes(str){
var byteArray=[];
for(var i=0;i < str.length;i++) {

byteArray.push(str.charCodeAt(i) & 0xFF);}

return byteArray;}


function utf16leToBytes(str,units){
var c,hi,lo;
var byteArray=[];
for(var i=0;i < str.length;i++) {
if((units -= 2) < 0)break;

c = str.charCodeAt(i);
hi = c >> 8;
lo = c % 256;
byteArray.push(lo);
byteArray.push(hi);}


return byteArray;}


function base64ToBytes(str){
return base64.toByteArray(base64clean(str));}


function blitBuffer(src,dst,offset,length){
for(var i=0;i < length;i++) {
if(i + offset >= dst.length || i >= src.length)break;
dst[i + offset] = src[i];}

return i;}


function decodeUtf8Char(str){
try{
return decodeURIComponent(str);}
catch(err) {
return String.fromCharCode(0xFFFD);}}},



{"base64-js":36,"ieee754":37,"is-array":38}],
36:[function(_dereq_,module,exports){
var lookup="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

;
(function(exports){
"use strict";

var Arr=typeof Uint8Array !== "undefined"?
Uint8Array:
Array;

var PLUS="+".charCodeAt(0);
var SLASH="/".charCodeAt(0);
var NUMBER="0".charCodeAt(0);
var LOWER="a".charCodeAt(0);
var UPPER="A".charCodeAt(0);
var PLUS_URL_SAFE="-".charCodeAt(0);
var SLASH_URL_SAFE="_".charCodeAt(0);

function decode(elt){
var code=elt.charCodeAt(0);
if(code === PLUS || 
code === PLUS_URL_SAFE)
return 62;
if(code === SLASH || 
code === SLASH_URL_SAFE)
return 63;
if(code < NUMBER)
return -1;
if(code < NUMBER + 10)
return code - NUMBER + 26 + 26;
if(code < UPPER + 26)
return code - UPPER;
if(code < LOWER + 26)
return code - LOWER + 26;}


function b64ToByteArray(b64){
var i,j,l,tmp,placeHolders,arr;

if(b64.length % 4 > 0){
throw new Error("Invalid string. Length must be a multiple of 4");}







var len=b64.length;
placeHolders = "=" === b64.charAt(len - 2)?2:"=" === b64.charAt(len - 1)?1:0;


arr = new Arr(b64.length * 3 / 4 - placeHolders);


l = placeHolders > 0?b64.length - 4:b64.length;

var L=0;

function push(v){
arr[L++] = v;}


for(i = 0,j = 0;i < l;i += 4,j += 3) {
tmp = decode(b64.charAt(i)) << 18 | decode(b64.charAt(i + 1)) << 12 | decode(b64.charAt(i + 2)) << 6 | decode(b64.charAt(i + 3));
push((tmp & 0xFF0000) >> 16);
push((tmp & 0xFF00) >> 8);
push(tmp & 0xFF);}


if(placeHolders === 2){
tmp = decode(b64.charAt(i)) << 2 | decode(b64.charAt(i + 1)) >> 4;
push(tmp & 0xFF);}else 
if(placeHolders === 1){
tmp = decode(b64.charAt(i)) << 10 | decode(b64.charAt(i + 1)) << 4 | decode(b64.charAt(i + 2)) >> 2;
push(tmp >> 8 & 0xFF);
push(tmp & 0xFF);}


return arr;}


function uint8ToBase64(uint8){
var i,
extraBytes=uint8.length % 3,
output="",
temp,length;

function encode(num){
return lookup.charAt(num);}


function tripletToBase64(num){
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F);}



for(i = 0,length = uint8.length - extraBytes;i < length;i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
output += tripletToBase64(temp);}



switch(extraBytes){
case 1:
temp = uint8[uint8.length - 1];
output += encode(temp >> 2);
output += encode(temp << 4 & 0x3F);
output += "==";
break;
case 2:
temp = (uint8[uint8.length - 2] << 8) + uint8[uint8.length - 1];
output += encode(temp >> 10);
output += encode(temp >> 4 & 0x3F);
output += encode(temp << 2 & 0x3F);
output += "=";
break;}


return output;}


exports.toByteArray = b64ToByteArray;
exports.fromByteArray = uint8ToBase64;})(
typeof exports === "undefined"?this.base64js = {}:exports);},

{}],
37:[function(_dereq_,module,exports){
exports.read = function(buffer,offset,isLE,mLen,nBytes){
var e,m,
eLen=nBytes * 8 - mLen - 1,
eMax=(1 << eLen) - 1,
eBias=eMax >> 1,
nBits=-7,
i=isLE?nBytes - 1:0,
d=isLE?-1:1,
s=buffer[offset + i];

i += d;

e = s & (1 << -nBits) - 1;
s >>= -nBits;
nBits += eLen;
for(;nBits > 0;e = e * 256 + buffer[offset + i],i += d,nBits -= 8);

m = e & (1 << -nBits) - 1;
e >>= -nBits;
nBits += mLen;
for(;nBits > 0;m = m * 256 + buffer[offset + i],i += d,nBits -= 8);

if(e === 0){
e = 1 - eBias;}else 
if(e === eMax){
return m?NaN:(s?-1:1) * Infinity;}else 
{
m = m + Math.pow(2,mLen);
e = e - eBias;}

return (s?-1:1) * m * Math.pow(2,e - mLen);};


exports.write = function(buffer,value,offset,isLE,mLen,nBytes){
var e,m,c,
eLen=nBytes * 8 - mLen - 1,
eMax=(1 << eLen) - 1,
eBias=eMax >> 1,
rt=mLen === 23?Math.pow(2,-24) - Math.pow(2,-77):0,
i=isLE?0:nBytes - 1,
d=isLE?1:-1,
s=value < 0 || value === 0 && 1 / value < 0?1:0;

value = Math.abs(value);

if(isNaN(value) || value === Infinity){
m = isNaN(value)?1:0;
e = eMax;}else 
{
e = Math.floor(Math.log(value) / Math.LN2);
if(value * (c = Math.pow(2,-e)) < 1){
e--;
c *= 2;}

if(e + eBias >= 1){
value += rt / c;}else 
{
value += rt * Math.pow(2,1 - eBias);}

if(value * c >= 2){
e++;
c /= 2;}


if(e + eBias >= eMax){
m = 0;
e = eMax;}else 
if(e + eBias >= 1){
m = (value * c - 1) * Math.pow(2,mLen);
e = e + eBias;}else 
{
m = value * Math.pow(2,eBias - 1) * Math.pow(2,mLen);
e = 0;}}



for(;mLen >= 8;buffer[offset + i] = m & 0xff,i += d,m /= 256,mLen -= 8);

e = e << mLen | m;
eLen += mLen;
for(;eLen > 0;buffer[offset + i] = e & 0xff,i += d,e /= 256,eLen -= 8);

buffer[offset + i - d] |= s * 128;};},


{}],
38:[function(_dereq_,module,exports){





var isArray=Array.isArray;





var str=Object.prototype.toString;


















module.exports = isArray || function(val){
return !!val && "[object Array]" == str.call(val);};},


{}],
39:[function(_dereq_,module,exports){





















function EventEmitter(){
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;}


module.exports = EventEmitter;


EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;



EventEmitter.defaultMaxListeners = 10;



EventEmitter.prototype.setMaxListeners = function(n){
if(!isNumber(n) || n < 0 || isNaN(n))
throw TypeError("n must be a positive number");
this._maxListeners = n;
return this;};


EventEmitter.prototype.emit = function(type){
var er,handler,len,args,i,listeners;

if(!this._events)
this._events = {};


if(type === "error"){
if(!this._events.error || 
isObject(this._events.error) && !this._events.error.length){
er = arguments[1];
if(er instanceof Error){
throw er;}

throw TypeError("Uncaught, unspecified \"error\" event.");}}



handler = this._events[type];

if(isUndefined(handler))
return false;

if(isFunction(handler)){
switch(arguments.length){

case 1:
handler.call(this);
break;
case 2:
handler.call(this,arguments[1]);
break;
case 3:
handler.call(this,arguments[1],arguments[2]);
break;

default:
len = arguments.length;
args = new Array(len - 1);
for(i = 1;i < len;i++) 
args[i - 1] = arguments[i];
handler.apply(this,args);}}else 

if(isObject(handler)){
len = arguments.length;
args = new Array(len - 1);
for(i = 1;i < len;i++) 
args[i - 1] = arguments[i];

listeners = handler.slice();
len = listeners.length;
for(i = 0;i < len;i++) 
listeners[i].apply(this,args);}


return true;};


EventEmitter.prototype.addListener = function(type,listener){
var m;

if(!isFunction(listener))
throw TypeError("listener must be a function");

if(!this._events)
this._events = {};



if(this._events.newListener)
this.emit("newListener",type,
isFunction(listener.listener)?
listener.listener:listener);

if(!this._events[type])

this._events[type] = listener;else 
if(isObject(this._events[type]))

this._events[type].push(listener);else 


this._events[type] = [this._events[type],listener];


if(isObject(this._events[type]) && !this._events[type].warned){
var m;
if(!isUndefined(this._maxListeners)){
m = this._maxListeners;}else 
{
m = EventEmitter.defaultMaxListeners;}


if(m && m > 0 && this._events[type].length > m){
this._events[type].warned = true;
console.error("(node) warning: possible EventEmitter memory " + 
"leak detected. %d listeners added. " + 
"Use emitter.setMaxListeners() to increase limit.",
this._events[type].length);
if(typeof console.trace === "function"){

console.trace();}}}




return this;};


EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type,listener){
if(!isFunction(listener))
throw TypeError("listener must be a function");

var fired=false;

function g(){
this.removeListener(type,g);

if(!fired){
fired = true;
listener.apply(this,arguments);}}



g.listener = listener;
this.on(type,g);

return this;};



EventEmitter.prototype.removeListener = function(type,listener){
var list,position,length,i;

if(!isFunction(listener))
throw TypeError("listener must be a function");

if(!this._events || !this._events[type])
return this;

list = this._events[type];
length = list.length;
position = -1;

if(list === listener || 
isFunction(list.listener) && list.listener === listener){
delete this._events[type];
if(this._events.removeListener)
this.emit("removeListener",type,listener);}else 

if(isObject(list)){
for(i = length;i-- > 0;) {
if(list[i] === listener || 
list[i].listener && list[i].listener === listener){
position = i;
break;}}



if(position < 0)
return this;

if(list.length === 1){
list.length = 0;
delete this._events[type];}else 
{
list.splice(position,1);}


if(this._events.removeListener)
this.emit("removeListener",type,listener);}


return this;};


EventEmitter.prototype.removeAllListeners = function(type){
var key,listeners;

if(!this._events)
return this;


if(!this._events.removeListener){
if(arguments.length === 0)
this._events = {};else 
if(this._events[type])
delete this._events[type];
return this;}



if(arguments.length === 0){
for(key in this._events) {
if(key === "removeListener")continue;
this.removeAllListeners(key);}

this.removeAllListeners("removeListener");
this._events = {};
return this;}


listeners = this._events[type];

if(isFunction(listeners)){
this.removeListener(type,listeners);}else 
{

while(listeners.length) 
this.removeListener(type,listeners[listeners.length - 1]);}

delete this._events[type];

return this;};


EventEmitter.prototype.listeners = function(type){
var ret;
if(!this._events || !this._events[type])
ret = [];else 
if(isFunction(this._events[type]))
ret = [this._events[type]];else 

ret = this._events[type].slice();
return ret;};


EventEmitter.listenerCount = function(emitter,type){
var ret;
if(!emitter._events || !emitter._events[type])
ret = 0;else 
if(isFunction(emitter._events[type]))
ret = 1;else 

ret = emitter._events[type].length;
return ret;};


function isFunction(arg){
return typeof arg === "function";}


function isNumber(arg){
return typeof arg === "number";}


function isObject(arg){
return typeof arg === "object" && arg !== null;}


function isUndefined(arg){
return arg === void 0;}},


{}],
40:[function(_dereq_,module,exports){
if(typeof Object.create === "function"){

module.exports = function inherits(ctor,superCtor){
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype,{
constructor:{
value:ctor,
enumerable:false,
writable:true,
configurable:true}});};}else 



{

module.exports = function inherits(ctor,superCtor){
ctor.super_ = superCtor;
var TempCtor=function(){};

TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;};}},



{}],
41:[function(_dereq_,module,exports){
module.exports = Array.isArray || function(arr){
return Object.prototype.toString.call(arr) == "[object Array]";};},


{}],
42:[function(_dereq_,module,exports){


var process=module.exports = {};
var queue=[];
var draining=false;

function drainQueue(){
if(draining){
return;}

draining = true;
var currentQueue;
var len=queue.length;
while(len) {
currentQueue = queue;
queue = [];
var i=-1;
while(++i < len) {
currentQueue[i]();}

len = queue.length;}

draining = false;}


process.nextTick = function(fun){
queue.push(fun);
if(!draining){
setTimeout(drainQueue,0);}};



process.title = "browser";
process.browser = true;
process.env = {};
process.argv = [];
process.version = "";
process.versions = {};

function noop(){}


process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;

process.binding = function(name){
throw new Error("process.binding is not supported");};



process.cwd = function(){
return "/";};

process.chdir = function(dir){
throw new Error("process.chdir is not supported");};

process.umask = function(){
return 0;};},


{}],
43:[function(_dereq_,module,exports){
module.exports = _dereq_("./lib/_stream_duplex.js");},

{"./lib/_stream_duplex.js":44}],
44:[function(_dereq_,module,exports){
(function(process){


























module.exports = Duplex;


var objectKeys=Object.keys || function(obj){
var keys=[];
for(var key in obj) keys.push(key);
return keys;};





var util=_dereq_("core-util-is");
util.inherits = _dereq_("inherits");


var Readable=_dereq_("./_stream_readable");
var Writable=_dereq_("./_stream_writable");

util.inherits(Duplex,Readable);

forEach(objectKeys(Writable.prototype),function(method){
if(!Duplex.prototype[method])
Duplex.prototype[method] = Writable.prototype[method];});


function Duplex(options){
if(!(this instanceof Duplex))
return new Duplex(options);

Readable.call(this,options);
Writable.call(this,options);

if(options && options.readable === false)
this.readable = false;

if(options && options.writable === false)
this.writable = false;

this.allowHalfOpen = true;
if(options && options.allowHalfOpen === false)
this.allowHalfOpen = false;

this.once("end",onend);}



function onend(){


if(this.allowHalfOpen || this._writableState.ended)
return;



process.nextTick(this.end.bind(this));}


function forEach(xs,f){
for(var i=0,l=xs.length;i < l;i++) {
f(xs[i],i);}}}).



call(this,_dereq_("_process"));},
{"./_stream_readable":46,"./_stream_writable":48,"_process":42,"core-util-is":49,"inherits":40}],
45:[function(_dereq_,module,exports){

























module.exports = PassThrough;

var Transform=_dereq_("./_stream_transform");


var util=_dereq_("core-util-is");
util.inherits = _dereq_("inherits");


util.inherits(PassThrough,Transform);

function PassThrough(options){
if(!(this instanceof PassThrough))
return new PassThrough(options);

Transform.call(this,options);}


PassThrough.prototype._transform = function(chunk,encoding,cb){
cb(null,chunk);};},


{"./_stream_transform":47,"core-util-is":49,"inherits":40}],
46:[function(_dereq_,module,exports){
(function(process){





















module.exports = Readable;


var isArray=_dereq_("isarray");




var Buffer=_dereq_("buffer").Buffer;


Readable.ReadableState = ReadableState;

var EE=_dereq_("events").EventEmitter;


if(!EE.listenerCount)EE.listenerCount = function(emitter,type){
return emitter.listeners(type).length;};



var Stream=_dereq_("stream");


var util=_dereq_("core-util-is");
util.inherits = _dereq_("inherits");


var StringDecoder;



var debug=_dereq_("util");
if(debug && debug.debuglog){
debug = debug.debuglog("stream");}else 
{
debug = function(){};}





util.inherits(Readable,Stream);

function ReadableState(options,stream){
var Duplex=_dereq_("./_stream_duplex");

options = options || {};



var hwm=options.highWaterMark;
var defaultHwm=options.objectMode?16:16 * 1024;
this.highWaterMark = hwm || hwm === 0?hwm:defaultHwm;


this.highWaterMark = ~ ~this.highWaterMark;

this.buffer = [];
this.length = 0;
this.pipes = null;
this.pipesCount = 0;
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false;





this.sync = true;



this.needReadable = false;
this.emittedReadable = false;
this.readableListening = false;




this.objectMode = !!options.objectMode;

if(stream instanceof Duplex)
this.objectMode = this.objectMode || !!options.readableObjectMode;




this.defaultEncoding = options.defaultEncoding || "utf8";



this.ranOut = false;


this.awaitDrain = 0;


this.readingMore = false;

this.decoder = null;
this.encoding = null;
if(options.encoding){
if(!StringDecoder)
StringDecoder = _dereq_("string_decoder/").StringDecoder;
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;}}



function Readable(options){
var Duplex=_dereq_("./_stream_duplex");

if(!(this instanceof Readable))
return new Readable(options);

this._readableState = new ReadableState(options,this);


this.readable = true;

Stream.call(this);}






Readable.prototype.push = function(chunk,encoding){
var state=this._readableState;

if(util.isString(chunk) && !state.objectMode){
encoding = encoding || state.defaultEncoding;
if(encoding !== state.encoding){
chunk = new Buffer(chunk,encoding);
encoding = "";}}



return readableAddChunk(this,state,chunk,encoding,false);};



Readable.prototype.unshift = function(chunk){
var state=this._readableState;
return readableAddChunk(this,state,chunk,"",true);};


function readableAddChunk(stream,state,chunk,encoding,addToFront){
var er=chunkInvalid(state,chunk);
if(er){
stream.emit("error",er);}else 
if(util.isNullOrUndefined(chunk)){
state.reading = false;
if(!state.ended)
onEofChunk(stream,state);}else 
if(state.objectMode || chunk && chunk.length > 0){
if(state.ended && !addToFront){
var e=new Error("stream.push() after EOF");
stream.emit("error",e);}else 
if(state.endEmitted && addToFront){
var e=new Error("stream.unshift() after end event");
stream.emit("error",e);}else 
{
if(state.decoder && !addToFront && !encoding)
chunk = state.decoder.write(chunk);

if(!addToFront)
state.reading = false;


if(state.flowing && state.length === 0 && !state.sync){
stream.emit("data",chunk);
stream.read(0);}else 
{

state.length += state.objectMode?1:chunk.length;
if(addToFront)
state.buffer.unshift(chunk);else 

state.buffer.push(chunk);

if(state.needReadable)
emitReadable(stream);}


maybeReadMore(stream,state);}}else 

if(!addToFront){
state.reading = false;}


return needMoreData(state);}










function needMoreData(state){
return !state.ended && (
state.needReadable || 
state.length < state.highWaterMark || 
state.length === 0);}



Readable.prototype.setEncoding = function(enc){
if(!StringDecoder)
StringDecoder = _dereq_("string_decoder/").StringDecoder;
this._readableState.decoder = new StringDecoder(enc);
this._readableState.encoding = enc;
return this;};



var MAX_HWM=0x800000;

function roundUpToNextPowerOf2(n){
if(n >= MAX_HWM){
n = MAX_HWM;}else 
{

n--;
for(var p=1;p < 32;p <<= 1) n |= n >> p;
n++;}

return n;}


function howMuchToRead(n,state){
if(state.length === 0 && state.ended)
return 0;

if(state.objectMode)
return n === 0?0:1;

if(isNaN(n) || util.isNull(n)){

if(state.flowing && state.buffer.length)
return state.buffer[0].length;else 

return state.length;}


if(n <= 0)
return 0;





if(n > state.highWaterMark)
state.highWaterMark = roundUpToNextPowerOf2(n);


if(n > state.length){
if(!state.ended){
state.needReadable = true;
return 0;}else 

return state.length;}


return n;}



Readable.prototype.read = function(n){
debug("read",n);
var state=this._readableState;
var nOrig=n;

if(!util.isNumber(n) || n > 0)
state.emittedReadable = false;




if(n === 0 && 
state.needReadable && (
state.length >= state.highWaterMark || state.ended)){
debug("read: emitReadable",state.length,state.ended);
if(state.length === 0 && state.ended)
endReadable(this);else 

emitReadable(this);
return null;}


n = howMuchToRead(n,state);


if(n === 0 && state.ended){
if(state.length === 0)
endReadable(this);
return null;}

























var doRead=state.needReadable;
debug("need readable",doRead);


if(state.length === 0 || state.length - n < state.highWaterMark){
doRead = true;
debug("length less than watermark",doRead);}




if(state.ended || state.reading){
doRead = false;
debug("reading or ended",doRead);}


if(doRead){
debug("do read");
state.reading = true;
state.sync = true;

if(state.length === 0)
state.needReadable = true;

this._read(state.highWaterMark);
state.sync = false;}




if(doRead && !state.reading)
n = howMuchToRead(nOrig,state);

var ret;
if(n > 0)
ret = fromList(n,state);else 

ret = null;

if(util.isNull(ret)){
state.needReadable = true;
n = 0;}


state.length -= n;



if(state.length === 0 && !state.ended)
state.needReadable = true;


if(nOrig !== n && state.ended && state.length === 0)
endReadable(this);

if(!util.isNull(ret))
this.emit("data",ret);

return ret;};


function chunkInvalid(state,chunk){
var er=null;
if(!util.isBuffer(chunk) && !util.isString(chunk) && !util.isNullOrUndefined(chunk) && !state.objectMode){
er = new TypeError("Invalid non-string/buffer chunk");}

return er;}



function onEofChunk(stream,state){
if(state.decoder && !state.ended){
var chunk=state.decoder.end();
if(chunk && chunk.length){
state.buffer.push(chunk);
state.length += state.objectMode?1:chunk.length;}}


state.ended = true;


emitReadable(stream);}





function emitReadable(stream){
var state=stream._readableState;
state.needReadable = false;
if(!state.emittedReadable){
debug("emitReadable",state.flowing);
state.emittedReadable = true;
if(state.sync)
process.nextTick(function(){
emitReadable_(stream);});else 


emitReadable_(stream);}}



function emitReadable_(stream){
debug("emit readable");
stream.emit("readable");
flow(stream);}









function maybeReadMore(stream,state){
if(!state.readingMore){
state.readingMore = true;
process.nextTick(function(){
maybeReadMore_(stream,state);});}}




function maybeReadMore_(stream,state){
var len=state.length;
while(!state.reading && !state.flowing && !state.ended && 
state.length < state.highWaterMark) {
debug("maybeReadMore read 0");
stream.read(0);
if(len === state.length)

break;else 

len = state.length;}

state.readingMore = false;}






Readable.prototype._read = function(n){
this.emit("error",new Error("not implemented"));};


Readable.prototype.pipe = function(dest,pipeOpts){
var src=this;
var state=this._readableState;

switch(state.pipesCount){
case 0:
state.pipes = dest;
break;
case 1:
state.pipes = [state.pipes,dest];
break;
default:
state.pipes.push(dest);
break;}

state.pipesCount += 1;
debug("pipe count=%d opts=%j",state.pipesCount,pipeOpts);

var doEnd=(!pipeOpts || pipeOpts.end !== false) && 
dest !== process.stdout && 
dest !== process.stderr;

var endFn=doEnd?onend:cleanup;
if(state.endEmitted)
process.nextTick(endFn);else 

src.once("end",endFn);

dest.on("unpipe",onunpipe);
function onunpipe(readable){
debug("onunpipe");
if(readable === src){
cleanup();}}



function onend(){
debug("onend");
dest.end();}






var ondrain=pipeOnDrain(src);
dest.on("drain",ondrain);

function cleanup(){
debug("cleanup");

dest.removeListener("close",onclose);
dest.removeListener("finish",onfinish);
dest.removeListener("drain",ondrain);
dest.removeListener("error",onerror);
dest.removeListener("unpipe",onunpipe);
src.removeListener("end",onend);
src.removeListener("end",cleanup);
src.removeListener("data",ondata);






if(state.awaitDrain && (
!dest._writableState || dest._writableState.needDrain))
ondrain();}


src.on("data",ondata);
function ondata(chunk){
debug("ondata");
var ret=dest.write(chunk);
if(false === ret){
debug("false write response, pause",
src._readableState.awaitDrain);
src._readableState.awaitDrain++;
src.pause();}}





function onerror(er){
debug("onerror",er);
unpipe();
dest.removeListener("error",onerror);
if(EE.listenerCount(dest,"error") === 0)
dest.emit("error",er);}




if(!dest._events || !dest._events.error)
dest.on("error",onerror);else 
if(isArray(dest._events.error))
dest._events.error.unshift(onerror);else 

dest._events.error = [onerror,dest._events.error];



function onclose(){
dest.removeListener("finish",onfinish);
unpipe();}


dest.once("close",onclose);
function onfinish(){
debug("onfinish");
dest.removeListener("close",onclose);
unpipe();}


dest.once("finish",onfinish);

function unpipe(){
debug("unpipe");
src.unpipe(dest);}



dest.emit("pipe",src);


if(!state.flowing){
debug("pipe resume");
src.resume();}


return dest;};


function pipeOnDrain(src){
return function(){
var state=src._readableState;
debug("pipeOnDrain",state.awaitDrain);
if(state.awaitDrain)
state.awaitDrain--;
if(state.awaitDrain === 0 && EE.listenerCount(src,"data")){
state.flowing = true;
flow(src);}};}





Readable.prototype.unpipe = function(dest){
var state=this._readableState;


if(state.pipesCount === 0)
return this;


if(state.pipesCount === 1){

if(dest && dest !== state.pipes)
return this;

if(!dest)
dest = state.pipes;


state.pipes = null;
state.pipesCount = 0;
state.flowing = false;
if(dest)
dest.emit("unpipe",this);
return this;}




if(!dest){

var dests=state.pipes;
var len=state.pipesCount;
state.pipes = null;
state.pipesCount = 0;
state.flowing = false;

for(var i=0;i < len;i++) 
dests[i].emit("unpipe",this);
return this;}



var i=indexOf(state.pipes,dest);
if(i === -1)
return this;

state.pipes.splice(i,1);
state.pipesCount -= 1;
if(state.pipesCount === 1)
state.pipes = state.pipes[0];

dest.emit("unpipe",this);

return this;};




Readable.prototype.on = function(ev,fn){
var res=Stream.prototype.on.call(this,ev,fn);



if(ev === "data" && false !== this._readableState.flowing){
this.resume();}


if(ev === "readable" && this.readable){
var state=this._readableState;
if(!state.readableListening){
state.readableListening = true;
state.emittedReadable = false;
state.needReadable = true;
if(!state.reading){
var self=this;
process.nextTick(function(){
debug("readable nexttick read 0");
self.read(0);});}else 

if(state.length){
emitReadable(this,state);}}}




return res;};

Readable.prototype.addListener = Readable.prototype.on;



Readable.prototype.resume = function(){
var state=this._readableState;
if(!state.flowing){
debug("resume");
state.flowing = true;
if(!state.reading){
debug("resume read 0");
this.read(0);}

resume(this,state);}

return this;};


function resume(stream,state){
if(!state.resumeScheduled){
state.resumeScheduled = true;
process.nextTick(function(){
resume_(stream,state);});}}




function resume_(stream,state){
state.resumeScheduled = false;
stream.emit("resume");
flow(stream);
if(state.flowing && !state.reading)
stream.read(0);}


Readable.prototype.pause = function(){
debug("call pause flowing=%j",this._readableState.flowing);
if(false !== this._readableState.flowing){
debug("pause");
this._readableState.flowing = false;
this.emit("pause");}

return this;};


function flow(stream){
var state=stream._readableState;
debug("flow",state.flowing);
if(state.flowing){
do {
var chunk=stream.read();}while(
null !== chunk && state.flowing);}}






Readable.prototype.wrap = function(stream){
var state=this._readableState;
var paused=false;

var self=this;
stream.on("end",function(){
debug("wrapped end");
if(state.decoder && !state.ended){
var chunk=state.decoder.end();
if(chunk && chunk.length)
self.push(chunk);}


self.push(null);});


stream.on("data",function(chunk){
debug("wrapped data");
if(state.decoder)
chunk = state.decoder.write(chunk);
if(!chunk || !state.objectMode && !chunk.length)
return;

var ret=self.push(chunk);
if(!ret){
paused = true;
stream.pause();}});





for(var i in stream) {
if(util.isFunction(stream[i]) && util.isUndefined(this[i])){
this[i] = (function(method){
return function(){
return stream[method].apply(stream,arguments);};})(

i);}}




var events=["error","close","destroy","pause","resume"];
forEach(events,function(ev){
stream.on(ev,self.emit.bind(self,ev));});




self._read = function(n){
debug("wrapped _read",n);
if(paused){
paused = false;
stream.resume();}};



return self;};




Readable._fromList = fromList;



function fromList(n,state){
var list=state.buffer;
var length=state.length;
var stringMode=!!state.decoder;
var objectMode=!!state.objectMode;
var ret;


if(list.length === 0)
return null;

if(length === 0)
ret = null;else 
if(objectMode)
ret = list.shift();else 
if(!n || n >= length){

if(stringMode)
ret = list.join("");else 

ret = Buffer.concat(list,length);
list.length = 0;}else 
{

if(n < list[0].length){


var buf=list[0];
ret = buf.slice(0,n);
list[0] = buf.slice(n);}else 
if(n === list[0].length){

ret = list.shift();}else 
{


if(stringMode)
ret = "";else 

ret = new Buffer(n);

var c=0;
for(var i=0,l=list.length;i < l && c < n;i++) {
var buf=list[0];
var cpy=Math.min(n - c,buf.length);

if(stringMode)
ret += buf.slice(0,cpy);else 

buf.copy(ret,c,0,cpy);

if(cpy < buf.length)
list[0] = buf.slice(cpy);else 

list.shift();

c += cpy;}}}




return ret;}


function endReadable(stream){
var state=stream._readableState;



if(state.length > 0)
throw new Error("endReadable called on non-empty stream");

if(!state.endEmitted){
state.ended = true;
process.nextTick(function(){

if(!state.endEmitted && state.length === 0){
state.endEmitted = true;
stream.readable = false;
stream.emit("end");}});}}





function forEach(xs,f){
for(var i=0,l=xs.length;i < l;i++) {
f(xs[i],i);}}



function indexOf(xs,x){
for(var i=0,l=xs.length;i < l;i++) {
if(xs[i] === x)return i;}

return -1;}}).


call(this,_dereq_("_process"));},
{
"./_stream_duplex":44,
"_process":42,
"buffer":35,
"core-util-is":49,
"events":39,
"inherits":40,
"isarray":41,
"stream":54,
"string_decoder/":55,
"util":34}],

47:[function(_dereq_,module,exports){
































































module.exports = Transform;

var Duplex=_dereq_("./_stream_duplex");


var util=_dereq_("core-util-is");
util.inherits = _dereq_("inherits");


util.inherits(Transform,Duplex);


function TransformState(options,stream){
this.afterTransform = function(er,data){
return afterTransform(stream,er,data);};


this.needTransform = false;
this.transforming = false;
this.writecb = null;
this.writechunk = null;}


function afterTransform(stream,er,data){
var ts=stream._transformState;
ts.transforming = false;

var cb=ts.writecb;

if(!cb)
return stream.emit("error",new Error("no writecb in Transform class"));

ts.writechunk = null;
ts.writecb = null;

if(!util.isNullOrUndefined(data))
stream.push(data);

if(cb)
cb(er);

var rs=stream._readableState;
rs.reading = false;
if(rs.needReadable || rs.length < rs.highWaterMark){
stream._read(rs.highWaterMark);}}




function Transform(options){
if(!(this instanceof Transform))
return new Transform(options);

Duplex.call(this,options);

this._transformState = new TransformState(options,this);


var stream=this;


this._readableState.needReadable = true;




this._readableState.sync = false;

this.once("prefinish",function(){
if(util.isFunction(this._flush))
this._flush(function(er){
done(stream,er);});else 


done(stream);});}



Transform.prototype.push = function(chunk,encoding){
this._transformState.needTransform = false;
return Duplex.prototype.push.call(this,chunk,encoding);};












Transform.prototype._transform = function(chunk,encoding,cb){
throw new Error("not implemented");};


Transform.prototype._write = function(chunk,encoding,cb){
var ts=this._transformState;
ts.writecb = cb;
ts.writechunk = chunk;
ts.writeencoding = encoding;
if(!ts.transforming){
var rs=this._readableState;
if(ts.needTransform || 
rs.needReadable || 
rs.length < rs.highWaterMark)
this._read(rs.highWaterMark);}};






Transform.prototype._read = function(n){
var ts=this._transformState;

if(!util.isNull(ts.writechunk) && ts.writecb && !ts.transforming){
ts.transforming = true;
this._transform(ts.writechunk,ts.writeencoding,ts.afterTransform);}else 
{


ts.needTransform = true;}};




function done(stream,er){
if(er)
return stream.emit("error",er);



var ws=stream._writableState;
var ts=stream._transformState;

if(ws.length)
throw new Error("calling transform done when ws.length != 0");

if(ts.transforming)
throw new Error("calling transform done when still transforming");

return stream.push(null);}},


{"./_stream_duplex":44,"core-util-is":49,"inherits":40}],
48:[function(_dereq_,module,exports){
(function(process){

























module.exports = Writable;


var Buffer=_dereq_("buffer").Buffer;


Writable.WritableState = WritableState;



var util=_dereq_("core-util-is");
util.inherits = _dereq_("inherits");


var Stream=_dereq_("stream");

util.inherits(Writable,Stream);

function WriteReq(chunk,encoding,cb){
this.chunk = chunk;
this.encoding = encoding;
this.callback = cb;}


function WritableState(options,stream){
var Duplex=_dereq_("./_stream_duplex");

options = options || {};




var hwm=options.highWaterMark;
var defaultHwm=options.objectMode?16:16 * 1024;
this.highWaterMark = hwm || hwm === 0?hwm:defaultHwm;



this.objectMode = !!options.objectMode;

if(stream instanceof Duplex)
this.objectMode = this.objectMode || !!options.writableObjectMode;


this.highWaterMark = ~ ~this.highWaterMark;

this.needDrain = false;

this.ending = false;

this.ended = false;

this.finished = false;




var noDecode=options.decodeStrings === false;
this.decodeStrings = !noDecode;




this.defaultEncoding = options.defaultEncoding || "utf8";




this.length = 0;


this.writing = false;


this.corked = 0;





this.sync = true;




this.bufferProcessing = false;


this.onwrite = function(er){
onwrite(stream,er);};



this.writecb = null;


this.writelen = 0;

this.buffer = [];



this.pendingcb = 0;



this.prefinished = false;


this.errorEmitted = false;}


function Writable(options){
var Duplex=_dereq_("./_stream_duplex");



if(!(this instanceof Writable) && !(this instanceof Duplex))
return new Writable(options);

this._writableState = new WritableState(options,this);


this.writable = true;

Stream.call(this);}



Writable.prototype.pipe = function(){
this.emit("error",new Error("Cannot pipe. Not readable."));};



function writeAfterEnd(stream,state,cb){
var er=new Error("write after end");

stream.emit("error",er);
process.nextTick(function(){
cb(er);});}








function validChunk(stream,state,chunk,cb){
var valid=true;
if(!util.isBuffer(chunk) && !util.isString(chunk) && !util.isNullOrUndefined(chunk) && !state.objectMode){
var er=new TypeError("Invalid non-string/buffer chunk");
stream.emit("error",er);
process.nextTick(function(){
cb(er);});

valid = false;}

return valid;}


Writable.prototype.write = function(chunk,encoding,cb){
var state=this._writableState;
var ret=false;

if(util.isFunction(encoding)){
cb = encoding;
encoding = null;}


if(util.isBuffer(chunk))
encoding = "buffer";else 
if(!encoding)
encoding = state.defaultEncoding;

if(!util.isFunction(cb))
cb = function(){};


if(state.ended)
writeAfterEnd(this,state,cb);else 
if(validChunk(this,state,chunk,cb)){
state.pendingcb++;
ret = writeOrBuffer(this,state,chunk,encoding,cb);}


return ret;};


Writable.prototype.cork = function(){
var state=this._writableState;

state.corked++;};


Writable.prototype.uncork = function(){
var state=this._writableState;

if(state.corked){
state.corked--;

if(!state.writing && !state.corked && !state.finished && !state.bufferProcessing && 
state.buffer.length)
clearBuffer(this,state);}};



function decodeChunk(state,chunk,encoding){
if(!state.objectMode && 
state.decodeStrings !== false && 
util.isString(chunk)){
chunk = new Buffer(chunk,encoding);}

return chunk;}





function writeOrBuffer(stream,state,chunk,encoding,cb){
chunk = decodeChunk(state,chunk,encoding);
if(util.isBuffer(chunk))
encoding = "buffer";
var len=state.objectMode?1:chunk.length;

state.length += len;

var ret=state.length < state.highWaterMark;

if(!ret)
state.needDrain = true;

if(state.writing || state.corked)
state.buffer.push(new WriteReq(chunk,encoding,cb));else 

doWrite(stream,state,false,len,chunk,encoding,cb);

return ret;}


function doWrite(stream,state,writev,len,chunk,encoding,cb){
state.writelen = len;
state.writecb = cb;
state.writing = true;
state.sync = true;
if(writev)
stream._writev(chunk,state.onwrite);else 

stream._write(chunk,encoding,state.onwrite);
state.sync = false;}


function onwriteError(stream,state,sync,er,cb){
if(sync)
process.nextTick(function(){
state.pendingcb--;
cb(er);});else 

{
state.pendingcb--;
cb(er);}


stream._writableState.errorEmitted = true;
stream.emit("error",er);}


function onwriteStateUpdate(state){
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;}


function onwrite(stream,er){
var state=stream._writableState;
var sync=state.sync;
var cb=state.writecb;

onwriteStateUpdate(state);

if(er)
onwriteError(stream,state,sync,er,cb);else 
{

var finished=needFinish(stream,state);

if(!finished && !state.corked && !state.bufferProcessing && 
state.buffer.length){
clearBuffer(stream,state);}


if(sync){
process.nextTick(function(){
afterWrite(stream,state,finished,cb);});}else 

{
afterWrite(stream,state,finished,cb);}}}




function afterWrite(stream,state,finished,cb){
if(!finished)
onwriteDrain(stream,state);
state.pendingcb--;
cb();
finishMaybe(stream,state);}





function onwriteDrain(stream,state){
if(state.length === 0 && state.needDrain){
state.needDrain = false;
stream.emit("drain");}}





function clearBuffer(stream,state){
state.bufferProcessing = true;

if(stream._writev && state.buffer.length > 1){

var cbs=[];
for(var c=0;c < state.buffer.length;c++) 
cbs.push(state.buffer[c].callback);



state.pendingcb++;
doWrite(stream,state,true,state.length,state.buffer,"",function(err){
for(var i=0;i < cbs.length;i++) {
state.pendingcb--;
cbs[i](err);}});




state.buffer = [];}else 
{

for(var c=0;c < state.buffer.length;c++) {
var entry=state.buffer[c];
var chunk=entry.chunk;
var encoding=entry.encoding;
var cb=entry.callback;
var len=state.objectMode?1:chunk.length;

doWrite(stream,state,false,len,chunk,encoding,cb);





if(state.writing){
c++;
break;}}



if(c < state.buffer.length)
state.buffer = state.buffer.slice(c);else 

state.buffer.length = 0;}


state.bufferProcessing = false;}


Writable.prototype._write = function(chunk,encoding,cb){
cb(new Error("not implemented"));};



Writable.prototype._writev = null;

Writable.prototype.end = function(chunk,encoding,cb){
var state=this._writableState;

if(util.isFunction(chunk)){
cb = chunk;
chunk = null;
encoding = null;}else 
if(util.isFunction(encoding)){
cb = encoding;
encoding = null;}


if(!util.isNullOrUndefined(chunk))
this.write(chunk,encoding);


if(state.corked){
state.corked = 1;
this.uncork();}



if(!state.ending && !state.finished)
endWritable(this,state,cb);};



function needFinish(stream,state){
return state.ending && 
state.length === 0 && !state.finished && !state.writing;}


function prefinish(stream,state){
if(!state.prefinished){
state.prefinished = true;
stream.emit("prefinish");}}



function finishMaybe(stream,state){
var need=needFinish(stream,state);
if(need){
if(state.pendingcb === 0){
prefinish(stream,state);
state.finished = true;
stream.emit("finish");}else 

prefinish(stream,state);}

return need;}


function endWritable(stream,state,cb){
state.ending = true;
finishMaybe(stream,state);
if(cb){
if(state.finished)
process.nextTick(cb);else 

stream.once("finish",cb);}

state.ended = true;}}).


call(this,_dereq_("_process"));},
{"./_stream_duplex":44,"_process":42,"buffer":35,"core-util-is":49,"inherits":40,"stream":54}],
49:[function(_dereq_,module,exports){
(function(Buffer){























function isArray(ar){
return Array.isArray(ar);}


exports.isArray = isArray;

function isBoolean(arg){
return typeof arg === "boolean";}


exports.isBoolean = isBoolean;

function isNull(arg){
return arg === null;}


exports.isNull = isNull;

function isNullOrUndefined(arg){
return arg == null;}


exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg){
return typeof arg === "number";}


exports.isNumber = isNumber;

function isString(arg){
return typeof arg === "string";}


exports.isString = isString;

function isSymbol(arg){
return typeof arg === "symbol";}


exports.isSymbol = isSymbol;

function isUndefined(arg){
return arg === void 0;}


exports.isUndefined = isUndefined;

function isRegExp(re){
return isObject(re) && objectToString(re) === "[object RegExp]";}


exports.isRegExp = isRegExp;

function isObject(arg){
return typeof arg === "object" && arg !== null;}


exports.isObject = isObject;

function isDate(d){
return isObject(d) && objectToString(d) === "[object Date]";}


exports.isDate = isDate;

function isError(e){
return isObject(e) && (
objectToString(e) === "[object Error]" || e instanceof Error);}


exports.isError = isError;

function isFunction(arg){
return typeof arg === "function";}


exports.isFunction = isFunction;

function isPrimitive(arg){
return arg === null || 
typeof arg === "boolean" || 
typeof arg === "number" || 
typeof arg === "string" || 
typeof arg === "symbol" || 
typeof arg === "undefined";}


exports.isPrimitive = isPrimitive;

function isBuffer(arg){
return Buffer.isBuffer(arg);}


exports.isBuffer = isBuffer;

function objectToString(o){
return Object.prototype.toString.call(o);}}).

call(this,_dereq_("buffer").Buffer);},
{"buffer":35}],
50:[function(_dereq_,module,exports){
module.exports = _dereq_("./lib/_stream_passthrough.js");},

{"./lib/_stream_passthrough.js":45}],
51:[function(_dereq_,module,exports){
exports = module.exports = _dereq_("./lib/_stream_readable.js");
exports.Stream = _dereq_("stream");
exports.Readable = exports;
exports.Writable = _dereq_("./lib/_stream_writable.js");
exports.Duplex = _dereq_("./lib/_stream_duplex.js");
exports.Transform = _dereq_("./lib/_stream_transform.js");
exports.PassThrough = _dereq_("./lib/_stream_passthrough.js");},

{
"./lib/_stream_duplex.js":44,
"./lib/_stream_passthrough.js":45,
"./lib/_stream_readable.js":46,
"./lib/_stream_transform.js":47,
"./lib/_stream_writable.js":48,
"stream":54}],

52:[function(_dereq_,module,exports){
module.exports = _dereq_("./lib/_stream_transform.js");},

{"./lib/_stream_transform.js":47}],
53:[function(_dereq_,module,exports){
module.exports = _dereq_("./lib/_stream_writable.js");},

{"./lib/_stream_writable.js":48}],
54:[function(_dereq_,module,exports){





















module.exports = Stream;

var EE=_dereq_("events").EventEmitter;
var inherits=_dereq_("inherits");

inherits(Stream,EE);
Stream.Readable = _dereq_("readable-stream/readable.js");
Stream.Writable = _dereq_("readable-stream/writable.js");
Stream.Duplex = _dereq_("readable-stream/duplex.js");
Stream.Transform = _dereq_("readable-stream/transform.js");
Stream.PassThrough = _dereq_("readable-stream/passthrough.js");


Stream.Stream = Stream;





function Stream(){
EE.call(this);}


Stream.prototype.pipe = function(dest,options){
var source=this;

function ondata(chunk){
if(dest.writable){
if(false === dest.write(chunk) && source.pause){
source.pause();}}}




source.on("data",ondata);

function ondrain(){
if(source.readable && source.resume){
source.resume();}}



dest.on("drain",ondrain);



if(!dest._isStdio && (!options || options.end !== false)){
source.on("end",onend);
source.on("close",onclose);}


var didOnEnd=false;

function onend(){
if(didOnEnd)return;
didOnEnd = true;

dest.end();}



function onclose(){
if(didOnEnd)return;
didOnEnd = true;

if(typeof dest.destroy === "function")dest.destroy();}



function onerror(er){
cleanup();
if(EE.listenerCount(this,"error") === 0){
throw er;}}



source.on("error",onerror);
dest.on("error",onerror);


function cleanup(){
source.removeListener("data",ondata);
dest.removeListener("drain",ondrain);

source.removeListener("end",onend);
source.removeListener("close",onclose);

source.removeListener("error",onerror);
dest.removeListener("error",onerror);

source.removeListener("end",cleanup);
source.removeListener("close",cleanup);

dest.removeListener("close",cleanup);}


source.on("end",cleanup);
source.on("close",cleanup);

dest.on("close",cleanup);

dest.emit("pipe",source);


return dest;};},


{
"events":39,
"inherits":40,
"readable-stream/duplex.js":43,
"readable-stream/passthrough.js":50,
"readable-stream/readable.js":51,
"readable-stream/transform.js":52,
"readable-stream/writable.js":53}],

55:[function(_dereq_,module,exports){





















var Buffer=_dereq_("buffer").Buffer;

var isBufferEncoding=Buffer.isEncoding || 
function(encoding){
switch(encoding && encoding.toLowerCase()){
case "hex":
case "utf8":
case "utf-8":
case "ascii":
case "binary":
case "base64":
case "ucs2":
case "ucs-2":
case "utf16le":
case "utf-16le":
case "raw":
return true;
default:
return false;}};




function assertEncoding(encoding){
if(encoding && !isBufferEncoding(encoding)){
throw new Error("Unknown encoding: " + encoding);}}











var StringDecoder=exports.StringDecoder = function(encoding){
this.encoding = (encoding || "utf8").toLowerCase().replace(/[-_]/,"");
assertEncoding(encoding);
switch(this.encoding){
case "utf8":

this.surrogateSize = 3;
break;
case "ucs2":
case "utf16le":

this.surrogateSize = 2;
this.detectIncompleteChar = utf16DetectIncompleteChar;
break;
case "base64":

this.surrogateSize = 3;
this.detectIncompleteChar = base64DetectIncompleteChar;
break;
default:
this.write = passThroughWrite;
return;}




this.charBuffer = new Buffer(6);

this.charReceived = 0;

this.charLength = 0;};












StringDecoder.prototype.write = function(buffer){
var charStr="";

while(this.charLength) {

var available=buffer.length >= this.charLength - this.charReceived?
this.charLength - this.charReceived:
buffer.length;


buffer.copy(this.charBuffer,this.charReceived,0,available);
this.charReceived += available;

if(this.charReceived < this.charLength){

return "";}



buffer = buffer.slice(available,buffer.length);


charStr = this.charBuffer.slice(0,this.charLength).toString(this.encoding);


var charCode=charStr.charCodeAt(charStr.length - 1);
if(charCode >= 0xD800 && charCode <= 0xDBFF){
this.charLength += this.surrogateSize;
charStr = "";
continue;}

this.charReceived = this.charLength = 0;


if(buffer.length === 0){
return charStr;}

break;}



this.detectIncompleteChar(buffer);

var end=buffer.length;
if(this.charLength){

buffer.copy(this.charBuffer,0,buffer.length - this.charReceived,end);
end -= this.charReceived;}


charStr += buffer.toString(this.encoding,0,end);

var end=charStr.length - 1;
var charCode=charStr.charCodeAt(end);

if(charCode >= 0xD800 && charCode <= 0xDBFF){
var size=this.surrogateSize;
this.charLength += size;
this.charReceived += size;
this.charBuffer.copy(this.charBuffer,size,0,size);
buffer.copy(this.charBuffer,0,0,size);
return charStr.substring(0,end);}



return charStr;};






StringDecoder.prototype.detectIncompleteChar = function(buffer){

var i=buffer.length >= 3?3:buffer.length;



for(;i > 0;i--) {
var c=buffer[buffer.length - i];




if(i == 1 && c >> 5 == 0x06){
this.charLength = 2;
break;}



if(i <= 2 && c >> 4 == 0x0E){
this.charLength = 3;
break;}



if(i <= 3 && c >> 3 == 0x1E){
this.charLength = 4;
break;}}


this.charReceived = i;};


StringDecoder.prototype.end = function(buffer){
var res="";
if(buffer && buffer.length)
res = this.write(buffer);

if(this.charReceived){
var cr=this.charReceived;
var buf=this.charBuffer;
var enc=this.encoding;
res += buf.slice(0,cr).toString(enc);}


return res;};


function passThroughWrite(buffer){
return buffer.toString(this.encoding);}


function utf16DetectIncompleteChar(buffer){
this.charReceived = buffer.length % 2;
this.charLength = this.charReceived?2:0;}


function base64DetectIncompleteChar(buffer){
this.charReceived = buffer.length % 3;
this.charLength = this.charReceived?3:0;}},


{"buffer":35}],
56:[function(_dereq_,module,exports){
module.exports = function isBuffer(arg){
return arg && typeof arg === "object" && 
typeof arg.copy === "function" && 
typeof arg.fill === "function" && 
typeof arg.readUInt8 === "function";};},

{}],
57:[function(_dereq_,module,exports){
(function(process,global){





















var formatRegExp=/%[sdj%]/g;
exports.format = function(f){
if(!isString(f)){
var objects=[];
for(var i=0;i < arguments.length;i++) {
objects.push(inspect(arguments[i]));}

return objects.join(" ");}


var i=1;
var args=arguments;
var len=args.length;
var str=String(f).replace(formatRegExp,function(x){
if(x === "%")return "%";
if(i >= len)return x;
switch(x){
case "%s":
return String(args[i++]);
case "%d":
return Number(args[i++]);
case "%j":
try{
return JSON.stringify(args[i++]);}
catch(_) {
return "[Circular]";}

default:
return x;}});


for(var x=args[i];i < len;x = args[++i]) {
if(isNull(x) || !isObject(x)){
str += " " + x;}else 
{
str += " " + inspect(x);}}


return str;};






exports.deprecate = function(fn,msg){

if(isUndefined(global.process)){
return function(){
return exports.deprecate(fn,msg).apply(this,arguments);};}



if(process.noDeprecation === true){
return fn;}


var warned=false;

function deprecated(){
if(!warned){
if(process.throwDeprecation){
throw new Error(msg);}else 
if(process.traceDeprecation){
console.trace(msg);}else 
{
console.error(msg);}

warned = true;}

return fn.apply(this,arguments);}


return deprecated;};



var debugs={};
var debugEnviron;
exports.debuglog = function(set){
if(isUndefined(debugEnviron))
debugEnviron = process.env.NODE_DEBUG || "";
set = set.toUpperCase();
if(!debugs[set]){
if(new RegExp("\\b" + set + "\\b","i").test(debugEnviron)){
var pid=process.pid;
debugs[set] = function(){
var msg=exports.format.apply(exports,arguments);
console.error("%s %d: %s",set,pid,msg);};}else 

{
debugs[set] = function(){};}}



return debugs[set];};











function inspect(obj,opts){

var ctx={
seen:[],
stylize:stylizeNoColor};


if(arguments.length >= 3)ctx.depth = arguments[2];
if(arguments.length >= 4)ctx.colors = arguments[3];
if(isBoolean(opts)){

ctx.showHidden = opts;}else 
if(opts){

exports._extend(ctx,opts);}


if(isUndefined(ctx.showHidden))ctx.showHidden = false;
if(isUndefined(ctx.depth))ctx.depth = 2;
if(isUndefined(ctx.colors))ctx.colors = false;
if(isUndefined(ctx.customInspect))ctx.customInspect = true;
if(ctx.colors)ctx.stylize = stylizeWithColor;
return formatValue(ctx,obj,ctx.depth);}


exports.inspect = inspect;



inspect.colors = {
"bold":[1,22],
"italic":[3,23],
"underline":[4,24],
"inverse":[7,27],
"white":[37,39],
"grey":[90,39],
"black":[30,39],
"blue":[34,39],
"cyan":[36,39],
"green":[32,39],
"magenta":[35,39],
"red":[31,39],
"yellow":[33,39]};



inspect.styles = {
"special":"cyan",
"number":"yellow",
"boolean":"yellow",
"undefined":"grey",
"null":"bold",
"string":"green",
"date":"magenta",

"regexp":"red"};



function stylizeWithColor(str,styleType){
var style=inspect.styles[styleType];

if(style){
return "\u001b[" + inspect.colors[style][0] + "m" + str + 
"\u001b[" + inspect.colors[style][1] + "m";}else 
{
return str;}}




function stylizeNoColor(str,styleType){
return str;}



function arrayToHash(array){
var hash={};

array.forEach(function(val,idx){
hash[val] = true;});


return hash;}



function formatValue(ctx,value,recurseTimes){


if(ctx.customInspect && 
value && 
isFunction(value.inspect) && 

value.inspect !== exports.inspect && 

!(value.constructor && value.constructor.prototype === value)){
var ret=value.inspect(recurseTimes,ctx);
if(!isString(ret)){
ret = formatValue(ctx,ret,recurseTimes);}

return ret;}



var primitive=formatPrimitive(ctx,value);
if(primitive){
return primitive;}



var keys=Object.keys(value);
var visibleKeys=arrayToHash(keys);

if(ctx.showHidden){
keys = Object.getOwnPropertyNames(value);}




if(isError(value) && (
keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)){
return formatError(value);}



if(keys.length === 0){
if(isFunction(value)){
var name=value.name?": " + value.name:"";
return ctx.stylize("[Function" + name + "]","special");}

if(isRegExp(value)){
return ctx.stylize(RegExp.prototype.toString.call(value),"regexp");}

if(isDate(value)){
return ctx.stylize(Date.prototype.toString.call(value),"date");}

if(isError(value)){
return formatError(value);}}



var base="",array=false,braces=["{","}"];


if(isArray(value)){
array = true;
braces = ["[","]"];}



if(isFunction(value)){
var n=value.name?": " + value.name:"";
base = " [Function" + n + "]";}



if(isRegExp(value)){
base = " " + RegExp.prototype.toString.call(value);}



if(isDate(value)){
base = " " + Date.prototype.toUTCString.call(value);}



if(isError(value)){
base = " " + formatError(value);}


if(keys.length === 0 && (!array || value.length == 0)){
return braces[0] + base + braces[1];}


if(recurseTimes < 0){
if(isRegExp(value)){
return ctx.stylize(RegExp.prototype.toString.call(value),"regexp");}else 
{
return ctx.stylize("[Object]","special");}}



ctx.seen.push(value);

var output;
if(array){
output = formatArray(ctx,value,recurseTimes,visibleKeys,keys);}else 
{
output = keys.map(function(key){
return formatProperty(ctx,value,recurseTimes,visibleKeys,key,array);});}



ctx.seen.pop();

return reduceToSingleString(output,base,braces);}



function formatPrimitive(ctx,value){
if(isUndefined(value))
return ctx.stylize("undefined","undefined");
if(isString(value)){
var simple="'" + JSON.stringify(value).replace(/^"|"$/g,"").
replace(/'/g,"\\'").
replace(/\\"/g,"\"") + "'";
return ctx.stylize(simple,"string");}

if(isNumber(value))
return ctx.stylize("" + value,"number");
if(isBoolean(value))
return ctx.stylize("" + value,"boolean");

if(isNull(value))
return ctx.stylize("null","null");}



function formatError(value){
return "[" + Error.prototype.toString.call(value) + "]";}



function formatArray(ctx,value,recurseTimes,visibleKeys,keys){
var output=[];
for(var i=0,l=value.length;i < l;++i) {
if(hasOwnProperty(value,String(i))){
output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,
String(i),true));}else 
{
output.push("");}}


keys.forEach(function(key){
if(!key.match(/^\d+$/)){
output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,
key,true));}});


return output;}



function formatProperty(ctx,value,recurseTimes,visibleKeys,key,array){
var name,str,desc;
desc = Object.getOwnPropertyDescriptor(value,key) || {value:value[key]};
if(desc.get){
if(desc.set){
str = ctx.stylize("[Getter/Setter]","special");}else 
{
str = ctx.stylize("[Getter]","special");}}else 

{
if(desc.set){
str = ctx.stylize("[Setter]","special");}}


if(!hasOwnProperty(visibleKeys,key)){
name = "[" + key + "]";}

if(!str){
if(ctx.seen.indexOf(desc.value) < 0){
if(isNull(recurseTimes)){
str = formatValue(ctx,desc.value,null);}else 
{
str = formatValue(ctx,desc.value,recurseTimes - 1);}

if(str.indexOf("\n") > -1){
if(array){
str = str.split("\n").map(function(line){
return "  " + line;}).
join("\n").substr(2);}else 
{
str = "\n" + str.split("\n").map(function(line){
return "   " + line;}).
join("\n");}}}else 


{
str = ctx.stylize("[Circular]","special");}}


if(isUndefined(name)){
if(array && key.match(/^\d+$/)){
return str;}

name = JSON.stringify("" + key);
if(name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)){
name = name.substr(1,name.length - 2);
name = ctx.stylize(name,"name");}else 
{
name = name.replace(/'/g,"\\'").
replace(/\\"/g,"\"").
replace(/(^"|"$)/g,"'");
name = ctx.stylize(name,"string");}}



return name + ": " + str;}



function reduceToSingleString(output,base,braces){
var numLinesEst=0;
var length=output.reduce(function(prev,cur){
numLinesEst++;
if(cur.indexOf("\n") >= 0)numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g,"").length + 1;},
0);

if(length > 60){
return braces[0] + (
base === ""?"":base + "\n ") + 
" " + 
output.join(",\n  ") + 
" " + 
braces[1];}


return braces[0] + base + " " + output.join(", ") + " " + braces[1];}





function isArray(ar){
return Array.isArray(ar);}


exports.isArray = isArray;

function isBoolean(arg){
return typeof arg === "boolean";}


exports.isBoolean = isBoolean;

function isNull(arg){
return arg === null;}


exports.isNull = isNull;

function isNullOrUndefined(arg){
return arg == null;}


exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg){
return typeof arg === "number";}


exports.isNumber = isNumber;

function isString(arg){
return typeof arg === "string";}


exports.isString = isString;

function isSymbol(arg){
return typeof arg === "symbol";}


exports.isSymbol = isSymbol;

function isUndefined(arg){
return arg === void 0;}


exports.isUndefined = isUndefined;

function isRegExp(re){
return isObject(re) && objectToString(re) === "[object RegExp]";}


exports.isRegExp = isRegExp;

function isObject(arg){
return typeof arg === "object" && arg !== null;}


exports.isObject = isObject;

function isDate(d){
return isObject(d) && objectToString(d) === "[object Date]";}


exports.isDate = isDate;

function isError(e){
return isObject(e) && (
objectToString(e) === "[object Error]" || e instanceof Error);}


exports.isError = isError;

function isFunction(arg){
return typeof arg === "function";}


exports.isFunction = isFunction;

function isPrimitive(arg){
return arg === null || 
typeof arg === "boolean" || 
typeof arg === "number" || 
typeof arg === "string" || 
typeof arg === "symbol" || 
typeof arg === "undefined";}


exports.isPrimitive = isPrimitive;

exports.isBuffer = _dereq_("./support/isBuffer");

function objectToString(o){
return Object.prototype.toString.call(o);}



function pad(n){
return n < 10?"0" + n.toString(10):n.toString(10);}



var months=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep",
"Oct","Nov","Dec"];


function timestamp(){
var d=new Date();
var time=[pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())].join(":");
return [d.getDate(),months[d.getMonth()],time].join(" ");}




exports.log = function(){
console.log("%s - %s",timestamp(),exports.format.apply(exports,arguments));};
















exports.inherits = _dereq_("inherits");

exports._extend = function(origin,add){

if(!add || !isObject(add))return origin;

var keys=Object.keys(add);
var i=keys.length;
while(i--) {
origin[keys[i]] = add[keys[i]];}

return origin;};


function hasOwnProperty(obj,prop){
return Object.prototype.hasOwnProperty.call(obj,prop);}}).


call(this,_dereq_("_process"),typeof global !== "undefined"?global:typeof self !== "undefined"?self:typeof window !== "undefined"?window:{});},
{"./support/isBuffer":56,"_process":42,"inherits":40}],
"htmlparser2":[function(_dereq_,module,exports){
var Parser=_dereq_("./Parser.js"),
DomHandler=_dereq_("domhandler");

function defineProp(name,value){
delete module.exports[name];
module.exports[name] = value;
return value;}


module.exports = {
Parser:Parser,
Tokenizer:_dereq_("./Tokenizer.js"),
ElementType:_dereq_("domelementtype"),
DomHandler:DomHandler,
get FeedHandler(){
return defineProp("FeedHandler",_dereq_("./FeedHandler.js"));},

get Stream(){
return defineProp("Stream",_dereq_("./Stream.js"));},

get WritableStream(){
return defineProp("WritableStream",_dereq_("./WritableStream.js"));},

get ProxyHandler(){
return defineProp("ProxyHandler",_dereq_("./ProxyHandler.js"));},

get DomUtils(){
return defineProp("DomUtils",_dereq_("domutils"));},

get CollectingHandler(){
return defineProp("CollectingHandler",_dereq_("./CollectingHandler.js"));},


DefaultHandler:DomHandler,
get RssHandler(){
return defineProp("RssHandler",this.FeedHandler);},


parseDOM:function(data,options){
var handler=new DomHandler(options);
new Parser(handler,options).end(data);
return handler.dom;},

parseFeed:function(feed,options){
var handler=new module.exports.FeedHandler(options);
new Parser(handler,options).end(feed);
return handler.dom;},

createDomStream:function(cb,options,elementCb){
var handler=new DomHandler(cb,options,elementCb);
return new Parser(handler,options);},


EVENTS:{

attribute:2,
cdatastart:0,
cdataend:0,
text:1,
processinginstruction:2,
comment:1,
commentend:0,
closetag:1,
opentag:2,
opentagname:1,
error:1,
end:0}};},



{
"./CollectingHandler.js":1,
"./FeedHandler.js":2,
"./Parser.js":3,
"./ProxyHandler.js":4,
"./Stream.js":5,
"./Tokenizer.js":6,
"./WritableStream.js":7,
"domelementtype":8,
"domhandler":9,
"domutils":12}]},

{},[])("htmlparser2");});
});
__d('noder/app/components/overlay/return.js',["react-native/Libraries/react-native/react-native.js","react-native-button/Button.js","react-native-icons/index.js","noder/app/components/overlay/overlayButton.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');

var Button=require('react-native-button/Button.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;

var OverlayButton=require('noder/app/components/overlay/overlayButton.js');


var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=





React.View;var Text=React.Text;var Component=React.Component;var TouchableHighlight=React.TouchableHighlight;var StyleSheet=React.StyleSheet;var Navigator=React.Navigator;


var returnSize=45;


var styles=StyleSheet.create({
returnIcon:{
height:returnSize,
width:returnSize,
borderRadius:returnSize / 2}});var 




Return=(function(_Component){_inherits(Return,_Component);
function Return(props){_classCallCheck(this,Return);
_get(Object.getPrototypeOf(Return.prototype),'constructor',this).call(this,props);}_createClass(Return,[{key:'_onPress',value:



function _onPress(){
this.props.router && this.props.router.pop && this.props.router.pop();}},{key:'render',value:



function render(){
return (
React.createElement(OverlayButton,{
onPress:this._onPress.bind(this)},
React.createElement(Icon,{
name:'ion|ios-arrow-thin-left',
size:30,
color:'rgba(255,255,255,1)',
style:styles.returnIcon})));}}]);return Return;})(Component);





module.exports = Return;
});
__d('noder/app/components/overlay/commentOverlay.js',["Dimensions","react-native/Libraries/react-native/react-native.js","react-native-icons/index.js","react-native-button/Button.js","noder/app/components/overlay/overlayButton.js","noder/app/configs/config.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Dimensions=require('Dimensions');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;
var Button=require('react-native-button/Button.js');


var OverlayButton=require('noder/app/components/overlay/overlayButton.js');


var config=require('noder/app/configs/config.js');var _Dimensions$get=

Dimensions.get('window');var width=_Dimensions$get.width;var height=_Dimensions$get.height;var 



View=











React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;var AsyncStorage=React.AsyncStorage;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;

var overlaySize=45;

var iconSize=12;

var styles=StyleSheet.create({
position:{
right:20,
bottom:20},

commentText:{
textAlign:'center',
color:'white',
fontSize:12,
paddingLeft:4},

content:{
height:overlaySize,
width:overlaySize,
borderRadius:overlaySize / 2,
flexDirection:'row',
justifyContent:'center',
alignItems:'center'},

commentIcon:{
height:iconSize,
width:iconSize}});var 




CommentOverlay=(function(_Component){_inherits(CommentOverlay,_Component);
function CommentOverlay(props){_classCallCheck(this,CommentOverlay);
_get(Object.getPrototypeOf(CommentOverlay.prototype),'constructor',this).call(this,props);}_createClass(CommentOverlay,[{key:'_renderCommentReplyCount',value:



function _renderCommentReplyCount(count){
if(count > 999){
return '1k+';}

return count;}},{key:'render',value:


function render(){
return (
React.createElement(OverlayButton,{
position:styles.position,
onPress:this.props.onPress},
React.createElement(View,{style:styles.content},
React.createElement(Icon,{
name:'ion|chatbox',
size:13,
color:'white',
style:styles.commentIcon}),

React.createElement(Text,{style:styles.commentText},
this._renderCommentReplyCount(this.props.topic.reply_count)))));}}]);return CommentOverlay;})(Component);








module.exports = CommentOverlay;
});
__d('noder/app/components/likeIcon.js',["react-native/Libraries/react-native/react-native.js","react-native-icons/index.js","noder/app/services/topicService.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;

var topicService=require('noder/app/services/topicService.js');var 



View=




React.View;var Component=React.Component;var TouchableOpacity=React.TouchableOpacity;var StyleSheet=React.StyleSheet;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;var 


LikeIcon=(function(_Component){_inherits(LikeIcon,_Component);
function LikeIcon(props){_classCallCheck(this,LikeIcon);
_get(Object.getPrototypeOf(LikeIcon.prototype),'constructor',this).call(this,props);
var userInfo=this.props.user;
var isLiked;
if(userInfo && userInfo.collect_topics){
isLiked = this._isLiked(userInfo.collect_topics);}

this.state = {
isLoading:false,
isLiked:isLiked};}_createClass(LikeIcon,[{key:'componentWillReceiveProps',value:



function componentWillReceiveProps(nextProps){
var userInfo=nextProps.user;
var isLiked;
if(userInfo && userInfo.collect_topics){
isLiked = this._isLiked(userInfo.collect_topics);}

this.setState({
isLiked:isLiked});}},{key:'_isLiked',value:




function _isLiked(collections){
var id=this.props.topic.id;
return collections.some(function(item){
return item.id == id;});}},{key:'_onLikedPress',value:




function _onLikedPress(){var _this=this;
if(!this.props.user || this.state.isLoading){
return;}

this.setState({
isLoading:true});


var topic=this.props.topic;


topicService.req.markTopicAsLike(topic.id,this.props.user.token,this.state.isLiked).
then(function(){
var actions=_this.props.actions;
var likeTopic=actions.likeTopic;
var unLikeTopic=actions.unLikeTopic;

!_this.state.isLiked?likeTopic(topic):unLikeTopic(topic.id);

_this.setState({
isLoading:false});}).



catch(function(err){
console.warn(err);
_this.setState({
isLoading:false});}).


done();}},{key:'_renderIcon',value:



function _renderIcon(){
if(this.state.isLoading){
return (
React.createElement(View,null,
React.createElement(ActivityIndicatorIOS,{
color:'rgba(255,255,255,0.8)',
style:[this.props.style]})));}




return (
React.createElement(Icon,{
name:this.state.isLiked?'ion|ios-heart':'ion|ios-heart-outline',
size:20,
color:'rgba(255,255,255,0.99)',
style:this.props.style}));}},{key:'render',value:





function render(){
return (
React.createElement(TouchableOpacity,{
onPress:this._onLikedPress.bind(this)},
this._renderIcon()));}}]);return LikeIcon;})(Component);






module.exports = LikeIcon;
});
__d('noder/app/services/topicService.js',["noder/app/services/request.js","noder/app/util/storage.js","noder/app/configs/config.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var request=require('noder/app/services/request.js');
var Storage=require('noder/app/util/storage.js');

var config=require('noder/app/configs/config.js');
var tabs=['good','ask','all','share','job'];


var storage={};

storage.get = function(tab){
return Storage.getItem('tab_' + tab).
then(function(topics){
if(topics){
return topics;}

throw 'topicsInStorageIsEmpty';});};



storage.getAll = function(){
return Storage.multiGet(tabs.map(function(tab){
return 'tab_' + tab;}));};




var req={};


req.getTopicsByTab = function(params){
var url=config.domain + '/api/v1/topics';

return request.get(url,params).
then(function(data){return data.data;}).
then(function(topics){
if(params.page == 1 && topics){
Storage.setItem('tab_' + params.tab,topics);}

return topics;});};




req.getTopicById = function(id){
var url=config.domain + '/api/v1/topic/' + id;
return request.get(url).
then(function(data){return data.data;}).
then(function(topic){
if(topic && topic.id){
return topic;}

throw 'GetTopicError';});};




req.markTopicAsLike = function(id,token,isLiked){
var apiUrl=config.domain + config.apiPath;

if(!isLiked){
apiUrl += '/topic/collect';}else 

{
apiUrl += '/topic/de_collect';}


console.log(apiUrl);

return request.post(apiUrl,{
accesstoken:token,
topic_id:id}).

then(function(data){
console.log(data);
if(!data.success){
throw 'error';}

return data;});};




req.reply = function(topicId,content,token,replyId){
var apiUrl=config.domain + config.apiPath;
var body={
accesstoken:token,
content:content};

if(replyId){
body.reply_id = replyId;}

var url=apiUrl + '/topic/' + topicId + '/replies';

return request.post(url,body).
then(function(data){
if(data.success){
return data.reply_id;}else 

{
throw 'do reply failed';}});};





exports.storage = storage;
exports.req = req;
});
__d('noder/app/services/request.js',["query-string/index.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var queryString=require('query-string/index.js');

var request={};

request.get = function(url,params){
if(params){
url += '?' + queryString.stringify(params);}

return fetch(url).
then(function(res){return res.json();});};



request.post = function(url,body){
var fetchOptions={
method:'POST',
headers:{
'Accept':'application/json',
'Content-Type':'application/json'},

body:JSON.stringify(body)};


return fetch(url,fetchOptions).
then(function(res){return res.json();});};



module.exports = request;
});
__d('query-string/index.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.extract = function(maybeUrl){
return maybeUrl.split('?')[1] || '';};


exports.parse = function(str){
if(typeof str !== 'string'){
return {};}


str = str.trim().replace(/^(\?|#|&)/,'');

if(!str){
return {};}


return str.split('&').reduce(function(ret,param){
var parts=param.replace(/\+/g,' ').split('=');
var key=parts[0];
var val=parts[1];

key = decodeURIComponent(key);


val = val === undefined?null:decodeURIComponent(val);

if(!ret.hasOwnProperty(key)){
ret[key] = val;}else 
if(Array.isArray(ret[key])){
ret[key].push(val);}else 
{
ret[key] = [ret[key],val];}


return ret;},
{});};


exports.stringify = function(obj){
return obj?Object.keys(obj).sort().map(function(key){
var val=obj[key];

if(Array.isArray(val)){
return val.sort().map(function(val2){
return encodeURIComponent(key) + '=' + encodeURIComponent(val2);}).
join('&');}


return encodeURIComponent(key) + '=' + encodeURIComponent(val);}).
join('&'):'';};
});
__d('noder/app/util/storage.js',["react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var React=require('react-native/Libraries/react-native/react-native.js');

var AsyncStorage=React.AsyncStorage;

var Storage={};


Storage.setItem = function(key,value){
if(value == null)return Promise.reject('value is null');
return AsyncStorage.setItem(key,JSON.stringify(value));};


Storage.getItem = function(key){
var result=AsyncStorage.getItem(key).
then(function(value){
return JSON.parse(value);});


return result;};


Storage.clear = AsyncStorage.clear;

Storage.removeItem = AsyncStorage.removeItem;

Storage.multiGet = function(keys){
return AsyncStorage.multiGet(keys).
then(function(results){
return results.map(function(item){
return [item[0],JSON.parse(item[1])];});});};




module.exports = Storage;
});
__d('noder/app/util/genColor.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var colors=['#E74C3C','#C0392B','#1ABC9C',
'#16A085','#2ECC71','#27AE60','#3498DB',
'#2980B9','#9B59B6','#8E44AD','#34495E',
'#2C3E50','#F1C40F','#F39C12','#E67E22',
'#D35400','#95A5A6','#7F8C8D'];


function getRandomNum(Min,Max){
var Range=Max - Min;
var Rand=Math.random();
return Min + Math.round(Rand * Range);}


module.exports = function(){
return colors[getRandomNum(0,colors.length - 1)];};
});
__d('noder/app/configs/sceneConfig.js',["Dimensions","react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var React=require('react-native/Libraries/react-native/react-native.js');
var Dimensions=require('Dimensions');var 


Navigator=
React.Navigator;var _Dimensions$get=

Dimensions.get('window');var width=_Dimensions$get.width;var height=_Dimensions$get.height;


var baseConfig=Navigator.SceneConfigs.FloatFromRight;
var popGestureConfig=Object.assign({},baseConfig.gestures.pop,{
edgeHitWidth:width / 3});



exports.customFloatFromRight = Object.assign({},baseConfig,{
gestures:{
pop:popGestureConfig}});
});
__d('noder/app/components/TabBar.js',["Dimensions","precomputeStyle","react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

var React=require('react-native/Libraries/react-native/react-native.js');var 

StyleSheet=



React.StyleSheet;var Text=React.Text;var View=React.View;var TouchableOpacity=React.TouchableOpacity;

var deviceWidth=require('Dimensions').get('window').width;
var precomputeStyle=require('precomputeStyle');
var TAB_UNDERLINE_REF='TAB_UNDERLINE';
var underLineColor='#3498DB';
var activeTabTextColor='rgba(0,0,0,9)';
var normalTabTextColor='rgba(0,0,0,0.4)';

var styles=StyleSheet.create({
tab:{
flex:1,
alignItems:'center',
justifyContent:'center',
paddingBottom:10,
paddingTop:10},


tabs:{
height:50 + 4,
flexDirection:'row',
marginTop:0,
borderWidth:1,
borderTopWidth:0,
borderLeftWidth:0,
borderRightWidth:0,
borderBottomColor:'rgba(0,0,0,0.06)'}});










var DefaultTabBar=React.createClass({displayName:'DefaultTabBar',
propTypes:{
goToPage:React.PropTypes.func,
activeTab:React.PropTypes.number,
tabs:React.PropTypes.array},


renderTabOption:function(name,page){var _this=this;
var isTabActive=this.props.activeTab === page;

return (
React.createElement(TouchableOpacity,{key:name,onPress:function(){return _this.props.goToPage(page);}},
React.createElement(View,{style:[styles.tab]},
React.createElement(Text,{
style:{color:isTabActive?activeTabTextColor:normalTabTextColor,fontWeight:isTabActive?'bold':'normal'}},name))));},





setAnimationValue:function(value){
this.refs[TAB_UNDERLINE_REF].setNativeProps(precomputeStyle({
left:deviceWidth * value / this.props.tabs.length}));},



render:function(){var _this2=this;
var numberOfTabs=this.props.tabs.length;
var tabUnderlineStyle={
position:'absolute',
width:deviceWidth / numberOfTabs,
height:4,
backgroundColor:underLineColor,
bottom:0};


return (
React.createElement(View,{style:styles.tabs},
this.props.tabs.map(function(tab,i){return _this2.renderTabOption(tab,i);}),
React.createElement(View,{style:tabUnderlineStyle,ref:TAB_UNDERLINE_REF})));}});





module.exports = DefaultTabBar;
});
__d('noder/app/services/userService.js',["noder/app/util/storage.js","noder/app/configs/config.js","noder/app/services/request.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var Storage=require('noder/app/util/storage.js');
var config=require('noder/app/configs/config.js');
var request=require('noder/app/services/request.js');

var storage={};


storage.saveUser = function(user){
return Storage.setItem('user',user);};



storage.clearUser = function(){
return Storage.removeItem('user');};



storage.saveUserInfo = function(userInfo){
return Storage.setItem('userInfo',userInfo);};



storage.getUser = function(){
return Storage.getItem('user');};


storage.getUserInfo = function(){
return Storage.getItem('userInfo');};


storage.getUserAndUserInfo = function(){
return Promise.all([
storage.getUser(),
storage.getUserInfo()]).

then(function(results){
return {
user:results[0],
userInfo:results[1]};});};





var req={};


req.getLoginUserInfo = function(user){
var apiUrl=config.domain + config.apiPath;

return request.get(apiUrl + '/user/' + user.loginname).
then(function(data){return data.data;}).
then(function(userInfo){
if(userInfo){
Storage.setItem('userInfo',userInfo);
return userInfo;}

return Storage.getItem('userInfo');});};




req.getUserInfo = function(userName){
var apiUrl=config.domain + config.apiPath;

return request.get(apiUrl + '/user/' + userName).
then(function(data){
if(data.error_msg){
throw 'UserNotExist';}

return data;}).

then(function(data){return data.data;});};



req.checkToken = function(token){
var apiUrl=config.domain + config.apiPath + '/accesstoken';
return request.post(apiUrl,{
accesstoken:token}).

then(function(data){
if(data.success){
data.token = token;
Storage.setItem('user',data);
return data;}

throw 'wrong token';});};



exports.storage = storage;
exports.req = req;
});
__d('noder/app/scene/comments.js',["precomputeStyle","react-native/Libraries/react-native/react-native.js","noder/app/util/window.js","moment/moment.js","react-native-icons/index.js","react-native-keyboardevents/KeyboardEvents.ios.js","markdown/lib/index.js","noder/app/components/htmlRender/htmlContent.js","noder/app/components/overlay/return.js","noder/app/components/overlay/commentOverlay.js","noder/app/components/htmlRender/commentHtml.js","noder/app/util/storage.js","noder/app/services/topicService.js","noder/app/util/genColor.js","noder/app/configs/config.js","noder/app/util/animation.js","noder/app/configs/sceneConfig.js","noder/app/configs/routes.js","noder/app/scene/topic.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;
var precomputeStyle=require('precomputeStyle');


var moment=require('moment/moment.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;
var KeyboardEvents=require('react-native-keyboardevents/KeyboardEvents.ios.js');
var KeyboardEventEmitter=KeyboardEvents.Emitter;
var markdown=require('markdown/lib/index.js').markdown;

var HtmlContent=require('noder/app/components/htmlRender/htmlContent.js');
var Return=require('noder/app/components/overlay/return.js');
var CommentOverlay=require('noder/app/components/overlay/commentOverlay.js');
var CommentHtml=require('noder/app/components/htmlRender/commentHtml.js');
var Storage=require('noder/app/util/storage.js');

var topicService=require('noder/app/services/topicService.js');

var genColor=require('noder/app/util/genColor.js');
var config=require('noder/app/configs/config.js');
var animations=require('noder/app/util/animation.js');
var sceneConfig=require('noder/app/configs/sceneConfig.js');
var routes=require('noder/app/configs/routes.js');var 


View=














React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;var TouchableOpacity=React.TouchableOpacity;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;var PushNotificationIOS=React.PushNotificationIOS;var TextInput=React.TextInput;var LayoutAnimation=React.LayoutAnimation;

var navHeight=55;
var authorImgSize=35;
var commentContentOffset=15 * 2 + authorImgSize;
var commentIconSize=12;
var replyFormHeight=55;
var commentsHeight=height - 40 - 20 - replyFormHeight;
var submitButtonWidth=55;


var styles=StyleSheet.create({
container:{
backgroundColor:'white',
height:height},

nav:{
height:navHeight,
width:width,
borderBottomColor:'rgba(0,0,0,0.03)',
borderBottomWidth:1,
flexDirection:'row',
justifyContent:'center',
alignItems:'center'},


navReturn:{
height:navHeight,
position:'absolute',
left:0,
top:0,
paddingLeft:15,
paddingRight:15},


navToTopic:{
height:navHeight,
position:'absolute',
right:0,
top:0,
paddingLeft:15,
paddingRight:15},

navReturnText:{
lineHeight:navHeight - 20,
fontSize:16},


titleText:{
color:'rgba(0,0,0,0.7)',
fontSize:16},


countText:{
color:'rgba(0,0,0,0.45)'},


comments:{

width:width,
height:commentsHeight},


commentWrapper:{
borderBottomColor:'rgba(0,0,0,0.02)',
borderBottomWidth:1,
padding:15,
flexDirection:'row'},


commentHeader:{
flexDirection:'row',
alignItems:'center'},


date:{
flexDirection:'row',
flex:1},


author:{
flex:1},

authorText:{
color:'rgba(0,0,0,0.3)',
fontSize:12},


dateIcon:{
height:commentIconSize,
width:commentIconSize,
flexDirection:'row'},


dateText:{
color:'rgba(0,0,0,0.3)',
fontSize:12,
textAlign:'right',
flex:1},


commentIcon:{
height:commentIconSize,
width:commentIconSize},



imageWrapper:{
width:authorImgSize + 15},


commentNumText:{
marginTop:15,
fontSize:12,
color:'rgba(0,0,0,0.3)',
textAlign:'center',
width:authorImgSize},



commentContentWrapper:{
width:width - commentContentOffset - 15},


authorImg:{
height:authorImgSize,
width:authorImgSize,
borderRadius:authorImgSize / 2},


commentFooter:{
flexDirection:'row',
flex:1,
justifyContent:'space-between',
alignItems:'flex-start',
marginTop:15},

up:{
width:80},

replyIcon:{
height:12,
width:15},

upIcon:{
height:10,
width:13},

replyFormWrapper:{
height:replyFormHeight + 4,
width:width,
flexDirection:'row',
shadowColor:'rgba(0,0,0,1)',
shadowOffset:{
width:-2,
height:-2},

shadowOpacity:0.1,
alignItems:'center'},

replyUserImgWrapper:{
width:authorImgSize + 15 * 2,
flexDirection:'row',
justifyContent:'center'},

userImg:{
height:authorImgSize,
width:authorImgSize,
resizeMode:Image.resizeMode.contain},

replyInputWrapper:{
width:width - replyFormHeight - submitButtonWidth,
flexDirection:'row',
alignItems:'center'},

replyInput:{
flex:1,
fontSize:14,
height:14 * 2,
lineHeight:14 * 1.4},

submitIcon:{
width:authorImgSize,
height:authorImgSize}});




var commentHtmlStyle=StyleSheet.create({
img:{
width:width - commentContentOffset - 15,
height:width - commentContentOffset - 15,
resizeMode:Image.resizeMode.contain}});var 




Comments=(function(_Component){_inherits(Comments,_Component);
function Comments(props){_classCallCheck(this,Comments);
_get(Object.getPrototypeOf(Comments.prototype),'constructor',this).call(this,props);
var ds=new ListView.DataSource({rowHasChanged:function(r1,r2){return r1 !== r2;}});
var data=[];
this.state = {
ds:ds.cloneWithRows(data),
commentLoading:false,
textInput:null,
replyUploading:false,
isLoaded:false,
didFocus:false};

this.updateKeyboardSpace = this.updateKeyboardSpace.bind(this);
this.resetKeyboardSpace = this.resetKeyboardSpace.bind(this);}_createClass(Comments,[{key:'updateKeyboardSpace',value:


function updateKeyboardSpace(frames){
LayoutAnimation.configureNext(animations.keyboard.layout.spring);
this.commentsView.setNativeProps({
height:commentsHeight - frames.end.height});}},{key:'resetKeyboardSpace',value:



function resetKeyboardSpace(){
LayoutAnimation.configureNext(animations.keyboard.layout.spring);
this.commentsView.setNativeProps({
height:commentsHeight});}},{key:'componentDidMount',value:




function componentDidMount(){
this.flag = 0;
this._fetchComment();
KeyboardEventEmitter.on(KeyboardEvents.KeyboardDidShowEvent,this.updateKeyboardSpace);
KeyboardEventEmitter.on(KeyboardEvents.KeyboardWillHideEvent,this.resetKeyboardSpace);}},{key:'componentDidFocus',value:



function componentDidFocus(){
this.setState({
didFocus:true});}},{key:'componentWillUnmount',value:




function componentWillUnmount(){
KeyboardEventEmitter.off(KeyboardEvents.KeyboardDidShowEvent,this.updateKeyboardSpace);
KeyboardEventEmitter.off(KeyboardEvents.KeyboardWillHideEvent,this.resetKeyboardSpace);}},{key:'componentDidUpdate',value:



function componentDidUpdate(){}},{key:'_scrollToReply',value:




function _scrollToReply(){var _this=this;
var reply=this.props.reply;
if(reply && this.flag == 1){
var row=this[reply.id];
if(row && row.measure){
row.measure(function(x,y,width,height,pageX,pageY){
_this._listView.setNativeProps({
contentOffset:{
x:0,
y:y}});});




row.setNativeProps(precomputeStyle({
styles:{
backgroundColor:'red'}}));}}}},{key:'_fetchComment',value:







function _fetchComment(){var _this2=this;
if(this.state.commentLoading){
return;}


this.setState({
commentLoading:true});

topicService.req.getTopicById(this.props.topic.id).
then(function(topic){
_this2.topic = topic;
return topic.replies;}).

then(function(replies){
return replies.reverse();}).

then(function(comments){
_this2.comments = comments;
_this2.setState({
ds:_this2.state.ds.cloneWithRows(_this2.comments),
commentLoading:false,
isLoaded:true});}).


catch(function(err){
console.warn(err);
_this2.setState({
commentLoading:false});}).


done();}},{key:'_doReply',value:



function _doReply(){var _this3=this;
if(this.state.replyUploading || this.state.textInput == '' || this.state.textInput == null){
return;}

var user=this.props.state.user;
var topic=this.props.topic;
var content=this.state.textInput + config.replySuffix;

this.setState({
replyUploading:true});



topicService.req.reply(topic.id,content,user.token,this.replyId).
then(function(replyId){
var newReply={
id:replyId,
author:{
loginname:user.loginname,
avatar_url:user.avatar_url},

content:markdown.toHTML(content),
ups:[],
create_at:new Date()};

_this3.comments = [newReply].concat(_this3.comments);
_this3.replyId = null;
_this3.setState({
ds:_this3.state.ds.cloneWithRows(_this3.comments),
textInput:'',
replyUploading:false});

_this3.textInput.blur();}).

catch(function(err){
console.warn(err);
_this3.setState({
replyUploading:false});}).


done();}},{key:'_onReplyPress',value:



function _onReplyPress(id,authorName){
this.textInput.focus();
this.setState({
textInput:'@' + authorName + ' '});

this.replyId = id;}},{key:'_onAuthorTextPress',value:



function _onAuthorTextPress(authorName){
var textInput=this.state.textInput || '';

this.setState({
textInput:textInput + (' @' + authorName + ' ')});}},{key:'_onSubmitPress',value:




function _onSubmitPress(){
this._doReply();}},{key:'_onReturnPress',value:



function _onReturnPress(){
Navigator.getContext(this).pop();}},{key:'_onReturnToTopic',value:



function _onReturnToTopic(){
var Topic=require('noder/app/scene/topic.js');
Navigator.getContext(this).push({
component:Topic,
sceneConfig:sceneConfig.customFloatFromRight,
name:'topic',
props:{
topic:this.topic}});}},{key:'_onAuthorImgPress',value:





function _onAuthorImgPress(authorName){
routes.toUser(this,{
userName:authorName});}},{key:'_onUpPress',value:




function _onUpPress(){}},{key:'_onCommentTitlePress',value:




function _onCommentTitlePress(){
this._listView.setNativeProps({
contentOffset:{
x:0,
y:0}});}},{key:'renderRow',value:





function renderRow(comment,sectionID,rowID,highlightRow){var _this4=this;
var authorName=comment.author.loginname;
var domain=config.domain;
var date=moment(comment.create_at).startOf('minute').fromNow();
var commentNum=this.comments.length - parseInt(rowID);
var focusStyle={};
if(this.props.reply){
var replyId=this.props.reply.id;

if(replyId == comment.id){
focusStyle = {
backgroundColor:'rgba(0,2,125,0.07)'};}}




var footer=
React.createElement(View,{style:styles.commentFooter},
React.createElement(View,{style:styles.up},
React.createElement(TouchableOpacity,{
onPress:this._onUpPress.bind(this,comment.id)},
React.createElement(Icon,{
name:'ion|thumbsup',
size:20,
color:'rgba(0,0,0,0.2)',
style:styles.upIcon}))),




React.createElement(View,{style:styles.reply},
React.createElement(TouchableOpacity,{
onPress:this._onReplyPress.bind(this,comment.id,authorName)},
React.createElement(Icon,{
name:'ion|reply',
size:20,
color:'rgba(0,0,0,0.35)',
style:styles.replyIcon}))));







return (
React.createElement(View,{
ref:function(view){return _this4[comment.id] = view;},
key:comment.id,
style:[styles.commentWrapper,focusStyle]},
React.createElement(View,{style:[styles.imageWrapper]},
React.createElement(TouchableOpacity,{onPress:this._onAuthorImgPress.bind(this,authorName)},
React.createElement(Image,{
style:styles.authorImg,
source:{uri:domain + comment.author.avatar_url}})),




React.createElement(Text,{style:styles.commentNumText},
commentNum,' 楼')),



React.createElement(View,{style:styles.commentContentWrapper},
React.createElement(View,{style:styles.commentHeader},
React.createElement(View,{style:styles.author},
React.createElement(TouchableOpacity,{onPress:this._onAuthorTextPress.bind(this,authorName)},
React.createElement(Text,{style:styles.authorText},
{authorName:authorName}))),




React.createElement(View,{style:styles.date},
React.createElement(Text,{style:styles.dateText},
date))),




React.createElement(View,{style:styles.commentContent},
React.createElement(CommentHtml,{
router:this.props.router,
style:commentHtmlStyle,
content:comment.content})),


!this.props.state.user || footer)));}},{key:'_renderComments',value:






function _renderComments(){var _this5=this;
if(this.state.didFocus && this.state.isLoaded){
return (
React.createElement(ListView,{
ref:function(view){return _this5._listView = view;},
style:{backgroundColor:'rgba(255,255,255,1)'},
showsVerticalScrollIndicator:true,
initialListSize:10,
pagingEnabled:false,
removeClippedSubviews:true,
dataSource:this.state.ds,
renderRow:this.renderRow.bind(this)}));}




return (
React.createElement(ActivityIndicatorIOS,{
size:'large',
animating:true,
style:{marginTop:20,width:width}}));}},{key:'_renderReplySubmiteIcon',value:




function _renderReplySubmiteIcon(){
if(this.state.replyUploading){
return (
React.createElement(View,null,
React.createElement(ActivityIndicatorIOS,{
style:styles.submitIcon})));}




return (
React.createElement(Icon,{
name:'ion|reply',
size:28,
color:'rgba(0,0,0,0.35)',
style:styles.submitIcon}));}},{key:'_renderReplyForm',value:





function _renderReplyForm(){var _this6=this;
var user=this.props.state.user;

if(!user)return null;

var userImg=config.domain + user.avatar_url;

return (
React.createElement(View,{style:styles.replyFormWrapper},
React.createElement(View,{style:styles.replyUserImgWrapper},
React.createElement(Image,{
style:styles.userImg,
source:{uri:userImg}})),


React.createElement(View,{style:styles.replyInputWrapper},
React.createElement(TextInput,{
ref:function(view){return _this6.textInput = view;},
value:this.state.textInput,
multiline:true,
placeholder:'嘿，说点啥吧',
style:styles.replyInput,
onChangeText:function(text){
_this6.setState({
textInput:text});}})),





React.createElement(View,{style:styles.submit},
React.createElement(TouchableOpacity,{
onPress:this._onSubmitPress.bind(this)},
this._renderReplySubmiteIcon()))));}},{key:'render',value:







function render(){var _this7=this;
var count=this.state.ds.getRowCount();
var returnToTopic=
React.createElement(TouchableHighlight,{
onPress:this._onReturnToTopic.bind(this),
underlayColor:'rgba(0,0,0,0.1)',
style:styles.navToTopic},
React.createElement(Text,{style:styles.navReturnText},'正文'));





return (
React.createElement(View,{style:styles.container},
React.createElement(View,{
ref:function(view){return _this7.nav = view;},
style:styles.nav},
React.createElement(TouchableHighlight,{
onPress:this._onReturnPress.bind(this),
underlayColor:'rgba(0,0,0,0.1)',
style:styles.navReturn},
React.createElement(Text,{style:styles.navReturnText},'返回')),




React.createElement(TouchableOpacity,{
onPress:this._onCommentTitlePress.bind(this),
style:styles.navTitle},
React.createElement(Text,{style:styles.titleText},'评论',

React.createElement(Text,{style:styles.countText},
' ' + count.toString()))),





this.state.didFocus && this.props.reply && this.state.isLoaded?returnToTopic:null),




React.createElement(View,{
ref:function(view){return _this7.commentsView = view;},
style:[styles.comments,{height:this.props.state.user?commentsHeight:commentsHeight + replyFormHeight}]},
this._renderComments()),


this._renderReplyForm()));}}]);return Comments;})(Component);





module.exports = Comments;
});
__d('react-native-keyboardevents/KeyboardEvents.ios.js',["react-native/Libraries/react-native/react-native.js","eventemitter3/index.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';var _require=






require('react-native/Libraries/react-native/react-native.js');var DeviceEventEmitter=_require.DeviceEventEmitter;var RNKeyboardEventsManager=_require.NativeModules.RNKeyboardEventsManager;
var EventEmitter=require('eventemitter3/index.js');

var KeyboardEventEmitter=new EventEmitter();
var events=[
'WillShow',
'DidShow',
'WillHide',
'DidHide',
'WillChangeFrame',
'DidChangeFrame'].
map(function(event){return 'Keyboard' + event;});

events.forEach(function(eventKey){
var event=RNKeyboardEventsManager[eventKey];
DeviceEventEmitter.addListener(
event,
function(frames){
KeyboardEventEmitter.emit(event,frames);});});




module.exports = events.reduce(function(carry,eventKey){
carry[eventKey + 'Event'] = RNKeyboardEventsManager[eventKey];
return carry;},
{
Emitter:KeyboardEventEmitter});
});
__d('eventemitter3/index.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';









var prefix=typeof Object.create !== 'function'?'~':false;









function EE(fn,context,once){
this.fn = fn;
this.context = context;
this.once = once || false;}









function EventEmitter(){}







EventEmitter.prototype._events = undefined;









EventEmitter.prototype.listeners = function listeners(event,exists){
var evt=prefix?prefix + event:event,
available=this._events && this._events[evt];

if(exists)return !!available;
if(!available)return [];
if(available.fn)return [available.fn];

for(var i=0,l=available.length,ee=new Array(l);i < l;i++) {
ee[i] = available[i].fn;}


return ee;};









EventEmitter.prototype.emit = function emit(event,a1,a2,a3,a4,a5){
var evt=prefix?prefix + event:event;

if(!this._events || !this._events[evt])return false;

var listeners=this._events[evt],
len=arguments.length,
args,
i;

if('function' === typeof listeners.fn){
if(listeners.once)this.removeListener(event,listeners.fn,undefined,true);

switch(len){
case 1:return (listeners.fn.call(listeners.context),true);
case 2:return (listeners.fn.call(listeners.context,a1),true);
case 3:return (listeners.fn.call(listeners.context,a1,a2),true);
case 4:return (listeners.fn.call(listeners.context,a1,a2,a3),true);
case 5:return (listeners.fn.call(listeners.context,a1,a2,a3,a4),true);
case 6:return (listeners.fn.call(listeners.context,a1,a2,a3,a4,a5),true);}


for(i = 1,args = new Array(len - 1);i < len;i++) {
args[i - 1] = arguments[i];}


listeners.fn.apply(listeners.context,args);}else 
{
var length=listeners.length,
j;

for(i = 0;i < length;i++) {
if(listeners[i].once)this.removeListener(event,listeners[i].fn,undefined,true);

switch(len){
case 1:listeners[i].fn.call(listeners[i].context);break;
case 2:listeners[i].fn.call(listeners[i].context,a1);break;
case 3:listeners[i].fn.call(listeners[i].context,a1,a2);break;
default:
if(!args)for(j = 1,args = new Array(len - 1);j < len;j++) {
args[j - 1] = arguments[j];}


listeners[i].fn.apply(listeners[i].context,args);}}}




return true;};










EventEmitter.prototype.on = function on(event,fn,context){
var listener=new EE(fn,context || this),
evt=prefix?prefix + event:event;

if(!this._events)this._events = prefix?{}:Object.create(null);
if(!this._events[evt])this._events[evt] = listener;else 
{
if(!this._events[evt].fn)this._events[evt].push(listener);else 
this._events[evt] = [
this._events[evt],listener];}



return this;};










EventEmitter.prototype.once = function once(event,fn,context){
var listener=new EE(fn,context || this,true),
evt=prefix?prefix + event:event;

if(!this._events)this._events = prefix?{}:Object.create(null);
if(!this._events[evt])this._events[evt] = listener;else 
{
if(!this._events[evt].fn)this._events[evt].push(listener);else 
this._events[evt] = [
this._events[evt],listener];}



return this;};











EventEmitter.prototype.removeListener = function removeListener(event,fn,context,once){
var evt=prefix?prefix + event:event;

if(!this._events || !this._events[evt])return this;

var listeners=this._events[evt],
events=[];

if(fn){
if(listeners.fn){
if(
listeners.fn !== fn || 
once && !listeners.once || 
context && listeners.context !== context)
{
events.push(listeners);}}else 

{
for(var i=0,length=listeners.length;i < length;i++) {
if(
listeners[i].fn !== fn || 
once && !listeners[i].once || 
context && listeners[i].context !== context)
{
events.push(listeners[i]);}}}}








if(events.length){
this._events[evt] = events.length === 1?events[0]:events;}else 
{
delete this._events[evt];}


return this;};








EventEmitter.prototype.removeAllListeners = function removeAllListeners(event){
if(!this._events)return this;

if(event)delete this._events[prefix?prefix + event:event];else 
this._events = prefix?{}:Object.create(null);

return this;};





EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.addListener = EventEmitter.prototype.on;




EventEmitter.prototype.setMaxListeners = function setMaxListeners(){
return this;};





EventEmitter.prefixed = prefix;




if('undefined' !== typeof module){
module.exports = EventEmitter;}
});
__d('markdown/lib/index.js',["markdown/lib/markdown.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  exports.
markdown = require("markdown/lib/markdown.js");
exports.parse = exports.markdown.toHTML;
});
__d('markdown/lib/markdown.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  (






function(expose){




























var Markdown=expose.Markdown = function(dialect){
switch(typeof dialect){
case "undefined":
this.dialect = Markdown.dialects.Gruber;
break;
case "object":
this.dialect = dialect;
break;
default:
if(dialect in Markdown.dialects){
this.dialect = Markdown.dialects[dialect];}else 

{
throw new Error("Unknown Markdown dialect '" + String(dialect) + "'");}

break;}

this.em_state = [];
this.strong_state = [];
this.debug_indent = "";};









expose.parse = function(source,dialect){

var md=new Markdown(dialect);
return md.toTree(source);};











expose.toHTML = function toHTML(source,dialect,options){
var input=expose.toHTMLTree(source,dialect,options);

return expose.renderJsonML(input);};













expose.toHTMLTree = function toHTMLTree(input,dialect,options){

if(typeof input === "string")input = this.parse(input,dialect);




var attrs=extract_attr(input),
refs={};

if(attrs && attrs.references){
refs = attrs.references;}


var html=convert_tree_to_html(input,refs,options);
merge_text_nodes(html);
return html;};



function mk_block_toSource(){
return "Markdown.mk_block( " + 
uneval(this.toString()) + 
", " + 
uneval(this.trailing) + 
", " + 
uneval(this.lineNumber) + 
" )";}



function mk_block_inspect(){
var util=require("util");
return "Markdown.mk_block( " + 
util.inspect(this.toString()) + 
", " + 
util.inspect(this.trailing) + 
", " + 
util.inspect(this.lineNumber) + 
" )";}



var mk_block=Markdown.mk_block = function(block,trail,line){

if(arguments.length == 1)trail = "\n\n";

var s=new String(block);
s.trailing = trail;

s.inspect = mk_block_inspect;
s.toSource = mk_block_toSource;

if(line != undefined)
s.lineNumber = line;

return s;};


function count_lines(str){
var n=0,i=-1;
while((i = str.indexOf("\n",i + 1)) !== -1) n++;
return n;}



Markdown.prototype.split_blocks = function splitBlocks(input,startLine){
input = input.replace(/(\r\n|\n|\r)/g,"\n");


var re=/([\s\S]+?)($|\n#|\n(?:\s*\n|$)+)/g,
blocks=[],
m;

var line_no=1;

if((m = /^(\s*\n)/.exec(input)) != null){

line_no += count_lines(m[0]);
re.lastIndex = m[0].length;}


while((m = re.exec(input)) !== null) {
if(m[2] == "\n#"){
m[2] = "\n";
re.lastIndex--;}

blocks.push(mk_block(m[1],m[2],line_no));
line_no += count_lines(m[0]);}


return blocks;};























Markdown.prototype.processBlock = function processBlock(block,next){
var cbs=this.dialect.block,
ord=cbs.__order__;

if("__call__" in cbs){
return cbs.__call__.call(this,block,next);}


for(var i=0;i < ord.length;i++) {

var res=cbs[ord[i]].call(this,block,next);
if(res){

if(!isArray(res) || res.length > 0 && !isArray(res[0]))
this.debug(ord[i],"didn't return a proper array");

return res;}}




return [];};


Markdown.prototype.processInline = function processInline(block){
return this.dialect.inline.__call__.call(this,String(block));};









Markdown.prototype.toTree = function toTree(source,custom_root){
var blocks=source instanceof Array?source:this.split_blocks(source);


var old_tree=this.tree;
try{
this.tree = custom_root || this.tree || ["markdown"];

blocks: 
while(blocks.length) {
var b=this.processBlock(blocks.shift(),blocks);


if(!b.length)continue blocks;

this.tree.push.apply(this.tree,b);}

return this.tree;}finally 

{
if(custom_root){
this.tree = old_tree;}}};





Markdown.prototype.debug = function(){
var args=Array.prototype.slice.call(arguments);
args.unshift(this.debug_indent);
if(typeof print !== "undefined")
print.apply(print,args);
if(typeof console !== "undefined" && typeof console.log !== "undefined")
console.log.apply(null,args);};


Markdown.prototype.loop_re_over_block = function(re,block,cb){

var m,
b=block.valueOf();

while(b.length && (m = re.exec(b)) != null) {
b = b.substr(m[0].length);
cb.call(this,m);}

return b;};







Markdown.dialects = {};









Markdown.dialects.Gruber = {
block:{
atxHeader:function atxHeader(block,next){
var m=block.match(/^(#{1,6})\s*(.*?)\s*#*\s*(?:\n|$)/);

if(!m)return undefined;

var header=["header",{level:m[1].length}];
Array.prototype.push.apply(header,this.processInline(m[2]));

if(m[0].length < block.length)
next.unshift(mk_block(block.substr(m[0].length),block.trailing,block.lineNumber + 2));

return [header];},


setextHeader:function setextHeader(block,next){
var m=block.match(/^(.*)\n([-=])\2\2+(?:\n|$)/);

if(!m)return undefined;

var level=m[2] === "="?1:2;
var header=["header",{level:level},m[1]];

if(m[0].length < block.length)
next.unshift(mk_block(block.substr(m[0].length),block.trailing,block.lineNumber + 2));

return [header];},


code:function code(block,next){






var ret=[],
re=/^(?: {0,3}\t| {4})(.*)\n?/,
lines;


if(!block.match(re))return undefined;

block_search: 
do {

var b=this.loop_re_over_block(
re,block.valueOf(),function(m){ret.push(m[1]);});

if(b.length){

next.unshift(mk_block(b,block.trailing));
break block_search;}else 

if(next.length){

if(!next[0].match(re))break block_search;


ret.push(block.trailing.replace(/[^\n]/g,"").substring(2));

block = next.shift();}else 

{
break block_search;}}while(

true);

return [["code_block",ret.join("\n")]];},


horizRule:function horizRule(block,next){

var m=block.match(/^(?:([\s\S]*?)\n)?[ \t]*([-_*])(?:[ \t]*\2){2,}[ \t]*(?:\n([\s\S]*))?$/);

if(!m){
return undefined;}


var jsonml=[["hr"]];


if(m[1]){
jsonml.unshift.apply(jsonml,this.processBlock(m[1],[]));}



if(m[3]){
next.unshift(mk_block(m[3]));}


return jsonml;},



















lists:(function(){

var any_list="[*+-]|\\d+\\.",
bullet_list=/[*+-]/,
number_list=/\d+\./,

is_list_re=new RegExp("^( {0,3})(" + any_list + ")[ \t]+"),
indent_re="(?: {0,3}\\t| {4})";



function regex_for_depth(depth){

return new RegExp(

"(?:^(" + indent_re + "{0," + depth + "} {0,3})(" + any_list + ")\\s+)|" + 

"(^" + indent_re + "{0," + (depth - 1) + "}[ ]{0,4})");}


function expand_tab(input){
return input.replace(/ {0,3}\t/g,"    ");}




function add(li,loose,inline,nl){
if(loose){
li.push(["para"].concat(inline));
return;}


var add_to=li[li.length - 1] instanceof Array && li[li.length - 1][0] == "para"?
li[li.length - 1]:
li;


if(nl && li.length > 1)inline.unshift(nl);

for(var i=0;i < inline.length;i++) {
var what=inline[i],
is_str=typeof what == "string";
if(is_str && add_to.length > 1 && typeof add_to[add_to.length - 1] == "string"){
add_to[add_to.length - 1] += what;}else 

{
add_to.push(what);}}}






function get_contained_blocks(depth,blocks){

var re=new RegExp("^(" + indent_re + "{" + depth + "}.*?\\n?)*$"),
replace=new RegExp("^" + indent_re + "{" + depth + "}","gm"),
ret=[];

while(blocks.length > 0) {
if(re.exec(blocks[0])){
var b=blocks.shift(),

x=b.replace(replace,"");

ret.push(mk_block(x,b.trailing,b.lineNumber));}else 

{
break;}}


return ret;}



function paragraphify(s,i,stack){
var list=s.list;
var last_li=list[list.length - 1];

if(last_li[1] instanceof Array && last_li[1][0] == "para"){
return;}

if(i + 1 == stack.length){


last_li.push(["para"].concat(last_li.splice(1,last_li.length - 1)));}else 

{
var sublist=last_li.pop();
last_li.push(["para"].concat(last_li.splice(1,last_li.length - 1)),sublist);}}




return function(block,next){
var m=block.match(is_list_re);
if(!m)return undefined;

function make_list(m){
var list=bullet_list.exec(m[2])?
["bulletlist"]:
["numberlist"];

stack.push({list:list,indent:m[1]});
return list;}



var stack=[],
list=make_list(m),
last_li,
loose=false,
ret=[stack[0].list],
i;


loose_search: 
while(true) {

var lines=block.split(/(?=\n)/);



var li_accumulate="";


tight_search: 
for(var line_no=0;line_no < lines.length;line_no++) {
var nl="",
l=lines[line_no].replace(/^\n/,function(n){nl = n;return "";});


var line_re=regex_for_depth(stack.length);

m = l.match(line_re);



if(m[1] !== undefined){

if(li_accumulate.length){
add(last_li,loose,this.processInline(li_accumulate),nl);

loose = false;
li_accumulate = "";}


m[1] = expand_tab(m[1]);
var wanted_depth=Math.floor(m[1].length / 4) + 1;

if(wanted_depth > stack.length){


list = make_list(m);
last_li.push(list);
last_li = list[1] = ["listitem"];}else 

{




var found=false;
for(i = 0;i < stack.length;i++) {
if(stack[i].indent != m[1])continue;
list = stack[i].list;
stack.splice(i + 1,stack.length - (i + 1));
found = true;
break;}


if(!found){

wanted_depth++;
if(wanted_depth <= stack.length){
stack.splice(wanted_depth,stack.length - wanted_depth);

list = stack[wanted_depth - 1].list;}else 


{

list = make_list(m);
last_li.push(list);}}




last_li = ["listitem"];
list.push(last_li);}

nl = "";}



if(l.length > m[0].length){
li_accumulate += nl + l.substr(m[0].length);}}



if(li_accumulate.length){
add(last_li,loose,this.processInline(li_accumulate),nl);

loose = false;
li_accumulate = "";}




var contained=get_contained_blocks(stack.length,next);


if(contained.length > 0){

forEach(stack,paragraphify,this);

last_li.push.apply(last_li,this.toTree(contained,[]));}


var next_block=next[0] && next[0].valueOf() || "";

if(next_block.match(is_list_re) || next_block.match(/^ /)){
block = next.shift();


var hr=this.dialect.block.horizRule(block,next);

if(hr){
ret.push.apply(ret,hr);
break;}



forEach(stack,paragraphify,this);

loose = true;
continue loose_search;}

break;}


return ret;};})(),



blockquote:function blockquote(block,next){
if(!block.match(/^>/m))
return undefined;

var jsonml=[];






if(block[0] != ">"){
var lines=block.split(/\n/),
prev=[],
line_no=block.lineNumber;


while(lines.length && lines[0][0] != ">") {
prev.push(lines.shift());
line_no++;}


var abutting=mk_block(prev.join("\n"),"\n",block.lineNumber);
jsonml.push.apply(jsonml,this.processBlock(abutting,[]));

block = mk_block(lines.join("\n"),block.trailing,line_no);}




while(next.length && next[0][0] == ">") {
var b=next.shift();
block = mk_block(block + block.trailing + b,b.trailing,block.lineNumber);}



var input=block.replace(/^> ?/gm,""),
old_tree=this.tree,
processedBlock=this.toTree(input,["blockquote"]),
attr=extract_attr(processedBlock);


if(attr && attr.references){
delete attr.references;

if(isEmpty(attr)){
processedBlock.splice(1,1);}}



jsonml.push(processedBlock);
return jsonml;},


referenceDefn:function referenceDefn(block,next){
var re=/^\s*\[(.*?)\]:\s*(\S+)(?:\s+(?:(['"])(.*?)\3|\((.*?)\)))?\n?/;


if(!block.match(re))
return undefined;


if(!extract_attr(this.tree)){
this.tree.splice(1,0,{});}


var attrs=extract_attr(this.tree);


if(attrs.references === undefined){
attrs.references = {};}


var b=this.loop_re_over_block(re,block,function(m){

if(m[2] && m[2][0] == "<" && m[2][m[2].length - 1] == ">")
m[2] = m[2].substring(1,m[2].length - 1);

var ref=attrs.references[m[1].toLowerCase()] = {
href:m[2]};


if(m[4] !== undefined)
ref.title = m[4];else 
if(m[5] !== undefined)
ref.title = m[5];});



if(b.length)
next.unshift(mk_block(b,block.trailing));

return [];},


para:function para(block,next){

return [["para"].concat(this.processInline(block))];}}};




Markdown.dialects.Gruber.inline = {

__oneElement__:function oneElement(text,patterns_or_re,previous_nodes){
var m,
res,
lastIndex=0;

patterns_or_re = patterns_or_re || this.dialect.inline.__patterns__;
var re=new RegExp("([\\s\\S]*?)(" + (patterns_or_re.source || patterns_or_re) + ")");

m = re.exec(text);
if(!m){

return [text.length,text];}else 

if(m[1]){

return [m[1].length,m[1]];}


var res;
if(m[2] in this.dialect.inline){
res = this.dialect.inline[m[2]].call(
this,
text.substr(m.index),m,previous_nodes || []);}


res = res || [m[2].length,m[2]];
return res;},


__call__:function inline(text,patterns){

var out=[],
res;

function add(x){

if(typeof x == "string" && typeof out[out.length - 1] == "string")
out[out.length - 1] += x;else 

out.push(x);}


while(text.length > 0) {
res = this.dialect.inline.__oneElement__.call(this,text,patterns,out);
text = text.substr(res.shift());
forEach(res,add);}


return out;},




"]":function(){},
"}":function(){},

__escape__:/^\\[\\`\*_{}\[\]()#\+.!\-]/,

"\\":function escaped(text){


if(this.dialect.inline.__escape__.exec(text))
return [2,text.charAt(1)];else 


return [1,"\\"];},


"![":function image(text){






var m=text.match(/^!\[(.*?)\][ \t]*\([ \t]*([^")]*?)(?:[ \t]+(["'])(.*?)\3)?[ \t]*\)/);

if(m){
if(m[2] && m[2][0] == "<" && m[2][m[2].length - 1] == ">")
m[2] = m[2].substring(1,m[2].length - 1);

m[2] = this.dialect.inline.__call__.call(this,m[2],/\\/)[0];

var attrs={alt:m[1],href:m[2] || ""};
if(m[4] !== undefined)
attrs.title = m[4];

return [m[0].length,["img",attrs]];}



m = text.match(/^!\[(.*?)\][ \t]*\[(.*?)\]/);

if(m){


return [m[0].length,["img_ref",{alt:m[1],ref:m[2].toLowerCase(),original:m[0]}]];}



return [2,"!["];},


"[":function link(text){

var orig=String(text);

var res=Markdown.DialectHelpers.inline_until_char.call(this,text.substr(1),"]");


if(!res)return [1,"["];

var consumed=1 + res[0],
children=res[1],
link,
attrs;



text = text.substr(consumed);







var m=text.match(/^\s*\([ \t]*([^"']*)(?:[ \t]+(["'])(.*?)\2)?[ \t]*\)/);
if(m){
var url=m[1];
consumed += m[0].length;

if(url && url[0] == "<" && url[url.length - 1] == ">")
url = url.substring(1,url.length - 1);


if(!m[3]){
var open_parens=1;
for(var len=0;len < url.length;len++) {
switch(url[len]){
case "(":
open_parens++;
break;
case ")":
if(--open_parens == 0){
consumed -= url.length - len;
url = url.substring(0,len);}

break;}}}





url = this.dialect.inline.__call__.call(this,url,/\\/)[0];

attrs = {href:url || ""};
if(m[3] !== undefined)
attrs.title = m[3];

link = ["link",attrs].concat(children);
return [consumed,link];}




m = text.match(/^\s*\[(.*?)\]/);

if(m){

consumed += m[0].length;


attrs = {ref:(m[1] || String(children)).toLowerCase(),original:orig.substr(0,consumed)};

link = ["link_ref",attrs].concat(children);




return [consumed,link];}




if(children.length == 1 && typeof children[0] == "string"){

attrs = {ref:children[0].toLowerCase(),original:orig.substr(0,consumed)};
link = ["link_ref",attrs,children[0]];
return [consumed,link];}



return [1,"["];},



"<":function autoLink(text){
var m;

if((m = text.match(/^<(?:((https?|ftp|mailto):[^>]+)|(.*?@.*?\.[a-zA-Z]+))>/)) != null){
if(m[3]){
return [m[0].length,["link",{href:"mailto:" + m[3]},m[3]]];}else 


if(m[2] == "mailto"){
return [m[0].length,["link",{href:m[1]},m[1].substr("mailto:".length)]];}else 


return [m[0].length,["link",{href:m[1]},m[1]]];}


return [1,"<"];},


"`":function inlineCode(text){


var m=text.match(/(`+)(([\s\S]*?)\1)/);

if(m && m[2])
return [m[1].length + m[2].length,["inlinecode",m[3]]];else 
{

return [1,"`"];}},



"  \n":function lineBreak(text){
return [3,["linebreak"]];}};





function strong_em(tag,md){

var state_slot=tag + "_state",
other_slot=tag == "strong"?"em_state":"strong_state";

function CloseTag(len){
this.len_after = len;
this.name = "close_" + md;}


return function(text,orig_match){

if(this[state_slot][0] == md){


this[state_slot].shift();


return [text.length,new CloseTag(text.length - md.length)];}else 

{

var other=this[other_slot].slice(),
state=this[state_slot].slice();

this[state_slot].unshift(md);




var res=this.processInline(text.substr(md.length));


var last=res[res.length - 1];



var check=this[state_slot].shift();
if(last instanceof CloseTag){
res.pop();

var consumed=text.length - last.len_after;
return [consumed,[tag].concat(res)];}else 

{

this[other_slot] = other;
this[state_slot] = state;


return [md.length,md];}}};}





Markdown.dialects.Gruber.inline["**"] = strong_em("strong","**");
Markdown.dialects.Gruber.inline["__"] = strong_em("strong","__");
Markdown.dialects.Gruber.inline["*"] = strong_em("em","*");
Markdown.dialects.Gruber.inline["_"] = strong_em("em","_");



Markdown.buildBlockOrder = function(d){
var ord=[];
for(var i in d) {
if(i == "__order__" || i == "__call__")continue;
ord.push(i);}

d.__order__ = ord;};



Markdown.buildInlinePatterns = function(d){
var patterns=[];

for(var i in d) {

if(i.match(/^__.*__$/))continue;
var l=i.replace(/([\\.*+?|()\[\]{}])/g,"\\$1").
replace(/\n/,"\\n");
patterns.push(i.length == 1?l:"(?:" + l + ")");}


patterns = patterns.join("|");
d.__patterns__ = patterns;


var fn=d.__call__;
d.__call__ = function(text,pattern){
if(pattern != undefined){
return fn.call(this,text,pattern);}else 


{
return fn.call(this,text,patterns);}};};




Markdown.DialectHelpers = {};
Markdown.DialectHelpers.inline_until_char = function(text,want){
var consumed=0,
nodes=[];

while(true) {
if(text.charAt(consumed) == want){

consumed++;
return [consumed,nodes];}


if(consumed >= text.length){

return null;}


var res=this.dialect.inline.__oneElement__.call(this,text.substr(consumed));
consumed += res[0];

nodes.push.apply(nodes,res.slice(1));}};




Markdown.subclassDialect = function(d){
function Block(){}
Block.prototype = d.block;
function Inline(){}
Inline.prototype = d.inline;

return {block:new Block(),inline:new Inline()};};


Markdown.buildBlockOrder(Markdown.dialects.Gruber.block);
Markdown.buildInlinePatterns(Markdown.dialects.Gruber.inline);

Markdown.dialects.Maruku = Markdown.subclassDialect(Markdown.dialects.Gruber);

Markdown.dialects.Maruku.processMetaHash = function processMetaHash(meta_string){
var meta=split_meta_hash(meta_string),
attr={};

for(var i=0;i < meta.length;++i) {

if(/^#/.test(meta[i])){
attr.id = meta[i].substring(1);}else 


if(/^\./.test(meta[i])){

if(attr["class"]){
attr["class"] = attr["class"] + meta[i].replace(/./," ");}else 

{
attr["class"] = meta[i].substring(1);}}else 



if(/\=/.test(meta[i])){
var s=meta[i].split(/\=/);
attr[s[0]] = s[1];}}



return attr;};


function split_meta_hash(meta_string){
var meta=meta_string.split(""),
parts=[""],
in_quotes=false;

while(meta.length) {
var letter=meta.shift();
switch(letter){
case " ":

if(in_quotes){
parts[parts.length - 1] += letter;}else 


{
parts.push("");}

break;
case "'":
case "\"":

in_quotes = !in_quotes;
break;
case "\\":


letter = meta.shift();
default:
parts[parts.length - 1] += letter;
break;}}



return parts;}


Markdown.dialects.Maruku.block.document_meta = function document_meta(block,next){

if(block.lineNumber > 1)return undefined;


if(!block.match(/^(?:\w+:.*\n)*\w+:.*$/))return undefined;


if(!extract_attr(this.tree)){
this.tree.splice(1,0,{});}


var pairs=block.split(/\n/);
for(p in pairs) {
var m=pairs[p].match(/(\w+):\s*(.*)$/),
key=m[1].toLowerCase(),
value=m[2];

this.tree[1][key] = value;}



return [];};


Markdown.dialects.Maruku.block.block_meta = function block_meta(block,next){

var m=block.match(/(^|\n) {0,3}\{:\s*((?:\\\}|[^\}])*)\s*\}$/);
if(!m)return undefined;


var attr=this.dialect.processMetaHash(m[2]);

var hash;


if(m[1] === ""){
var node=this.tree[this.tree.length - 1];
hash = extract_attr(node);


if(typeof node === "string")return undefined;


if(!hash){
hash = {};
node.splice(1,0,hash);}



for(a in attr) {
hash[a] = attr[a];}



return [];}



var b=block.replace(/\n.*$/,""),
result=this.processBlock(b,[]);


hash = extract_attr(result[0]);
if(!hash){
hash = {};
result[0].splice(1,0,hash);}



for(a in attr) {
hash[a] = attr[a];}


return result;};


Markdown.dialects.Maruku.block.definition_list = function definition_list(block,next){

var tight=/^((?:[^\s:].*\n)+):\s+([\s\S]+)$/,
list=["dl"],
i,m;


if(m = block.match(tight)){

var blocks=[block];
while(next.length && tight.exec(next[0])) {
blocks.push(next.shift());}


for(var b=0;b < blocks.length;++b) {
var m=blocks[b].match(tight),
terms=m[1].replace(/\n$/,"").split(/\n/),
defns=m[2].split(/\n:\s+/);



for(i = 0;i < terms.length;++i) {
list.push(["dt",terms[i]]);}


for(i = 0;i < defns.length;++i) {

list.push(["dd"].concat(this.processInline(defns[i].replace(/(\n)\s+/,"$1"))));}}}else 



{
return undefined;}


return [list];};





Markdown.dialects.Maruku.block.table = function table(block,next){

var _split_on_unescaped=function(s,ch){
ch = ch || "\\s";
if(ch.match(/^[\\|\[\]{}?*.+^$]$/)){ch = "\\" + ch;}
var res=[],
r=new RegExp("^((?:\\\\.|[^\\\\" + ch + "])*)" + ch + "(.*)"),
m;
while(m = s.match(r)) {
res.push(m[1]);
s = m[2];}

res.push(s);
return res;};


var leading_pipe=/^ {0,3}\|(.+)\n {0,3}\|\s*([\-:]+[\-| :]*)\n((?:\s*\|.*(?:\n|$))*)(?=\n|$)/,

no_leading_pipe=/^ {0,3}(\S(?:\\.|[^\\|])*\|.*)\n {0,3}([\-:]+\s*\|[\-| :]*)\n((?:(?:\\.|[^\\|])*\|.*(?:\n|$))*)(?=\n|$)/,
i,m;
if(m = block.match(leading_pipe)){


m[3] = m[3].replace(/^\s*\|/gm,"");}else 
if(!(m = block.match(no_leading_pipe))){
return undefined;}


var table=["table",["thead",["tr"]],["tbody"]];



m[2] = m[2].replace(/\|\s*$/,"").split("|");


var html_attrs=[];
forEach(m[2],function(s){
if(s.match(/^\s*-+:\s*$/))html_attrs.push({align:"right"});else 
if(s.match(/^\s*:-+\s*$/))html_attrs.push({align:"left"});else 
if(s.match(/^\s*:-+:\s*$/))html_attrs.push({align:"center"});else 
html_attrs.push({});});



m[1] = _split_on_unescaped(m[1].replace(/\|\s*$/,""),"|");
for(i = 0;i < m[1].length;i++) {
table[1][1].push(["th",html_attrs[i] || {}].concat(
this.processInline(m[1][i].trim())));}



forEach(m[3].replace(/\|\s*$/mg,"").split("\n"),function(row){
var html_row=["tr"];
row = _split_on_unescaped(row,"|");
for(i = 0;i < row.length;i++) {
html_row.push(["td",html_attrs[i] || {}].concat(this.processInline(row[i].trim())));}

table[2].push(html_row);},
this);

return [table];};


Markdown.dialects.Maruku.inline["{:"] = function inline_meta(text,matches,out){
if(!out.length){
return [2,"{:"];}



var before=out[out.length - 1];

if(typeof before === "string"){
return [2,"{:"];}



var m=text.match(/^\{:\s*((?:\\\}|[^\}])*)\s*\}/);


if(!m){
return [2,"{:"];}



var meta=this.dialect.processMetaHash(m[1]),
attr=extract_attr(before);

if(!attr){
attr = {};
before.splice(1,0,attr);}


for(var k in meta) {
attr[k] = meta[k];}



return [m[0].length,""];};


Markdown.dialects.Maruku.inline.__escape__ = /^\\[\\`\*_{}\[\]()#\+.!\-|:]/;

Markdown.buildBlockOrder(Markdown.dialects.Maruku.block);
Markdown.buildInlinePatterns(Markdown.dialects.Maruku.inline);

var isArray=Array.isArray || function(obj){
return Object.prototype.toString.call(obj) == "[object Array]";};


var forEach;

if(Array.prototype.forEach){
forEach = function(arr,cb,thisp){
return arr.forEach(cb,thisp);};}else 


{
forEach = function(arr,cb,thisp){
for(var i=0;i < arr.length;i++) {
cb.call(thisp || arr,arr[i],i,arr);}};}




var isEmpty=function(obj){
for(var key in obj) {
if(hasOwnProperty.call(obj,key)){
return false;}}



return true;};


function extract_attr(jsonml){
return isArray(jsonml) && 
jsonml.length > 1 && 
typeof jsonml[1] === "object" && 
!isArray(jsonml[1])?
jsonml[1]:
undefined;}

















expose.renderJsonML = function(jsonml,options){
options = options || {};

options.root = options.root || false;

var content=[];

if(options.root){
content.push(render_tree(jsonml));}else 

{
jsonml.shift();
if(jsonml.length && typeof jsonml[0] === "object" && !(jsonml[0] instanceof Array)){
jsonml.shift();}


while(jsonml.length) {
content.push(render_tree(jsonml.shift()));}}



return content.join("\n\n");};


function escapeHTML(text){
return text.replace(/&/g,"&amp;").
replace(/</g,"&lt;").
replace(/>/g,"&gt;").
replace(/"/g,"&quot;").
replace(/'/g,"&#39;");}


function render_tree(jsonml){

if(typeof jsonml === "string"){
return escapeHTML(jsonml);}


var tag=jsonml.shift(),
attributes={},
content=[];

if(jsonml.length && typeof jsonml[0] === "object" && !(jsonml[0] instanceof Array)){
attributes = jsonml.shift();}


while(jsonml.length) {
content.push(render_tree(jsonml.shift()));}


var tag_attrs="";
for(var a in attributes) {
tag_attrs += " " + a + "=\"" + escapeHTML(attributes[a]) + "\"";}



if(tag == "img" || tag == "br" || tag == "hr"){
return "<" + tag + tag_attrs + "/>";}else 

{
return "<" + tag + tag_attrs + ">" + content.join("") + "</" + tag + ">";}}



function convert_tree_to_html(tree,references,options){
var i;
options = options || {};


var jsonml=tree.slice(0);

if(typeof options.preprocessTreeNode === "function"){
jsonml = options.preprocessTreeNode(jsonml,references);}



var attrs=extract_attr(jsonml);
if(attrs){
jsonml[1] = {};
for(i in attrs) {
jsonml[1][i] = attrs[i];}

attrs = jsonml[1];}



if(typeof jsonml === "string"){
return jsonml;}



switch(jsonml[0]){
case "header":
jsonml[0] = "h" + jsonml[1].level;
delete jsonml[1].level;
break;
case "bulletlist":
jsonml[0] = "ul";
break;
case "numberlist":
jsonml[0] = "ol";
break;
case "listitem":
jsonml[0] = "li";
break;
case "para":
jsonml[0] = "p";
break;
case "markdown":
jsonml[0] = "html";
if(attrs)delete attrs.references;
break;
case "code_block":
jsonml[0] = "pre";
i = attrs?2:1;
var code=["code"];
code.push.apply(code,jsonml.splice(i,jsonml.length - i));
jsonml[i] = code;
break;
case "inlinecode":
jsonml[0] = "code";
break;
case "img":
jsonml[1].src = jsonml[1].href;
delete jsonml[1].href;
break;
case "linebreak":
jsonml[0] = "br";
break;
case "link":
jsonml[0] = "a";
break;
case "link_ref":
jsonml[0] = "a";


var ref=references[attrs.ref];


if(ref){
delete attrs.ref;


attrs.href = ref.href;
if(ref.title){
attrs.title = ref.title;}



delete attrs.original;}else 


{
return attrs.original;}

break;
case "img_ref":
jsonml[0] = "img";


var ref=references[attrs.ref];


if(ref){
delete attrs.ref;


attrs.src = ref.href;
if(ref.title){
attrs.title = ref.title;}



delete attrs.original;}else 


{
return attrs.original;}

break;}



i = 1;


if(attrs){

for(var key in jsonml[1]) {
i = 2;
break;}


if(i === 1){
jsonml.splice(i,1);}}



for(;i < jsonml.length;++i) {
jsonml[i] = convert_tree_to_html(jsonml[i],references,options);}


return jsonml;}




function merge_text_nodes(jsonml){

var i=extract_attr(jsonml)?2:1;

while(i < jsonml.length) {

if(typeof jsonml[i] === "string"){
if(i + 1 < jsonml.length && typeof jsonml[i + 1] === "string"){

jsonml[i] += jsonml.splice(i + 1,1)[0];}else 

{
++i;}}else 



{
merge_text_nodes(jsonml[i]);
++i;}}}})(




(function(){
if(typeof exports === "undefined"){
window.markdown = {};
return window.markdown;}else 

{
return exports;}})());
});
__d('noder/app/components/htmlRender/commentHtml.js',["react-native/Libraries/react-native/react-native.js","noder/app/components/htmlRender/htmlContent.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var HtmlContent=require('noder/app/components/htmlRender/htmlContent.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


Component=




React.Component;var View=React.View;var Text=React.Text;var StyleSheet=React.StyleSheet;var Image=React.Image;var 


CommentHtml=(function(_Component){_inherits(CommentHtml,_Component);
function CommentHtml(props){_classCallCheck(this,CommentHtml);
_get(Object.getPrototypeOf(CommentHtml.prototype),'constructor',this).call(this,props);
if(this.props.style){
this.styles = Object.assign({},styles,this.props.style);}}_createClass(CommentHtml,[{key:'render',value:



function render(){
return (
React.createElement(HtmlContent,{
content:this.props.content,
style:this.styles,
router:this.props.router}));}}]);return CommentHtml;})(Component);






var fontSize=14;
var titleMargin=5;
var liFontSize=fontSize - 2;

var styles=StyleSheet.create({
p:{
lineHeight:fontSize * 1.4,
fontSize:fontSize,
color:'rgba(0,0,0,0.8)'},

pwrapper:{
marginTop:5,
marginBottom:5},


a:{
color:'#3498DB',
fontSize:fontSize,
paddingLeft:4,
paddingRight:4,
marginRight:10,
marginLeft:10},

h1:{
fontSize:fontSize * 1.6,
fontWeight:'bold',
color:'rgba(0,0,0,0.8)'},

h1wrapper:{
marginTop:titleMargin,
marginBottom:titleMargin},

h2:{
fontSize:fontSize * 1.5,
fontWeight:'bold',
color:'rgba(0,0,0,0.85)'},

h2wrapper:{
marginBottom:titleMargin,
marginTop:titleMargin},

h3:{
fontWeight:'bold',
fontSize:fontSize * 1.4,
color:'rgba(0,0,0,0.8)'},

h3wrapper:{
marginBottom:titleMargin - 2,
marginTop:titleMargin - 2},

h4:{
fontSize:fontSize * 1.3,
color:'rgba(0,0,0,0.7)',
fontWeight:'bold'},

h4wrapper:{
marginBottom:titleMargin - 2,
marginTop:titleMargin - 2},

h5:{
fontSize:fontSize * 1.2,
color:'rgba(0,0,0,0.7)',
fontWeight:'bold'},

h5wrapper:{
marginBottom:titleMargin - 3,
marginTop:titleMargin - 3},

h6:{
fontSize:fontSize * 1.1,
color:'rgba(0,0,0,0.7)',
fontWeight:'bold'},

h6wrapper:{
marginBottom:titleMargin - 3,
marginTop:titleMargin - 3},

li:{
fontSize:fontSize * 0.9,
color:'rgba(0,0,0,0.7)'},

liwrapper:{
paddingLeft:20,
marginBottom:10},

strong:{
fontWeight:'bold'},

em:{
fontStyle:'italic'},

codeScrollView:{
backgroundColor:'#333',
flexDirection:'column',
marginBottom:15},

codeRow:{
flex:1,
flexDirection:'row',
height:25,
alignItems:'center'},

codeFirstRow:{
paddingTop:20,
height:25 + 20},

codeLastRow:{
paddingBottom:20,
height:25 + 20},

codeFirstAndLastRow:{
paddingBottom:20,
height:25 + 40,
paddingTop:20},

lineNum:{
width:55,
color:'rgba(255,255,255,0.5)'},

lineNumWrapper:{
width:55,
height:25,
backgroundColor:'rgba(0,0,0,0.1)',
flexDirection:'row',
alignItems:'center',
paddingLeft:20},

codeWrapper:{
flexDirection:'column'},

codeLineWrapper:{
height:25,
flexDirection:'row',
alignItems:'center',
paddingLeft:20,
paddingRight:20},

blockquotewrapper:{
paddingLeft:20,
borderLeftColor:'#3498DB',
borderLeftWidth:3}});



module.exports = CommentHtml;
});
__d('noder/app/util/animation.js',["react-native/Libraries/react-native/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var React=require('react-native/Libraries/react-native/react-native.js');var 


LayoutAnimation=
React.LayoutAnimation;

var animations={};

animations.keyboard = {
layout:{
spring:{
duration:400,
create:{
duration:300,
type:LayoutAnimation.Types.easeInEaseOut,
property:LayoutAnimation.Properties.opacity},

update:{
type:LayoutAnimation.Types.spring,
springDamping:400}},


easeInEaseOut:{
duration:400,
create:{
type:LayoutAnimation.Types.easeInEaseOut,
property:LayoutAnimation.Properties.scaleXY},

update:{
type:LayoutAnimation.Types.easeInEaseOut}}}};





module.exports = animations;
});
__d('noder/app/containers/Message.js',["react-native/Libraries/react-native/react-native.js","react-native-scrollable-tab-view/index.js","noder/app/components/MessagePage.js","noder/app/components/TabBar.js","noder/app/components/overlay/return.js","noder/app/components/overlay/markAsReadOverlay.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}
var React=require('react-native/Libraries/react-native/react-native.js');
var ScrollableTabView=require('react-native-scrollable-tab-view/index.js');


var MessagePage=require('noder/app/components/MessagePage.js');
var TabBar=require('noder/app/components/TabBar.js');
var Return=require('noder/app/components/overlay/return.js');
var MarkAsReadOverlay=require('noder/app/components/overlay/markAsReadOverlay.js');


var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=



React.View;var Text=React.Text;var Component=React.Component;var StyleSheet=React.StyleSheet;var 


Message=(function(_Component){_inherits(Message,_Component);
function Message(props){_classCallCheck(this,Message);
_get(Object.getPrototypeOf(Message.prototype),'constructor',this).call(this,props);
this.state = {
didFocus:false};}_createClass(Message,[{key:'componentDidMount',value:




function componentDidMount(){
this.props.actions.getMessages(this.props.state.user.token);}},{key:'componentDidFocus',value:



function componentDidFocus(){
this.setState({
didFocus:true});}},{key:'render',value:




function render(){
var message=this.props.state.message;
var didFocus=this.state.didFocus;
var hasNotReadCount=message.hasNotRead.length;
var hasReadCount=message.hasRead.length;

return (
React.createElement(View,{style:styles.container},
React.createElement(ScrollableTabView,{
edgeHitWidth:width / 3 * 2,
renderTabBar:function(){return TabBar;}},
React.createElement(MessagePage,{
router:this.props.router,
didFocus:didFocus,
isLoading:message.isLoading,
data:message.hasNotRead,
style:styles.userTopicPage,
tabLabel:'未读消息 ' + hasNotReadCount}),
React.createElement(MessagePage,{
router:this.props.router,
didFocus:didFocus,
isLoading:message.isLoading,
data:message.hasRead,
style:styles.userTopicPage,
tabLabel:'已读消息 ' + hasReadCount})),


React.createElement(Return,{router:this.props.router}),
React.createElement(MarkAsReadOverlay,{
isLoading:message.isMarkAsReadLoading,
markAsRead:this.props.actions.markAsRead,
message:message,
token:this.props.state.user.token})));}}]);return Message;})(Component);







var styles=StyleSheet.create({
container:{
backgroundColor:'white',
height:height}});




module.exports = Message;
});
__d('noder/app/components/MessagePage.js',["react-native/Libraries/react-native/react-native.js","moment/moment.js","noder/app/configs/config.js","noder/app/configs/routes.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var moment=require('moment/moment.js');


var config=require('noder/app/configs/config.js');
var routes=require('noder/app/configs/routes.js');


var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 



View=









React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var Image=React.Image;var ListView=React.ListView;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;


var styles=StyleSheet.create({
'row':{
'height':90,
'flexDirection':'row',
'borderBottomColor':'rgba(0, 0, 0, 0.02)',
'borderBottomWidth':1,
'paddingTop':25,
'paddingRight':0,
'paddingBottom':25,
'paddingLeft':20},

'imgWrapper':{
'width':90,
'position':'absolute',
'left':20,
'top':25,
'height':65},

'img':{
'height':40,
'width':40,
'borderRadius':20},

'topic':{
'marginLeft':60},

'title':{
'fontSize':15},

'topicFooter':{
'marginTop':10,
'flexDirection':'row',
width:width - (20 + 90)},

'topicFooter text':{
'fontSize':11,
'color':'rgba(0, 0, 0, 0.4)'},

'topicFooter date':{
'position':'absolute',
'right':0,
'top':0},

'topicFooter count':{
'marginRight':15},

'topicFooter top':{
'fontSize':11,
'marginTop':1,
'marginRight':0,
'marginBottom':0,
'marginLeft':10,
'color':'#E74C3C'},

'topicFooter good':{
'fontSize':11,
'marginTop':1,
'marginRight':0,
'marginBottom':0,
'marginLeft':10,
'color':'#2ECC71'},

'topicFooter tab':{
'fontSize':11,
'marginTop':1,
'marginRight':0,
'marginBottom':0,
'marginLeft':10},

'loading':{
'marginTop':250},

rowFooterText:{
fontSize:13,
color:'rgba(0,0,0,0.7)'},

atText:{
color:'#E74C3C'},

replyText:{
color:'#2980B9'},

emptyMessage:{
marginTop:80,
flex:1},

emptyMessageText:{
textAlign:'center',
color:'#3498DB',
fontSize:24}});var 





MessagePage=(function(_Component){_inherits(MessagePage,_Component);
function MessagePage(props){_classCallCheck(this,MessagePage);
_get(Object.getPrototypeOf(MessagePage.prototype),'constructor',this).call(this,props);
this.ds = new ListView.DataSource({rowHasChanged:function(r1,r2){return r1 !== r2;}});
this.state = {
ds:this.ds.cloneWithRows(this.props.data)};}_createClass(MessagePage,[{key:'componentWillReceiveProps',value:




function componentWillReceiveProps(nextProps){
if(nextProps.data != this.props.data){
this.setState({
ds:this.ds.cloneWithRows(nextProps.data)});}}},{key:'_onRowPress',value:





function _onRowPress(message){
this.props.router.toComments({
topic:message.topic,
from:'message',
reply:message.reply});}},{key:'_renderRowFooter',value:




function _renderRowFooter(message){
var date=moment(message.reply.create_at).startOf('minute').fromNow();

return (
React.createElement(View,{style:styles.topicFooter},
React.createElement(Text,{style:styles['topicFooter text']},
React.createElement(Text,null,
message.author.loginname),

React.createElement(Text,{style:styles[message.type + 'Text']},
message.type == 'reply'?' 回复':' @')),



React.createElement(Text,{style:[styles['topicFooter date'],styles['topicFooter text']]},
date)));}},{key:'_renderLoading',value:






function _renderLoading(){
if(this.props.isLoading){
return (
React.createElement(ActivityIndicatorIOS,{
size:'large',
animating:this.props.isLoading,
style:{marginTop:20,width:width}}));}


return null;}},{key:'_renderRow',value:



function _renderRow(message){var _this=this;
var topic=message.topic;
var title=topic.title;
var titleLength=Math.floor((width - 100) / 15) + 2;
if(title.length > titleLength){
title = title.substring(0,titleLength - 3) + '...';}



return (
React.createElement(TouchableHighlight,{
onPress:function(){_this._onRowPress(message);},
underlayColor:'#3498DB',
key:message.id},
React.createElement(View,{style:styles.row},
React.createElement(View,{style:styles.imgWrapper},
React.createElement(Image,{
style:styles.img,
source:{uri:config.domain + message.author.avatar_url}})),




React.createElement(View,{style:[styles.topic]},
React.createElement(Text,{style:[styles.title]},
title),


React.createElement(View,{style:[styles.topicFooter]},
this._renderRowFooter(message))))));}},{key:'_renderEmptyMessage',value:








function _renderEmptyMessage(){
if(this.props.data.length == 0 && this.props.isLoading == false){
return (
React.createElement(View,{style:styles.emptyMessage},
React.createElement(Text,{style:styles.emptyMessageText},'空空哒')));}}},{key:'_renderListView',value:








function _renderListView(){
if(this.props.didFocus){
return (
React.createElement(ListView,{
style:{backgroundColor:'rgba(255,255,255,1)'},
showsVerticalScrollIndicator:true,
initialListSize:10,
pagingEnabled:false,
removeClippedSubviews:true,
dataSource:this.state.ds,
renderRow:this._renderRow.bind(this),
onEndReachedThreshold:100}));}



return null;}},{key:'render',value:



function render(){
return (
React.createElement(View,{style:[{width:width,height:height - 40},{backgroundColor:'white'}]},
this._renderLoading(),
this._renderEmptyMessage(),
this._renderListView()));}}]);return MessagePage;})(Component);






module.exports = MessagePage;
});
__d('noder/app/components/overlay/markAsReadOverlay.js',["react-native/Libraries/react-native/react-native.js","react-native-button/Button.js","noder/app/components/overlay/overlayButton.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');

var Button=require('react-native-button/Button.js');
var OverlayButton=require('noder/app/components/overlay/overlayButton.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 



View=




React.View;var StyleSheet=React.StyleSheet;var Component=React.Component;var Text=React.Text;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;

var overlaySize=45;


var styles=StyleSheet.create({
position:{
right:20,
bottom:20},

text:{
textAlign:'center',
color:'white',
fontSize:12},

content:{
height:overlaySize,
width:overlaySize,
borderRadius:overlaySize / 2,
flexDirection:'column',
justifyContent:'center'}});var 




MarkAsRead=(function(_Component){_inherits(MarkAsRead,_Component);
function MarkAsRead(props){_classCallCheck(this,MarkAsRead);
_get(Object.getPrototypeOf(MarkAsRead.prototype),'constructor',this).call(this,props);}_createClass(MarkAsRead,[{key:'_onPress',value:



function _onPress(){
if(this.props.message.hasNotRead.length == 0){
window.alert('暂无未读消息!');}else 

{
this.props.markAsRead(this.props.token);}}},{key:'_renderContent',value:




function _renderContent(){
if(this.props.isLoading){
return (
React.createElement(ActivityIndicatorIOS,null));}


return (
React.createElement(Text,{style:[styles.text]},'已读'));}},{key:'render',value:






function render(){
return (
React.createElement(OverlayButton,{
position:styles.position,
onPress:this._onPress.bind(this)},
React.createElement(View,{style:styles.content},
this._renderContent())));}}]);return MarkAsRead;})(Component);







module.exports = MarkAsRead;
});
__d('noder/app/containers/QRCode.js',["react-native/Libraries/react-native/react-native.js","react-native-camera/Camera.ios.js","react-native-icons/index.js","react-native-button/Button.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var Camera=require('react-native-camera/Camera.ios.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;
var Button=require('react-native-button/Button.js');


var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 



StyleSheet=






React.StyleSheet;var View=React.View;var Text=React.Text;var TouchableOpacity=React.TouchableOpacity;var Component=React.Component;var Navigator=React.Navigator;var VibrationIOS=React.VibrationIOS;

var cameraSize=250;
var borderColor='rgba(255,255,255,0.6)';
var borderBoxSize=35;

var styles=StyleSheet.create({
camera:{
width:width,
height:height,
flexDirection:'column',
justifyContent:'center',
alignItems:'center'},

header:{
height:80,
width:350,
flexDirection:'row',
justifyContent:'space-between',
alignItems:'center'},

cameraView:{
height:cameraSize,
width:cameraSize},

container:{
height:350},

borderBox:{
position:'absolute',
borderWidth:2,
height:borderBoxSize,
width:borderBoxSize},

borderLeftTop:{
borderColor:'transparent',
borderLeftColor:borderColor,
borderTopColor:borderColor,
left:0,
top:0},

borderRightTop:{
borderColor:'transparent',
borderRightColor:borderColor,
borderTopColor:borderColor,
right:0,
top:0},

borderLeftBottom:{
borderColor:'transparent',
borderLeftColor:borderColor,
borderBottomColor:borderColor,
left:0,
bottom:0},

borderRightBottom:{
borderColor:'transparent',
borderRightColor:borderColor,
borderBottomColor:borderColor,
right:0,
bottom:0},

infoText:{
color:'rgba(255,255,255,0.7)',
textAlign:'center',
marginTop:40,
fontSize:24},

closeButton:{
width:35,
height:35},

closeIcon:{
width:35,
height:35,
borderRadius:35 / 2,
backgroundColor:'rgba(0,0,0,0.4)'},

buttonWrapper:{
width:35,
height:35,
position:'absolute',
right:30,
top:0}});var 





QRCode=(function(_Component){_inherits(QRCode,_Component);
function QRCode(props){_classCallCheck(this,QRCode);
_get(Object.getPrototypeOf(QRCode.prototype),'constructor',this).call(this,props);
this.succesed = false;}_createClass(QRCode,[{key:'_onBarCodeRead',value:


function _onBarCodeRead(result){
if(this.succesed)return;

var self=this;
self.succesed = true;
VibrationIOS.vibrate();
Navigator.getContext(this).pop();
this.props.actions.checkToken(result.data);}},{key:'_onClosePress',value:


function _onClosePress(){
Navigator.getContext(this).pop();}},{key:'render',value:


function render(){
return (
React.createElement(View,null,
React.createElement(Camera,{
ref:'camera',
style:styles.camera,
onBarCodeRead:this._onBarCodeRead.bind(this)},


React.createElement(View,{style:styles.header},
React.createElement(View,{style:styles.buttonWrapper},
React.createElement(Button,{
onPress:this._onClosePress.bind(this),
style:styles.closeButton},
React.createElement(Icon,{
name:'ion|ios-close-empty',
size:40,
color:'rgba(255,255,255,0.7)',
style:styles.closeIcon})))),





React.createElement(View,{style:styles.container},
React.createElement(View,{style:styles.cameraViewWrapper},
React.createElement(View,{style:styles.cameraView},
React.createElement(View,{style:[styles.borderLeftTop,styles.borderBox]}),
React.createElement(View,{style:[styles.borderRightTop,styles.borderBox]}),
React.createElement(View,{style:[styles.borderLeftBottom,styles.borderBox]}),
React.createElement(View,{style:[styles.borderRightBottom,styles.borderBox]})),

React.createElement(Text,{style:styles.infoText},'请将二维码放到框内'))))));}}]);return QRCode;})(Component);











module.exports = QRCode;
});
__d('react-native-camera/Camera.ios.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  var React=require('React');
var DeviceEventEmitter=require('RCTDeviceEventEmitter');
var NativeModules=require('NativeModules');
var ReactNativeViewAttributes=require('ReactNativeViewAttributes');
var StyleSheet=require('StyleSheet');
var createReactNativeComponentClass=require('createReactNativeComponentClass');
var PropTypes=require('ReactPropTypes');
var StyleSheetPropType=require('StyleSheetPropType');
var NativeMethodsMixin=require('NativeMethodsMixin');
var flattenStyle=require('flattenStyle');
var merge=require('merge');

var constants={
Aspect:NativeModules.CameraManager.Aspect,
BarCodeType:NativeModules.CameraManager.BarCodeType,
Type:NativeModules.CameraManager.Type,
CaptureMode:NativeModules.CameraManager.CaptureMode,
CaptureTarget:NativeModules.CameraManager.CaptureTarget,
Orientation:NativeModules.CameraManager.Orientation,
FlashMode:NativeModules.CameraManager.FlashMode,
TorchMode:NativeModules.CameraManager.TorchMode};


var Camera=React.createClass({displayName:'Camera',
propTypes:{
aspect:PropTypes.oneOfType([
PropTypes.string,
PropTypes.number]),

captureAudio:PropTypes.bool,
captureMode:PropTypes.oneOfType([
PropTypes.string,
PropTypes.number]),

captureTarget:PropTypes.oneOfType([
PropTypes.string,
PropTypes.number]),

type:PropTypes.oneOfType([
PropTypes.string,
PropTypes.number]),

orientation:PropTypes.oneOfType([
PropTypes.string,
PropTypes.number]),

flashMode:PropTypes.oneOfType([
PropTypes.string,
PropTypes.number]),

torchMode:PropTypes.oneOfType([
PropTypes.string,
PropTypes.number])},



mixins:[NativeMethodsMixin],

viewConfig:{
uiViewClassName:'UIView',
validAttributes:ReactNativeViewAttributes.UIView},


getDefaultProps:function(){
return {
aspect:constants.Aspect.fill,
type:constants.Type.back,
orientation:constants.Orientation.auto,
captureAudio:true,
captureMode:constants.CaptureMode.still,
captureTarget:constants.CaptureTarget.cameraRoll,
flashMode:constants.FlashMode.off,
torchMode:constants.TorchMode.off};},



getInitialState:function(){
return {
isAuthorized:false,
isRecording:false};},



componentWillMount:function(){
NativeModules.CameraManager.checkDeviceAuthorizationStatus((function(err,isAuthorized){
this.state.isAuthorized = isAuthorized;
this.setState(this.state);}).
bind(this));
this.cameraBarCodeReadListener = DeviceEventEmitter.addListener('CameraBarCodeRead',this._onBarCodeRead);},


componentWillUnmount:function(){
this.cameraBarCodeReadListener.remove();

if(this.state.isRecording){
this.stopRecording();}},



render:function(){
var style=flattenStyle([styles.base,this.props.style]);

var aspect=this.props.aspect,
type=this.props.type,
orientation=this.props.orientation,
flashMode=this.props.flashMode,
torchMode=this.props.torchMode;

var legacyProps={
aspect:{
Fill:'fill',
Fit:'fit',
Stretch:'stretch'},

orientation:{
LandscapeLeft:'landscapeLeft',
LandscapeRight:'landscapeRight',
Portrait:'portrait',
PortraitUpsideDown:'portraitUpsideDown'},

type:{
Front:'front',
Back:'back'}};



if(typeof aspect === 'string'){
aspect = constants.Aspect[aspect];}


if(typeof flashMode === 'string'){
flashMode = constants.FlashMode[flashMode];}


if(typeof orientation === 'string'){
orientation = constants.Orientation[orientation];}


if(typeof torchMode === 'string'){
torchMode = constants.TorchMode[torchMode];}


if(typeof type === 'string'){
type = constants.Type[type];}


var nativeProps=merge(this.props,{
style:style,
aspect:aspect,
type:type,
orientation:orientation,
flashMode:flashMode,
torchMode:torchMode});


return React.createElement(RCTCamera,nativeProps);},


_onBarCodeRead:function(e){
this.props.onBarCodeRead && this.props.onBarCodeRead(e);},


capture:function(options,cb){

if(arguments.length == 1){
cb = options;
options = {};}


options = Object.assign({},{
audio:this.props.captureAudio,
mode:this.props.captureMode,
target:this.props.captureTarget},
options);

if(typeof options.mode === 'string'){
options.mode = constants.CaptureMode[options.mode];}


if(options.mode === constants.CaptureMode.video){
options.totalSeconds = options.totalSeconds > -1?options.totalSeconds:-1;
options.preferredTimeScale = options.preferredTimeScale || 30;
this.setState({isRecording:true});}


if(typeof options.target === 'string'){
options.target = constants.CaptureTarget[options.target];}


NativeModules.CameraManager.capture(options,cb);},


stopCapture:function(){
if(this.state.isRecording){
NativeModules.CameraManager.stopCapture();
this.setState({isRecording:false});}}});





var RCTCamera=createReactNativeComponentClass({
validAttributes:merge(ReactNativeViewAttributes.UIView,{
aspect:true,
type:true,
orientation:true,
flashMode:true,
torchMode:true}),

uiViewClassName:'RCTCamera'});


var styles=StyleSheet.create({
base:{}});


Camera.constants = constants;
module.exports = Camera;
});
__d('noder/app/components/topicsInTab.js',["react-native/Libraries/react-native/react-native.js","rebound/rebound.js","noder/app/components/pageScrollView.js","noder/app/components/pageNavBar.js","noder/app/components/pageListView.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var rebound=require('rebound/rebound.js');


var PageScrollView=require('noder/app/components/pageScrollView.js');
var PageNavBar=require('noder/app/components/pageNavBar.js');
var PageListView=require('noder/app/components/pageListView.js');


var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=










React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var TouchableHighlight=React.TouchableHighlight;var Navigator=React.Navigator;var AsyncStorage=React.AsyncStorage;var 


TopicsInTab=(function(_Component){_inherits(TopicsInTab,_Component);
function TopicsInTab(props){_classCallCheck(this,TopicsInTab);
_get(Object.getPrototypeOf(TopicsInTab.prototype),'constructor',this).call(this,props);
this.navs = ['精华','问答','主页','分享','招聘'];
this.totalPages = this.navs.length;
this.tabs = ['good','ask','all','share','job'];
this.space = (width - 60 * 3) / 2 + 60;
var pageIndex=2;
var pageScrollContentWidth=width * pageIndex;
var pageNavBarWith=this.space / width * pageScrollContentWidth;
var pageNavBarOffset=pageIndex * width / pageScrollContentWidth * pageNavBarWith;

this.state = {
pageIndex:pageIndex,
navBarOffset:pageNavBarOffset};}_createClass(TopicsInTab,[{key:'componentWillMount',value:



function componentWillMount(){var _this=this;
this.springSystem = new rebound.SpringSystem();
this._scrollSpring = this.springSystem.createSpring();
this._updateSpringConfig(this.props);

this._scrollSpring.addListener({
onSpringUpdate:function(){
var currentValue=_this._scrollSpring.getCurrentValue();
var space=_this.space;
var offset=currentValue.offset;
var pageScrollContentWidth=currentValue.contentWidth;
if(offset < 0 || offset > pageScrollContentWidth - width){
return;}


var pageNavBarWith=space / width * pageScrollContentWidth;
var pageNavBarOffset=offset / pageScrollContentWidth * pageNavBarWith;

_this._pageNavBar.updateNav(pageNavBarOffset);}});}},{key:'componentDidMount',value:




function componentDidMount(){
this._scrollSpring.setCurrentValue({
offset:this.state.pageIndex * width,
contentWidth:0});}},{key:'_updateSpringConfig',value:



function _updateSpringConfig(props){
var springConfig=this._scrollSpring.getSpringConfig();
springConfig.tension = rebound.OrigamiValueConverter.tensionFromOrigamiValue(props.springTension || 25);
springConfig.friction = rebound.OrigamiValueConverter.frictionFromOrigamiValue(props.springFriction || 8);

this._scrollSpring.setOvershootClampingEnabled(typeof props.clampSpring === 'undefined'?true:props.clampSpring);}},{key:'shouldComponentUpdate',value:



function shouldComponentUpdate(nextProps,nextState){
if(nextProps.topic !== this.props.topic){
return true;}

return false;}},{key:'_pageScrollViewOnScroll',value:



function _pageScrollViewOnScroll(e){
var offset=e.nativeEvent.contentOffset.x;
this._scrollSpring.setCurrentValue({
offset:offset,
contentWidth:e.nativeEvent.contentSize.width});}},{key:'_onNavItemPress',value:




function _onNavItemPress(index){var _scrollSpring$getCurrentValue=
this._scrollSpring.getCurrentValue();var offset=_scrollSpring$getCurrentValue.offset;
if(offset % width == 0){
var currentIndex=offset / width;
if(currentIndex == index){
this['_pageListView_' + index] && this['_pageListView_' + index].scrollToTop();}

this._pageScrollView.scrollTo(index * width,Math.abs(currentIndex - index));}}},{key:'_renderPageListView',value:




function _renderPageListView(){var _this2=this;
var navs=this.navs;
var tabs=this.tabs;
var space=this.space;
return navs.map(function(nav,index){
var tab=tabs[index];
return (
React.createElement(PageListView,{
ref:function(view){_this2['_pageListView_' + index] = view;},
key:'listView' + index,
navs:navs,
space:space,
data:_this2.props.topic[tab].topics,
actions:_this2.props.actions,
tab:_this2.props.topic[tab],
router:_this2.props.router}));});}},{key:'render',value:






function render(){var _this3=this;
return (
React.createElement(View,null,
React.createElement(PageNavBar,{
navBarOffset:this.state.navBarOffset,
pageIndex:this.state.pageIndex,
space:this.space,
navs:this.navs,
totalPages:this.totalPages,
onItemPress:this._onNavItemPress.bind(this),
ref:function(view){_this3._pageNavBar = view;}}),



React.createElement(PageScrollView,{
ref:function(view){_this3._pageScrollView = view;},
pageIndex:this.state.pageIndex,
totalPages:this.totalPages,
onScroll:this._pageScrollViewOnScroll.bind(this),
onScrollBeginDrag:this._pageScrollViewOnScroll.bind(this)},

this._renderPageListView())));}}]);return TopicsInTab;})(Component);







module.exports = TopicsInTab;
});
__d('noder/app/components/pageScrollView.js',["react-native/Libraries/react-native/react-native.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 



View=





React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;


var stylesExtends=StyleSheet.create({
page:{
width:width}});var 




PageScrollView=(function(_Component){_inherits(PageScrollView,_Component);
function PageScrollView(props){_classCallCheck(this,PageScrollView);
_get(Object.getPrototypeOf(PageScrollView.prototype),'constructor',this).call(this,props);
this.state = {
index:0};}_createClass(PageScrollView,[{key:'_getInitContentOffset',value:



function _getInitContentOffset(){
return {
x:this.props.pageIndex * width,
y:0};}},{key:'scrollTo',value:




function scrollTo(x,type){
if(type > 1){
this.scrollView.setNativeProps({
contentOffset:{
x:x,
y:0}});}else 




{
this.scrollView.scrollTo(0,x);}}},{key:'render',value:




function render(){var _this=this;
var self=this;
return (
React.createElement(ScrollView,{
ref:function(view){return _this.scrollView = view;},
contentOffset:this._getInitContentOffset(),
bounces:true,
horizontal:true,
directionalLockEnabled:true,
scrollEventThrottle:16,
onScroll:this.props.onScroll,
pagingEnabled:true,
onScrollBeginDrag:this.props.onScrollBeginDrag,
onScrollEndDrag:this.props.onScrollEndDrag,
scrollEnabled:true,
automaticallyAdjustContentInsets:false,
removeClippedSubviews:true,
showsHorizontalScrollIndicator:false,
showsVerticalScrollIndicator:false},

this.props.children.map(function(pageContent,index){
return (
React.createElement(View,{
key:'pageScrollView' + index,
style:[stylesExtends.page,self.props.pageStyle]},
pageContent));})));}}]);return PageScrollView;})(Component);











module.exports = PageScrollView;
});
__d('noder/app/components/pageNavBar.js',["precomputeStyle","react-native/Libraries/react-native/react-native.js","rebound/rebound.js","noder/app/components/pageScrollView.js","noder/app/styles/pageNavBar.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var rebound=require('rebound/rebound.js');
var precomputeStyle=require('precomputeStyle');



var PageScrollView=require('noder/app/components/pageScrollView.js');


var styles=require('noder/app/styles/pageNavBar.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 



View=





React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var TouchableOpacity=React.TouchableOpacity;


var stylesExtends=StyleSheet.create({
navBar:{
width:width,
height:40}});var 




PageNavBar=(function(_Component){_inherits(PageNavBar,_Component);
function PageNavBar(props){_classCallCheck(this,PageNavBar);
_get(Object.getPrototypeOf(PageNavBar.prototype),'constructor',this).call(this,props);
this.state = {
offset:0};

this._navBars = [];}_createClass(PageNavBar,[{key:'_onNavItemPress',value:



function _onNavItemPress(){
this.props.onItemPress();}},{key:'_getActiveItemStyle',value:



function _getActiveItemStyle(opacity){
return {
borderTopColor:'rgba(241,196,15,' + opacity + ')'};}},{key:'_getNavs',value:




function _getNavs(){var _this=this;
var pageIndex=this.props.pageIndex;
return this.props.navs.map(function(item,index,arr){
var activeStyle=_this._getActiveItemStyle(0);
if(index == pageIndex){
activeStyle = _this._getActiveItemStyle(1);}


return (
React.createElement(View,{
ref:function(view){_this._navBars.push(view);},
key:'navBar' + index,
style:[styles['navBar li'],activeStyle]},
React.createElement(TouchableOpacity,{onPress:function(){return _this.props.onItemPress(index);}},
React.createElement(View,{style:styles['navBar item']},
React.createElement(Text,{style:styles['navBar text']},
item)))));});}},{key:'_updateNavsStyle',value:











function _updateNavsStyle(offset){var _this2=this;
var space=this.props.space;
this.props.navs.forEach(function(item,index,arr){
var min=(index - 1) * space;
var max=(index + 1) * space;
var center=index * space;

var opacity=0;
if(offset > min && offset < center){
opacity = (offset - min) / space;}

if(offset > center && offset < max){
opacity = (max - offset) / space;}


if(offset == center){
opacity = 1;}


var activeStyle=_this2._getActiveItemStyle(opacity);

_this2._navBars[index].setNativeProps(precomputeStyle(activeStyle));});}},{key:'updateNav',value:






function updateNav(offset){
this.refs.navPageScrollInner.setNativeProps({
contentOffset:{
x:offset,
y:0}});


this._updateNavsStyle(offset);}},{key:'render',value:



function render(){
var totalPages=this.props.totalPages;
var space=this.props.space;

var widthStyle={
width:{
width:(totalPages + 2) * 60 + (totalPages + 1) * (space - 60)}};



return (
React.createElement(ScrollView,{
ref:'navPageScrollInner',
bounces:false,
horizontal:true,
directionalLockEnabled:true,
removeClippedSubviews:true,
showsHorizontalScrollIndicator:false,
showsVerticalScrollIndicator:false,
contentContainerStyle:[widthStyle.width],
contentOffset:{x:this.props.navBarOffset,y:0}},

React.createElement(View,{style:[stylesExtends.navBar,widthStyle.width]},
React.createElement(View,{
style:[styles.navBar,stylesExtends.navBar,widthStyle.width]},

React.createElement(View,{
key:'navItemFirst',
style:[styles['navBar li']]},
React.createElement(View,{style:styles['navBar item']},
React.createElement(Text,{style:styles['navBar text']}))),






this._getNavs(),

React.createElement(View,{
key:'navItemLast',
style:styles['navBar li']},
React.createElement(View,{style:styles['navBar item']},
React.createElement(Text,{style:styles['navBar text']})))))));}}]);return PageNavBar;})(Component);












module.exports = PageNavBar;
});
__d('noder/app/styles/pageNavBar.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  module.exports = {
"navBar":{
"height":40,
"backgroundColor":"rgba(0, 0, 0, 0.75)",
"flexDirection":"row",
"position":"absolute",
"top":0,
"left":0,
"alignItems":"center",
"justifyContent":"space-between"},

"navBar li":{
"height":40,
"width":60,
"flexDirection":"column",
"alignItems":"center",
"justifyContent":"space-around",
"borderTopWidth":4,
"borderTopColor":"transparent"},

"navBar liActive":{
"borderTopColor":"#F1C40F"},

"navBar item":{
"paddingLeft":2,
"paddingRight":2,
"paddingTop":12,
"paddingBottom":0,
"height":40},

"navBar text":{
"color":"white",
"fontSize":14},

"navScroll":{
"height":40}};
});
__d('noder/app/components/pageListView.js',["react-native/Libraries/react-native/react-native.js","moment/moment.js","noder/app/services/topicService.js","noder/app/components/topicRow.js","noder/app/configs/routes.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');
var moment=require('moment/moment.js');

var TopicService=require('noder/app/services/topicService.js');
var TopicRow=require('noder/app/components/topicRow.js');

var routes=require('noder/app/configs/routes.js');
var window=require('noder/app/util/window.js');var _window$get=


window.get();var width=_window$get.width;var height=_window$get.height;var 


View=











React.View;var StyleSheet=React.StyleSheet;var ScrollView=React.ScrollView;var Component=React.Component;var Text=React.Text;var StatusBarIOS=React.StatusBarIOS;var Image=React.Image;var ListView=React.ListView;var ActivityIndicatorIOS=React.ActivityIndicatorIOS;var TouchableHighlight=React.TouchableHighlight;var LayoutAnimation=React.LayoutAnimation;var TouchableOpacity=React.TouchableOpacity;


var extendsStyles=StyleSheet.create({
topic:{
width:width - 100},

loadingupdate:{
width:width,
marginTop:20},

loadingget:{
width:width,
marginBottom:20,
marginTop:20}});var 



PageListView=(function(_Component){_inherits(PageListView,_Component);
function PageListView(porps){_classCallCheck(this,PageListView);
_get(Object.getPrototypeOf(PageListView.prototype),'constructor',this).call(this,porps);
this.ds = new ListView.DataSource({rowHasChanged:function(r1,r2){return r1 !== r2;}});
this.page = 1;
this.state = {
ds:this.ds.cloneWithRows(this.props.data),
isLoading:false,
loadingPosition:'top',
getTopicError:null};}_createClass(PageListView,[{key:'componentDidMount',value:




function componentDidMount(){
this._fetchTopic('update');}},{key:'shouldComponentUpdate',value:



function shouldComponentUpdate(nextProps,nextState){
if(nextProps.data != this.props.data || nextState.isLoading != this.state.isLoading){
return true;}

return false;}},{key:'componentWillReceiveProps',value:



function componentWillReceiveProps(nextProps){
if(nextProps.data !== this.props.data){
console.log(this.props.data.length);

this.setState({
ds:this.ds.cloneWithRows(nextProps.data)});}}},{key:'onEndReached',value:





function onEndReached(){
this._fetchTopic('get');}},{key:'onScroll',value:


function onScroll(e){
if(e.nativeEvent.contentOffset.y < -90){
this._fetchTopic('update');}}},{key:'scrollToTop',value:



function scrollToTop(){
this._listView.setNativeProps({
contentOffset:{
x:0,
y:0}});}},{key:'_onRowPress',value:





function _onRowPress(topic){
this.props.router.toTopic({
topicId:topic.id,
topic:topic});}},{key:'_onGetAgainPress',value:




function _onGetAgainPress(){
this._fetchTopic('get');}},{key:'_fetchTopic',value:



function _fetchTopic(type){var _this=this;
if(this.isFreshing){
if(type == 'get'){
this.setState({
getTopicError:'fetchFailed'});}


return;}


this.isFreshing = true;
this.setState({
isLoading:true,
loadingType:type});


var page=type == 'update'?1:this.page + 1;
var tab=this.props.tab.name;
var actions=this.props.actions;
var getTopics=actions.getTopicsByTab;
var updateTopics=actions.updateTopicsByTab;

TopicService.req.getTopicsByTab({
page:page,
tab:tab,
limit:10}).

then(function(topics){
console.log('fetched topics');
LayoutAnimation.configureNext(LayoutAnimation.Presets.spring);
type == 'update'?updateTopics(topics,tab):getTopics(topics,tab);
return null;}).

catch(function(err){
console.warn(err);
if(type == 'get'){
return err;}}).


done(function(err){
_this.isFreshing = false;
_this.setState({
isLoading:false,
err:err});

_this.page = page;});}},{key:'_renderLoading',value:




function _renderLoading(loadingType){
return (
React.createElement(ActivityIndicatorIOS,{
hidesWhenStopped:false,
size:'large',
animating:true,
style:[extendsStyles['loading' + loadingType]]}));}},{key:'_renderTopicFooter',value:





function _renderTopicFooter(topic){
var renderArr=[];
var navs={
ask:'问答',
share:'分享',
job:'招聘'};

var tab=navs[topic.tab] || '分享';
var date=moment(topic.last_reply_at).startOf('minute').fromNow();


renderArr.push(
React.createElement(Text,{
key:'countText',
style:[styles['topicFooter text'],styles['topicFooter count']]},
topic.reply_count + ' / ' + topic.visit_count));


renderArr.push(
React.createElement(Text,{
key:'tabText',
style:[styles['topicFooter text'],styles['topicFooter tab']]},
tab));



renderArr.push(
React.createElement(Text,{
key:'dateText',
style:[styles['topicFooter text'],styles['topicFooter date']]},
date));



if(topic.top){
renderArr.push(
React.createElement(Text,{
key:'topText',
style:[styles['topicFooter text'],styles['topicFooter tab'],styles['topicFooter top']]},
'顶'));}



if(topic.good){
renderArr.push(
React.createElement(Text,{
key:'goodText',
style:[styles['topicFooter text'],styles['topicFooter tab'],styles['topicFooter good']]},
'精'));}



return renderArr;}},{key:'_renderHeader',value:




function _renderHeader(){
if(this.state.isLoading && this.state.loadingType == 'update'){
return this._renderLoading('update');}


return null;}},{key:'_renderFooter',value:



function _renderFooter(){
if(this.state.isLoading && this.state.loadingType == 'get'){
return this._renderLoading('get');}







return null;}},{key:'renderRow',value:



function renderRow(topic){
return (
React.createElement(TopicRow,{
onPress:this._onRowPress.bind(this),
topic:topic,
footer:this._renderTopicFooter(topic)}));}},{key:'render',value:





function render(){var _this2=this;
return (
React.createElement(View,{style:[{width:width,height:height - 40},{backgroundColor:'white'}]},
React.createElement(ListView,{
ref:function(view){_this2._listView = view;},
style:{backgroundColor:'rgba(255,255,255,1)'},
onScroll:this.onScroll.bind(this),
showsVerticalScrollIndicator:true,
initialListSize:10,
pagingEnabled:false,
removeClippedSubviews:true,
dataSource:this.state.ds,
renderRow:this.renderRow.bind(this),
onEndReached:this.onEndReached.bind(this),
scrollRenderAheadDistance:90,
renderHeader:this._renderHeader.bind(this),
renderFooter:this._renderFooter.bind(this)})));}}]);return PageListView;})(Component);







var styles=StyleSheet.create({
'row':{
'height':90,
'flexDirection':'row',
'borderBottomColor':'rgba(0, 0, 0, 0.02)',
'borderBottomWidth':1,
'paddingTop':25,
'paddingRight':0,
'paddingBottom':25,
'paddingLeft':20},

'imgWrapper':{
'width':90,
'position':'absolute',
'left':20,
'top':25,
'height':65},

'img':{
'height':40,
'width':40,
'borderRadius':20},

'topic':{
'marginLeft':60},

'title':{
'fontSize':15},

'topicFooter':{
'marginTop':12,
'flexDirection':'row'},

'topicFooter text':{
'fontSize':11,
'color':'rgba(0, 0, 0, 0.5)'},

'topicFooter date':{
'position':'absolute',
'right':0,
'top':0},

'topicFooter count':{
'marginRight':15},

'topicFooter top':{
'fontSize':11,
'marginTop':1,
'marginRight':0,
'marginBottom':0,
'marginLeft':10,
'color':'#E74C3C'},

'topicFooter good':{
'fontSize':11,
'marginTop':1,
'marginRight':0,
'marginBottom':0,
'marginLeft':10,
'color':'#2ECC71'},

'topicFooter tab':{
'fontSize':11,
'marginTop':1,
'marginRight':0,
'marginBottom':0,
'marginLeft':10},

'loading':{
'marginTop':250},

footerErrorText:{
fontSize:20,
textAlign:'center',
flex:1},

footerError:{
height:76,
width:width,
flexDirection:'column'}});



module.exports = PageListView;
});
__d('noder/app/components/overlay/messageOverlay.js',["react-native/Libraries/react-native/react-native.js","react-native-icons/index.js","noder/app/components/overlay/overlayButton.js","noder/app/configs/routes.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  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;};})();var _get=function get(object,property,receiver){if(object === null)object = Function.prototype;var desc=Object.getOwnPropertyDescriptor(object,property);if(desc === undefined){var parent=Object.getPrototypeOf(object);if(parent === null){return undefined;}else {return get(parent,property,receiver);}}else if('value' in desc){return desc.value;}else {var getter=desc.get;if(getter === undefined){return undefined;}return getter.call(receiver);}};function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}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)subClass.__proto__ = superClass;}var React=require('react-native/Libraries/react-native/react-native.js');var _require=
require('react-native-icons/index.js');var Icon=_require.Icon;

var OverlayButton=require('noder/app/components/overlay/overlayButton.js');

var routes=require('noder/app/configs/routes.js');

var window=require('noder/app/util/window.js');var _window$get=
window.get();var width=_window$get.width;var height=_window$get.height;var 


View=




React.View;var Text=React.Text;var Component=React.Component;var StyleSheet=React.StyleSheet;var Image=React.Image;var 


MessageOverlay=(function(_Component){_inherits(MessageOverlay,_Component);
function MessageOverlay(props){_classCallCheck(this,MessageOverlay);
_get(Object.getPrototypeOf(MessageOverlay.prototype),'constructor',this).call(this,props);}_createClass(MessageOverlay,[{key:'componentDidMount',value:


function componentDidMount(){
this.props.getUnreadCount(this.props.user.token);}},{key:'_renderMessageCount',value:



function _renderMessageCount(){
var count=this.props.count;

if(count > 0){
return (
React.createElement(View,{style:styles.countWrapper},
React.createElement(Text,{style:styles.countText},
count > 999?'1k+':count)));}





return null;}},{key:'_onPress',value:



function _onPress(){
this.props.router.toMessage();}},{key:'render',value:



function render(){
if(this.props.user){
return (
React.createElement(OverlayButton,{
position:styles.position,
onPress:this._onPress.bind(this)},
React.createElement(Icon,{
name:'ion|ios-email-outline',
size:28,
color:'rgba(255,255,255,0.9)',
style:styles.icon}),

this._renderMessageCount()));}



return null;}}]);return MessageOverlay;})(Component);




var overlaySize=45;
var countBoxSize=20;
var countTextSize=10;


var styles=StyleSheet.create({
icon:{
height:overlaySize,
width:overlaySize,
borderRadius:overlaySize / 2},

countWrapper:{
height:countBoxSize,
width:countBoxSize,
borderRadius:countBoxSize / 2,
backgroundColor:'red',
position:'absolute',
right:-5,
top:-5},

countText:{
color:'rgba(255,255,255,0.8)',
fontSize:countTextSize,
lineHeight:countBoxSize - countTextSize / 2,
textAlign:'center',
height:countBoxSize,
width:countBoxSize,
borderRadius:countBoxSize / 2},

position:{
right:20,
bottom:20},

container:{
backgroundColor:'blue',
borderRadius:overlaySize / 2}});




module.exports = MessageOverlay;
});
__d('noder/app/actions/index.js',["noder/app/actions/UserActions.js","noder/app/actions/HomeActions.js","noder/app/actions/MessageActions.js","noder/app/actions/TopicActions.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var user=require('noder/app/actions/UserActions.js');
var home=require('noder/app/actions/HomeActions.js');
var message=require('noder/app/actions/MessageActions.js');
var topic=require('noder/app/actions/TopicActions.js');

var actions={};

Object.assign(actions,user,home,message,topic);

module.exports = actions;
});
__d('noder/app/actions/UserActions.js',["noder/app/constants/ActionTypes.js","noder/app/services/userService.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var types=require('noder/app/constants/ActionTypes.js');
var UserService=require('noder/app/services/userService.js');


function getUser(user){
return {
type:types.GET_USER,
user:user};}




exports.getLoginUserFromStorage = function(){
return function(dispatch){
var userTemp={};
UserService.storage.getUser().
then(function(user){
console.log('haveLoadedUser');
if(user){
dispatch(getUser(user));
userTemp = user;
return UserService.req.getLoginUserInfo(user);}else 

{
throw 'GET_LOGIN_USER_FROM_STORAGE_FAILED';}}).



then(function(userFetched){
console.log('fetchUser');
if(userFetched){
var userUpdated=Object.assign(userTemp,userFetched);
UserService.storage.saveUser(userUpdated);
dispatch(getUser(userTemp));}}).


catch(function(err){
console.warn(err);}).

done();};};




exports.fetchUser = function fetchUser(user){
return function(dispatch){
UserService.req.getLoginUserInfo(user).
then(function(userInfo){
if(userInfo){
Object.assign(user,userInfo);
UserService.storage.saveUser(user);
dispatch(getUser(user));}}).





done();};};




exports.checkToken = function(token){
return function(dispatch){
var userTemp={};
dispatch({
type:types.CHECK_TOKEN_REQUREST});

UserService.req.checkToken(token).
then(function(user){
userTemp = user;
return UserService.req.getLoginUserInfo(user);}).

then(function(userInfo){
if(userInfo){
Object.assign(userTemp,userInfo);
UserService.storage.saveUser(userTemp);
dispatch(getUser(userTemp));
dispatch({
type:types.CHECK_TOKEN_SUCCESS,
isModalOpen:false});}else 


{
throw 'CHECK_TOKEN_FAILED';}}).


catch(function(err){
console.warn(err);
dispatch({
type:types.CHECK_TOKEN_FAILED,
err:err});

window.alert('token验证失败');}).

done();};};




exports.likeTopic = function(topic){
return {
type:types.LIKE_TOPIC,
topic:{
id:topic.id,
author:topic.author,
title:topic.title,
last_reply_at:topic.last_reply_at}};};





exports.unLikeTopic = function(id){
return {
type:types.UN_LIKE_TOPIC,
id:id};};
});
__d('noder/app/constants/ActionTypes.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  exports.GET_USER = 'GET_USER';
exports.GET_LOGIN_USER_FROM_STORAGE = 'GET_LOGIN_USER_FROM_STORAGE';
exports.GET_USER_FROM_STORAGE_FAILED = 'GET_USER_FROM_STORAGE_FAILED';
exports.FETCH_USER = 'FETCH_USER';


exports.OPEN_LOGIN_MODAL = 'OPEN_LOGIN_MODAL';
exports.CLOSE_LOGIN_MODAL = 'CLOSE_LOGIN_MODAL';
exports.LOGIN_SUCCESS = 'LOGIN_SUCCESS';
exports.QR_SUCCESS = 'QR_SUCCESS';
exports.CHECK_TOKEN_SUCCESS = 'CHECK_TOKEN_SUCCESS';
exports.CHECK_TOKEN_REQUREST = 'CHECK_TOKEN_REQUREST';
exports.CHECK_TOKEN_FAILED = 'CHECK_TOKEN_FAILED';
exports.LIKE_TOPIC = 'LIKE_TOPIC';
exports.UN_LIKE_TOPIC = 'UN_LIKE_TOPIC';


exports.GET_UNREAD_MESSAGE_COUNT_SUCCESS = 'GET_UNREAD_MESSAGE_COUNT_SUCCESS';
exports.GET_MESSAGES = 'GET_MESSAGES';
exports.FETCH_MESSAGES_FAILED = 'FETCH_MESSAGES_FAILED';
exports.FETCH_MESSAGES_REQUEST = 'FETCH_MESSAGES_REQUEST';
exports.FETCH_MESSAGES_SUCCESS = 'FETCH_MESSAGES_SUCCESS';
exports.MARK_AS_READ_SUCCESS = 'MARK_AS_READ_SUCCESS';
exports.MARK_AS_READ_FAILED = 'MARK_AS_READ_FAILED';
exports.MARK_AS_READ_REQUEST = 'MARK_AS_READ_REQUEST';


exports.GET_ALL_TOPICS_FROM_STORAGE = 'GET_ALL_TOPICS_FROM_STORAGE';
exports.FETCH_TOPICS_BY_TAB_REQUEST = 'FETCH_TOPICS_BY_TAB_REQUEST';
exports.FETCH_TOPICS_BY_TAB_SUCCESS = 'FETCH_TOPICS_BY_TAB_SUCCESS';
exports.FETCH_TOPICS_BY_TAB_FAILED = 'FETCH_TOPICS_BY_TAB_FAILED';


exports.GET_TOPICS = 'GET_TOPICS';
exports.UPDATE_TOPICS = 'UPDATE_TOPICS';
});
__d('noder/app/actions/HomeActions.js',["noder/app/constants/ActionTypes.js","noder/app/services/userService.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var types=require('noder/app/constants/ActionTypes.js');
var UserService=require('noder/app/services/userService.js');
var window=require('noder/app/util/window.js');


exports.openLoginModal = function openLoginModal(){
return {
type:types.OPEN_LOGIN_MODAL,
isModalOpen:true};};



exports.closeLoginModal = function closeLoginModal(){
return {
type:types.CLOSE_LOGIN_MODAL,
isModalOpen:false};};
});
__d('noder/app/actions/MessageActions.js',["noder/app/constants/ActionTypes.js","noder/app/services/messageService.js","noder/app/util/window.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var types=require('noder/app/constants/ActionTypes.js');
var MessageService=require('noder/app/services/messageService.js');


var window=require('noder/app/util/window.js');


function getMessages(messages){
return {
type:types.GET_MESSAGES,
hasRead:messages.has_read_messages,
hasNotRead:messages.hasnot_read_messages,
isLoading:true};}



function fetchMessagesRequest(){
return {
type:types.FETCH_MESSAGES_REQUEST,
isLoading:true};}



function fetchMessagesSuccess(messages){
return {
type:types.FETCH_MESSAGES_SUCCESS,
isLoading:false,
hasRead:messages.has_read_messages,
hasNotRead:messages.hasnot_read_messages};}



function fetchMessagesFailed(err){
return {
type:types.FETCH_MESSAGES_FAILED,
isLoading:false,
err:err};}



exports.getUnreadMessageCount = function(token){
return function(dispatch){
MessageService.req.getUnreadMessageCount(token).
then(function(count){
dispatch({
type:types.GET_UNREAD_MESSAGE_COUNT_SUCCESS,
count:count});}).


catch(function(err){
console.warn(err);}).

done();};};




exports.getMessages = function(token){
return function(dispatch){

dispatch(fetchMessagesRequest());

MessageService.storage.get().
then(function(messages){
if(messages){
dispatch(getMessages(messages));}

return MessageService.req.get(token);}).

then(function(messages){
if(messages){
dispatch(fetchMessagesSuccess(messages));}else 

{
throw 'FETCH_MESSAGES_FAILED';}}).


catch(function(err){
dispatch(fetchMessagesFailed(err));}).

done();};};




exports.fetchMessages = function(token){
return function(dispatch){
dispatch(fetchMessagesRequest());

MessageService.req.get(token).
then(function(messages){
if(messages){
dispatch(fetchMessagesSuccess(messages));}else 

{
throw 'FETCH_MESSAGES_FAILED';}}).


catch(function(err){
dispatch(fetchMessagesFailed(err));}).

done();};};




exports.markAsRead = function(token){
return function(dispatch){
dispatch({
type:types.MARK_AS_READ_REQUEST});

MessageService.req.markAsRead(token).
then(function(){
dispatch({
type:types.MARK_AS_READ_SUCCESS});

window.alert('已全部标记为已读!');}).

catch(function(){
dispatch({
type:types.MARK_AS_READ_FAILED});

window.alert('标记失败!');}).

done();};};
});
__d('noder/app/services/messageService.js',["noder/app/util/storage.js","noder/app/services/request.js","noder/app/configs/config.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var Storage=require('noder/app/util/storage.js');
var request=require('noder/app/services/request.js');
var config=require('noder/app/configs/config.js');

var storage={};

storage.get = function(){
return Storage.getItem('messages');};


storage.save = function(value){
return Storage.setItem('messages',value);};



var req={};

req.get = function(token){
var apiUrl=config.domain + config.apiPath + '/messages' + '?accesstoken=' + token;

return request.get(apiUrl).
then(function(data){return data.data;}).
then(function(messages){
if(messages){
storage.save(messages);
return messages;}else 

{
throw 'getMessagesFailed';}});};




req.markAsRead = function(token){
var apiUrl=config.domain + config.apiPath + '/message/mark_all';

return request.post(apiUrl,{
accesstoken:token}).

then(function(data){
console.log(data);
if(data.success){
return data;}else 

{
throw 'markAsReadFailed';}});};





req.getUnreadMessageCount = function(token){
var url=config.domain + config.apiPath + '/message/count';
return request.get(url,{
accesstoken:token}).

then(function(data){return data.data;});};



exports.storage = storage;
exports.req = req;
});
__d('noder/app/actions/TopicActions.js',["noder/app/constants/ActionTypes.js","noder/app/services/topicService.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var types=require('noder/app/constants/ActionTypes.js');
var TopicService=require('noder/app/services/topicService.js');


exports.fetchTopicsByTab = function(params,cbs){
return function(dispatch){
dispatch({
type:types.FETCH_TOPICS_BY_TAB_REQUEST,
tab:params.tab});

cbs = cbs || {};
cbs.request && cbs.request();

TopicService.req.getTopicsByTab(params).
then(function(topics){
console.log('fetchedTopics');
dispatch({
type:types.FETCH_TOPICS_BY_TAB_SUCCESS,
tab:params.tab,
topics:topics});

cbs.success && cbs.success();}).

catch(function(){
dispatch({
type:types.FETCH_MESSAGES_FAILED,
tab:params.tab});

cbs.failed && cbs.failed();}).

done();};};




exports.getAllTopicsFromStorage = function(){
return function(dispatch){
TopicService.storage.getAll().
then(function(results){
dispatch({
type:types.GET_ALL_TOPICS_FROM_STORAGE,
results:results});}).


catch(function(err){}).


done();};};




exports.getTopicsByTab = function(topics,tab){
return {
type:types.GET_TOPICS,
topics:topics,
tab:tab};};




exports.updateTopicsByTab = function(topics,tab){
return {
type:types.UPDATE_TOPICS,
topics:topics,
tab:tab};};
});
__d('redux/react-native.js',["redux/lib/react-native.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;

function _interopRequireWildcard(obj){if(obj && obj.__esModule){return obj;}else {var newObj={};if(obj != null){for(var key in obj) {if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key] = obj[key];}}newObj['default'] = obj;return newObj;}}

function _defaults(obj,defaults){var keys=Object.getOwnPropertyNames(defaults);for(var i=0;i < keys.length;i++) {var key=keys[i];var value=Object.getOwnPropertyDescriptor(defaults,key);if(value && value.configurable && obj[key] === undefined){Object.defineProperty(obj,key,value);}}return obj;}

var _libReactNative=require('redux/lib/react-native.js');

_defaults(exports,_interopRequireWildcard(_libReactNative));
});
__d('redux/lib/react-native.js',["react-native/Libraries/react-native/react-native.js","redux/lib/components/createAll.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

var _reactNative=require('react-native/Libraries/react-native/react-native.js');

var _reactNative2=_interopRequireDefault(_reactNative);

var _componentsCreateAll=require('redux/lib/components/createAll.js');

var _componentsCreateAll2=_interopRequireDefault(_componentsCreateAll);

var _createAll=_componentsCreateAll2['default'](_reactNative2['default']);

var Provider=_createAll.Provider;
var Connector=_createAll.Connector;
var provide=_createAll.provide;
var connect=_createAll.connect;
exports.Provider = Provider;
exports.Connector = Connector;
exports.provide = provide;
exports.connect = connect;
});
__d('redux/lib/components/createAll.js',["redux/lib/components/createProvider.js","redux/lib/components/createProvideDecorator.js","redux/lib/components/createConnector.js","redux/lib/components/createConnectDecorator.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = createAll;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

var _createProvider=require('redux/lib/components/createProvider.js');

var _createProvider2=_interopRequireDefault(_createProvider);

var _createProvideDecorator=require('redux/lib/components/createProvideDecorator.js');

var _createProvideDecorator2=_interopRequireDefault(_createProvideDecorator);

var _createConnector=require('redux/lib/components/createConnector.js');

var _createConnector2=_interopRequireDefault(_createConnector);

var _createConnectDecorator=require('redux/lib/components/createConnectDecorator.js');

var _createConnectDecorator2=_interopRequireDefault(_createConnectDecorator);

function createAll(React){

var Provider=_createProvider2['default'](React);
var Connector=_createConnector2['default'](React);


var provide=_createProvideDecorator2['default'](React,Provider);
var connect=_createConnectDecorator2['default'](React,Connector);

return {Provider:Provider,Connector:Connector,provide:provide,connect:connect};}


module.exports = exports['default'];
});
__d('redux/lib/components/createProvider.js',["redux/lib/utils/createStoreShape.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;

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;};})();

exports['default'] = createProvider;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}

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)subClass.__proto__ = superClass;}

var _utilsCreateStoreShape=require('redux/lib/utils/createStoreShape.js');

var _utilsCreateStoreShape2=_interopRequireDefault(_utilsCreateStoreShape);

function createProvider(React){
var Component=React.Component;
var PropTypes=React.PropTypes;

var storeShape=_utilsCreateStoreShape2['default'](PropTypes);

return (function(_Component){
function Provider(props,context){
_classCallCheck(this,Provider);

_Component.call(this,props,context);
this.state = {store:props.store};}


_inherits(Provider,_Component);

Provider.prototype.getChildContext = function getChildContext(){
return {store:this.state.store};};


Provider.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps){
var store=this.state.store;
var nextStore=nextProps.store;

if(store !== nextStore){
var nextReducer=nextStore.getReducer();
store.replaceReducer(nextReducer);}};



Provider.prototype.render = function render(){
var children=this.props.children;

return children();};


_createClass(Provider,null,[{
key:'childContextTypes',
value:{
store:storeShape.isRequired},

enumerable:true},
{
key:'propTypes',
value:{
children:PropTypes.func.isRequired},

enumerable:true}]);


return Provider;})(
Component);}


module.exports = exports['default'];
});
__d('redux/lib/utils/createStoreShape.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";

exports.__esModule = true;
exports["default"] = createStoreShape;

function createStoreShape(PropTypes){
return PropTypes.shape({
subscribe:PropTypes.func.isRequired,
dispatch:PropTypes.func.isRequired,
getState:PropTypes.func.isRequired});}



module.exports = exports["default"];
});
__d('redux/lib/components/createProvideDecorator.js',["redux/lib/utils/getDisplayName.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;

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;};})();

exports['default'] = createProvideDecorator;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}

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)subClass.__proto__ = superClass;}

var _utilsGetDisplayName=require('redux/lib/utils/getDisplayName.js');

var _utilsGetDisplayName2=_interopRequireDefault(_utilsGetDisplayName);

function createProvideDecorator(React,Provider){
var Component=React.Component;

return function provide(store){
return function(DecoratedComponent){
return (function(_Component){
function ProviderDecorator(){
_classCallCheck(this,ProviderDecorator);

_Component.apply(this,arguments);}


_inherits(ProviderDecorator,_Component);

ProviderDecorator.prototype.render = function render(){
var _this=this;

return React.createElement(
Provider,
{store:store},
function(){
return React.createElement(DecoratedComponent,_this.props);});};




_createClass(ProviderDecorator,null,[{
key:'displayName',
value:'Provider(' + _utilsGetDisplayName2['default'](DecoratedComponent) + ')',
enumerable:true},
{
key:'DecoratedComponent',
value:DecoratedComponent,
enumerable:true}]);


return ProviderDecorator;})(
Component);};};}




module.exports = exports['default'];
});
__d('redux/lib/utils/getDisplayName.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = getDisplayName;

function getDisplayName(Component){
return Component.displayName || Component.name || 'Component';}


module.exports = exports['default'];
});
__d('redux/lib/components/createConnector.js',["invariant","redux/lib/utils/createStoreShape.js","redux/lib/utils/identity.js","redux/lib/utils/shallowEqual.js","redux/lib/utils/isPlainObject.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;

var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};

var _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;};})();

exports['default'] = createConnector;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}

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)subClass.__proto__ = superClass;}

var _utilsCreateStoreShape=require('redux/lib/utils/createStoreShape.js');

var _utilsCreateStoreShape2=_interopRequireDefault(_utilsCreateStoreShape);

var _utilsIdentity=require('redux/lib/utils/identity.js');

var _utilsIdentity2=_interopRequireDefault(_utilsIdentity);

var _utilsShallowEqual=require('redux/lib/utils/shallowEqual.js');

var _utilsShallowEqual2=_interopRequireDefault(_utilsShallowEqual);

var _utilsIsPlainObject=require('redux/lib/utils/isPlainObject.js');

var _utilsIsPlainObject2=_interopRequireDefault(_utilsIsPlainObject);

var _invariant=require('invariant');

var _invariant2=_interopRequireDefault(_invariant);

function createConnector(React){
var Component=React.Component;
var PropTypes=React.PropTypes;

var storeShape=_utilsCreateStoreShape2['default'](PropTypes);

return (function(_Component){
function Connector(props,context){
_classCallCheck(this,Connector);

_Component.call(this,props,context);
this.state = this.selectState(props,context);}


_inherits(Connector,_Component);

Connector.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps,nextState){
return !this.isSliceEqual(this.state.slice,nextState.slice) || !_utilsShallowEqual2['default'](this.props,nextProps);};


Connector.prototype.isSliceEqual = function isSliceEqual(slice,nextSlice){
var isRefEqual=slice === nextSlice;
if(isRefEqual){
return true;}else 
if(typeof slice !== 'object' || typeof nextSlice !== 'object'){
return isRefEqual;}

return _utilsShallowEqual2['default'](slice,nextSlice);};


Connector.prototype.componentDidMount = function componentDidMount(){
this.unsubscribe = this.context.store.subscribe(this.handleChange.bind(this));};


Connector.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps){
if(nextProps.select !== this.props.select){

this.handleChange(nextProps);}};



Connector.prototype.componentWillUnmount = function componentWillUnmount(){
this.unsubscribe();};


Connector.prototype.handleChange = function handleChange(){
var props=arguments[0] === undefined?this.props:arguments[0];

var nextState=this.selectState(props,this.context);
this.setState(nextState);};


Connector.prototype.selectState = function selectState(props,context){
var state=context.store.getState();
var slice=props.select(state);

_invariant2['default'](_utilsIsPlainObject2['default'](slice),'The return value of `select` prop must be an object. Instead received %s.',slice);

return {slice:slice};};


Connector.prototype.render = function render(){
var children=this.props.children;
var slice=this.state.slice;
var dispatch=this.context.store.dispatch;

return children(_extends({dispatch:dispatch},slice));};


_createClass(Connector,null,[{
key:'contextTypes',
value:{
store:storeShape.isRequired},

enumerable:true},
{
key:'propTypes',
value:{
children:PropTypes.func.isRequired,
select:PropTypes.func.isRequired},

enumerable:true},
{
key:'defaultProps',
value:{
select:_utilsIdentity2['default']},

enumerable:true}]);


return Connector;})(
Component);}


module.exports = exports['default'];
});
__d('redux/lib/utils/identity.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";

exports.__esModule = true;
exports["default"] = identity;

function identity(value){
return value;}


module.exports = exports["default"];
});
__d('redux/lib/utils/shallowEqual.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  "use strict";

exports.__esModule = true;
exports["default"] = shallowEqual;

function shallowEqual(objA,objB){
if(objA === objB){
return true;}


var keysA=Object.keys(objA);
var keysB=Object.keys(objB);

if(keysA.length !== keysB.length){
return false;}



var hasOwn=Object.prototype.hasOwnProperty;
for(var i=0;i < keysA.length;i++) {
if(!hasOwn.call(objB,keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]){
return false;}}



return true;}


module.exports = exports["default"];
});
__d('redux/lib/components/createConnectDecorator.js',["redux/lib/utils/getDisplayName.js","redux/lib/utils/shallowEqualScalar.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;

var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};

var _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;};})();

exports['default'] = createConnectDecorator;

function _interopRequireDefault(obj){return obj && obj.__esModule?obj:{'default':obj};}

function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError('Cannot call a class as a function');}}

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)subClass.__proto__ = superClass;}

var _utilsGetDisplayName=require('redux/lib/utils/getDisplayName.js');

var _utilsGetDisplayName2=_interopRequireDefault(_utilsGetDisplayName);

var _utilsShallowEqualScalar=require('redux/lib/utils/shallowEqualScalar.js');

var _utilsShallowEqualScalar2=_interopRequireDefault(_utilsShallowEqualScalar);

function createConnectDecorator(React,Connector){
var Component=React.Component;

return function connect(select){
return function(DecoratedComponent){
return (function(_Component){
function ConnectorDecorator(){
_classCallCheck(this,ConnectorDecorator);

_Component.apply(this,arguments);}


_inherits(ConnectorDecorator,_Component);

ConnectorDecorator.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps){
return !_utilsShallowEqualScalar2['default'](this.props,nextProps);};


ConnectorDecorator.prototype.render = function render(){
var _this=this;

return React.createElement(
Connector,
{select:function(state){
return select(state,_this.props);}},

function(stuff){
return React.createElement(DecoratedComponent,_extends({},stuff,_this.props));});};




_createClass(ConnectorDecorator,null,[{
key:'displayName',
value:'Connector(' + _utilsGetDisplayName2['default'](DecoratedComponent) + ')',
enumerable:true},
{
key:'DecoratedComponent',
value:DecoratedComponent,
enumerable:true}]);


return ConnectorDecorator;})(
Component);};};}




module.exports = exports['default'];
});
__d('redux/lib/utils/shallowEqualScalar.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  'use strict';

exports.__esModule = true;
exports['default'] = shallowEqualScalar;

function shallowEqualScalar(objA,objB){
if(objA === objB){
return true;}


if(typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null){
return false;}


var keysA=Object.keys(objA);
var keysB=Object.keys(objB);

if(keysA.length !== keysB.length){
return false;}



var hasOwn=Object.prototype.hasOwnProperty;
for(var i=0;i < keysA.length;i++) {
if(!hasOwn.call(objB,keysA[i])){
return false;}


var valA=objA[keysA[i]];
var valB=objB[keysA[i]];

if(valA !== valB || typeof valA === 'object' || typeof valB === 'object'){
return false;}}



return true;}


module.exports = exports['default'];
});
__d('noder/app/reducers/index.js',["noder/app/reducers/user.js","noder/app/reducers/home.js","noder/app/reducers/message.js","noder/app/reducers/topic.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  exports.user = require('noder/app/reducers/user.js');
exports.home = require('noder/app/reducers/home.js');
exports.message = require('noder/app/reducers/message.js');
exports.topic = require('noder/app/reducers/topic.js');
});
__d('noder/app/reducers/user.js',["noder/app/constants/ActionTypes.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};var types=require('noder/app/constants/ActionTypes.js');


var initialState={};

function unLikeTopic(state,id){
var collections=state.collect_topics;
var index=-1;
for(var i=0;i < collections.length;i++) {
if(collections[i].id == id){
index = i;}}


if(index > -1){
collections.splice(index,1);}

return _extends({},
state,{
collect_topics:collections});}



module.exports = function(state,action){
state = state || initialState;
switch(action.type){
case types.GET_USER:
return action.user;

case types.FETCH_USER:
return action.user;

case types.LIKE_TOPIC:
return _extends({},
state,{
collect_topics:[action.topic].concat(state.collect_topics)});


case types.UN_LIKE_TOPIC:
return unLikeTopic(state,action.id);

default:
return state;}};
});
__d('noder/app/reducers/home.js',["noder/app/constants/ActionTypes.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};var types=require('noder/app/constants/ActionTypes.js');

var initialState={
isModalOpen:false,
checkTokenLoading:false};



module.exports = function(state,action){
state = state || initialState;
switch(action.type){
case types.OPEN_LOGIN_MODAL:
return {
isModalOpen:true};

case types.CLOSE_LOGIN_MODAL:
return {
isModalOpen:false};

case types.CHECK_TOKEN_REQUREST:
return _extends({},
state,{
checkTokenLoading:true});

case types.CHECK_TOKEN_SUCCESS:
return {
isModalOpen:false,
checkTokenLoading:false};

default:
return state;}};
});
__d('noder/app/reducers/message.js',["noder/app/constants/ActionTypes.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};var types=require('noder/app/constants/ActionTypes.js');

var initialState={
isLoading:false,
hasNotRead:[],
hasRead:[],
unreadMessageCount:0,
isMarkAsReadLoading:false};



module.exports = function(state,action){
state = state || initialState;

switch(action.type){
case types.GET_UNREAD_MESSAGE_COUNT_SUCCESS:
return _extends({},
state,{
unreadMessageCount:action.count});


case types.GET_MESSAGES:
return _extends({},
state,{
isLoading:true,
unreadMessageCount:action.hasNotRead.length,
hasRead:action.hasRead,
hasNotRead:action.hasNotRead});


case types.FETCH_MESSAGES_REQUEST:
return _extends({},
state,{
isLoading:true});


case types.FETCH_MESSAGES_SUCCESS:
return _extends({},
state,{
unreadMessageCount:action.hasNotRead.length,
hasRead:action.hasRead,
hasNotRead:action.hasNotRead,
isLoading:false});


case types.FETCH_MESSAGES_FAILED:
return _extends({},
state,{
isLoading:false});


case types.MARK_AS_READ_REQUEST:
return _extends({},
state,{
isMarkAsReadLoading:true});


case types.MARK_AS_READ_SUCCESS:
return _extends({},
state,{
hasNotRead:[],
hasRead:state.hasNotRead.concat(state.hasRead),
unreadMessageCount:0,
isMarkAsReadLoading:false});


case types.MARK_AS_READ_FAILED:
return _extends({},
state,{
isMarkAsReadLoading:false});


default:
return state;}};
});
__d('noder/app/reducers/topic.js',["noder/app/constants/ActionTypes.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var _extends=Object.assign || function(target){for(var i=1;i < arguments.length;i++) {var source=arguments[i];for(var key in source) {if(Object.prototype.hasOwnProperty.call(source,key)){target[key] = source[key];}}}return target;};



var types=require('noder/app/constants/ActionTypes.js');

var tabs=['good','ask','all','share','job'];

var initialTabState={
isLoading:true,
topics:[]};



var initialState={};


tabs.forEach(function(tab){
initialTabState.name = tab;
initialState[tab] = Object.assign({},initialTabState);});



function getTopicsFromStorage(state,action){var 
results=action.results;

results.forEach(function(item,index){
state[tabs[index]].topics = item[1];});


return Object.assign({},state);}


function fetchTopicsByTabRequest(state,action){var 
tab=action.tab;
var tabState=state[tab];
state[tab] = _extends({},
tabState,{
isLoading:true});

return Object.assign({},state);}



function fetchTopicsByTabSuccess(state,action){var 
tab=action.tab;
var tabState=state[tab];
var topics=tabState.topics;
var page=state[tab].page;
if(action.loadingType == 'get'){
topics = topics.concat(action.topics);
page++;}else 

{
topics = action.topics;
page = 1;}

state[tab] = _extends({},
tabState,{
topics:topics,
isLoading:false,
page:page});

return Object.assign({},state);}



function getTopics(state,action){var 
tab=action.tab;var topics=action.topics;
var tabState=state[tab];
state[tab] = _extends({},
tabState,{
topics:tabState.topics.concat(topics)});

return Object.assign({},state);}



function updateTopics(state,action){var 
tab=action.tab;var topics=action.topics;
var tabState=state[tab];

state[tab] = _extends({},
tabState,{
topics:topics});

return Object.assign({},state);}



module.exports = function(state,action){
state = state || initialState;

switch(action.type){
case types.GET_ALL_TOPICS_FROM_STORAGE:
return getTopicsFromStorage(state,action);







case types.GET_TOPICS:
return getTopics(state,action);

case types.UPDATE_TOPICS:
return updateTopics(state,action);

default:
return state;}};
});
__d('noder/app/mocks/user.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  module.exports = {
"success":true,
"loginname":"soliury",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5032079%3Fv%3D3%26s%3D120",
"id":"51ed5627f4963ade0ea60395",
token:"d376572b-f372-4ff8-836a-091c5d2455fc"};
});
__d('noder/app/mocks/userInfo.js',[],function(global, require, requireDynamic, requireLazy, module, exports) {  module.exports = {
"data":{
"loginname":"soliury",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5032079%3Fv%3D3%26s%3D120",
"githubUsername":"soliury",
"create_at":"2013-07-22T15:56:23.097Z",
"score":1275,
"recent_topics":[{
"id":"55604d9c4eb040084cfe5d4a",
"author":{
"loginname":"soliury",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5032079%3Fv%3D3%26s%3D120"},

"title":"请勿删除此贴，正在调试react-native cnode客户端html渲染",
"last_reply_at":"2015-07-02T10:08:24.522Z"},
{
"id":"55561c2e7cabb7b45ee6bc69",
"author":{
"loginname":"soliury",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5032079%3Fv%3D3%26s%3D120"},

"title":"【Gulp Tips】错误处理",
"last_reply_at":"2015-05-15T16:17:50.185Z"},
{
"id":"5552fc48c62bb7483db55101",
"author":{
"loginname":"soliury",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5032079%3Fv%3D3%26s%3D120"},

"title":"【Gulp Tips】如何正确地删除文件",
"last_reply_at":"2015-05-13T07:24:56.959Z"},
{
"id":"5551b1cf7664e06d7cd471a6",
"author":{
"loginname":"soliury",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5032079%3Fv%3D3%26s%3D120"},

"title":"【Gulp Tips】gulp流为何流",
"last_reply_at":"2015-05-12T14:21:21.231Z"},
{
"id":"5551a6067664e06d7cd4718f",
"author":{
"loginname":"soliury",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5032079%3Fv%3D3%26s%3D120"},

"title":"关于gulp",
"last_reply_at":"2015-05-13T10:46:18.039Z"}],

"recent_replies":[{
"id":"5595f55547e6bdc30297ed8b",
"author":{
"loginname":"meiguixu",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F13146138%3Fv%3D3%26s%3D120"},

"title":"【巨头联手：阿里巴巴+SMG】平台广阔，坐标上海，第一财经高薪招募RUBY及WEB开发工程师",
"last_reply_at":"2015-07-03T02:50:38.925Z"},
{
"id":"55955f2147e6bdc30297ecd7",
"author":{
"loginname":"zenghongyujia123",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F7914166%3Fv%3D3%26s%3D120"},

"title":"［上海］已拿A轮融资的互联网+物流创业新军 -  底薪180K+ 和 15K+期权  颜值（高）味道（爆）与环境 (爽)，诚聘 js 程序员 ！",
"last_reply_at":"2015-07-03T04:25:46.068Z"},
{
"id":"5595402b47e6bdc30297ecb7",
"author":{
"loginname":"mmXiaoYao",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F13150693%3Fv%3D3%26s%3D120"},

"title":"velocity.Parser and velocity.Compile",
"last_reply_at":"2015-07-02T13:59:55.532Z"},
{
"id":"5594f0a047e6bdc30297ebf4",
"author":{
"loginname":"youlong723687543",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F13144449%3Fv%3D3%26s%3D120"},

"title":"技术世界一片茫然",
"last_reply_at":"2015-07-03T00:25:20.826Z"},
{
"id":"5594ed6947e6bdc30297ebeb",
"author":{
"loginname":"somonus",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5165612%3Fv%3D3%26s%3D120"},

"title":"[杭州-滨江] 阿里巴巴数据产品部招聘前端/全端工程师",
"last_reply_at":"2015-07-03T01:39:29.849Z"}],

"collect_topics":[{
"id":"55928df39418ff516f650e6b",
"author":{
"loginname":"DavidCai1993",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5886475%3Fv%3D3%26s%3D120"},

"title":"分享一个自己翻译的io.js API 中文文档（完成度100%）",
"last_reply_at":"2015-07-03T04:38:05.380Z"},
{
"id":"5590adbbebf9c92d17e734de",
"author":{
"loginname":"i5ting",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3118295%3Fv%3D3%26s%3D120"},

"title":"mongodb运维之副本集实践",
"last_reply_at":"2015-07-01T08:00:54.885Z"},
{
"id":"558d1453ebf9c92d17e732fa",
"author":{
"loginname":"PaulGuo",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F758740%3Fv%3D3%26s%3D120"},

"title":"美团酒店Node全栈开发实践",
"last_reply_at":"2015-07-01T04:00:23.493Z"},
{
"id":"558b6b92c31358754d3aa3cd",
"author":{
"loginname":"i5ting",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3118295%3Fv%3D3%26s%3D120"},

"title":"sails vs meteor之sails篇",
"last_reply_at":"2015-06-30T01:17:55.285Z"},
{
"id":"558a80b0c31358754d3aa343",
"author":{
"loginname":"turing",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2Ffd05a307dcd03fdef795a3c9810ae667%3Fsize%3D48"},

"title":"聊聊实时 Node 应用性能监测的实现",
"last_reply_at":"2015-07-03T04:04:14.020Z"},
{
"id":"55815f28395a0c1812f18257",
"author":{
"loginname":"i5ting",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3118295%3Fv%3D3%26s%3D120"},

"title":"Koa 还是 Express？",
"last_reply_at":"2015-06-24T13:22:20.747Z"},
{
"id":"557c354d16839d2d539362b6",
"author":{
"loginname":"luoyjx",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F4217102%3Fv%3D3%26s%3D120"},

"title":"分享下重放攻击的概念",
"last_reply_at":"2015-06-16T05:46:03.935Z"},
{
"id":"55778225c4e7fbea6e9a3357",
"author":{
"loginname":"i5ting",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3118295%3Fv%3D3%26s%3D120"},

"title":"Nodejs RESTFul架构实践",
"last_reply_at":"2015-06-14T12:47:37.356Z"},
{
"id":"5536708e48636414313a72ff",
"author":{
"loginname":"i5ting",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3118295%3Fv%3D3%26s%3D120"},

"title":"使用config来管理配置文件",
"last_reply_at":"2015-04-23T15:17:00.088Z"},
{
"id":"552b3b9382388cec50cf6d95",
"author":{
"loginname":"i5ting",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3118295%3Fv%3D3%26s%3D120"},

"title":"客户端 API 开发总结",
"last_reply_at":"2015-06-24T01:59:19.938Z"},
{
"id":"5524989ab50122cc0bf6d60e",
"author":{
"loginname":"2596887568",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F9349200%3Fv%3D3%26s%3D120"},

"title":"AngularJS的启动引导过程",
"last_reply_at":"2015-04-08T10:51:50.328Z"},
{
"id":"551802d3687c387d2f5b2906",
"author":{
"loginname":"JerryC8080",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F6801672%3Fv%3D3%26s%3D120"},

"title":"基于RESTful API 怎么设计用户权限控制？",
"last_reply_at":"2015-05-27T01:19:10.861Z"},
{
"id":"551200e6d792542a29789a43",
"author":{
"loginname":"tw93",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F8736212%3Fv%3D3%26s%3D120"},

"title":"深入浅出Nodejs读书笔记",
"last_reply_at":"2015-06-11T04:53:25.330Z"},
{
"id":"54b3fc05edf686411e1b9ce1",
"author":{
"loginname":"wewoor",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F2766811%3Fv%3D3%26s%3D120"},

"title":"谁也阻挡不了我穿墙！！搭建自己的VPN",
"last_reply_at":"2015-01-29T12:15:12.992Z"},
{
"id":"549ec1388ade094b67f3fdb4",
"author":{
"loginname":"i5ting",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3118295%3Fv%3D3%26s%3D120"},

"title":"关于sloc",
"last_reply_at":"2014-12-28T14:59:02.225Z"},
{
"id":"5475befe65e5a201268b9193",
"author":{
"loginname":"wizardforcel",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5080126%3Fv%3D3%26s%3D120"},

"title":"W3School 教程整理",
"last_reply_at":"2014-12-07T01:10:08.412Z"},
{
"id":"546c0b721c825b0c4d79e84a",
"author":{
"loginname":"zengliqi",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F9347370%3Fv%3D3%26s%3D120"},

"title":"也谈如何构建高性能服务端程序",
"last_reply_at":"2014-11-19T03:56:27.098Z"},
{
"id":"546a08fa7981ed441bdda690",
"author":{
"loginname":"pockry",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2F530c7eeafcacfbe52827a98c6a4a1358%3Fsize%3D48"},

"title":"passport.js学习笔记",
"last_reply_at":"2014-11-24T03:11:08.567Z"},
{
"id":"545628badcf5d4372651d18c",
"author":{
"loginname":"justjavac",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F359395%3Fv%3D3%26s%3D120"},

"title":"开发者必备的 Chrome 扩展",
"last_reply_at":"2014-11-02T15:19:26.933Z"},
{
"id":"5450e433d0c2f0fe2f5339dc",
"author":{
"loginname":"laomayi",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2F2da2a62c55430459e62a6cdb41a41a06%3Fsize%3D48"},

"title":"我用NodeJS写了个DHT爬虫, 发现比Python写出的还牛逼!",
"last_reply_at":"2014-10-31T07:08:19.658Z"},
{
"id":"54474a6b649ac9220757b8c7",
"author":{
"loginname":"justjavac",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F359395%3Fv%3D3%26s%3D120"},

"title":"Firebase 相关文章的索引",
"last_reply_at":"2014-10-23T07:01:14.870Z"},
{
"id":"541414d88518442c6218e15d",
"author":{
"loginname":"lgqlee",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F6489372%3Fv%3D3%26s%3D120"},

"title":"大家都是怎么学node的呢？",
"last_reply_at":"2014-09-21T03:46:49.567Z"},
{
"id":"540880ebf4d8f79a5a0706df",
"author":{
"loginname":"okoala",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F2127199%3Fv%3D3%26s%3D120"},

"title":"教你如何快速掌握Chrome DevTools中的各种NB技能~~",
"last_reply_at":"2014-09-06T02:51:21.993Z"},
{
"id":"53ca1b2d2df7453a44f8ebf4",
"author":{
"loginname":"FuGardenia",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F3283580%3Fv%3D3%26s%3D120"},

"title":"全国省市乡镇村地区五级联动",
"last_reply_at":"2014-07-20T05:18:53.891Z"},
{
"id":"53c652bfc9507b404446ee40",
"author":{
"loginname":"lcjnil",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F5821684%3Fv%3D3%26s%3D120"},

"title":"【翻译】在Nodejs中使用JSON WEB Tokens",
"last_reply_at":"2014-07-17T07:02:00.576Z"},
{
"id":"5354cfdb1969a7b22afbbf82",
"author":{
"loginname":"youqingkui",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F7046903%3Fv%3D3%26s%3D120"},

"title":"请问在 Express 4.0 里如何实现上传？",
"last_reply_at":"2015-04-02T00:21:22.285Z"},
{
"id":"535376501969a7b22aca6d24",
"author":{
"loginname":"nswbmw",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2F11c35a5b58d99d2c8a950165b795917d%3Fsize%3D48"},

"title":"学习 Node.js 的 6 个步骤",
"last_reply_at":"2014-08-11T13:41:50.494Z"},
{
"id":"5203a71844e76d216a727d2e",
"author":{
"loginname":"ggaaooppeenngg",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F4769989%3Fv%3D3%26s%3D120"},

"title":"通读cheerio API",
"last_reply_at":"2015-05-11T07:16:24.961Z"},
{
"id":"51fc8bd944e76d216ab64939",
"author":{
"loginname":"kimady",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2F2c63b57d3c76ccaed06fcc34ba0e8d33%3Fsize%3D48"},

"title":"Node.js 对图片进行裁切、缩放 (gm)",
"last_reply_at":"2014-12-04T08:59:47.007Z"},
{
"id":"5190d61263e9f8a542acd83b",
"author":{
"loginname":"shiedman",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2F849581002e39edc8ffe0cb8b97ee6f12%3Fsize%3D48"},

"title":"[技术讨论]mongodb驱动的正确使用方法",
"last_reply_at":"2014-08-20T05:02:55.341Z"},
{
"id":"516526766d38277306c7d277",
"author":{
"loginname":"lhfcws",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2F19775e24394f727eb342154459370d20%3Fsize%3D48"},

"title":"初识 mocha in NodeJS",
"last_reply_at":"2015-06-05T04:19:13.338Z"},
{
"id":"50aeec5e637ffa41559d2fbe",
"author":{
"loginname":"luofei614",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2Fe45ec2d493a3ffdd0b8a80bb3f8ed5b2%3Fsize%3D48"},

"title":"nodejs+cloudfoundry  实现代理服务器。",
"last_reply_at":"2012-11-23T16:08:23.196Z"},
{
"id":"5076313f25bf229e20212ba8",
"author":{
"loginname":"342479384",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2Fab32ab04dd8ab0a45a6760ae8a466e2a%3Fsize%3D48"},

"title":"如何用node.js 获取访问者的公网IP?",
"last_reply_at":"2015-06-15T09:03:11.382Z"},
{
"id":"504b4924e2b84515770103dd",
"author":{
"loginname":"a272121742",
"avatar_url":"/agent?url=http%3A%2F%2Fwww.gravatar.com%2Favatar%2Fb087595f7b1a3801718f7a04d24add89%3Fsize%3D48"},

"title":"Mongoose学习参考文档——基础篇",
"last_reply_at":"2015-05-18T11:01:56.015Z"},
{
"id":"4fa94df3b92b05485007fd87",
"author":{
"loginname":"JacksonTian",
"avatar_url":"/agent?url=https%3A%2F%2Favatars.githubusercontent.com%2Fu%2F327019%3Fv%3D3%26s%3D120"},

"title":"Node内存泄漏专题",
"last_reply_at":"2014-12-05T03:08:30.190Z"}]}};
});
__d('noder/app/configs/onRun.js',["react-native/Libraries/react-native/react-native.js","noder/app/services/userService.js","noder/app/util/storage.js"],function(global, require, requireDynamic, requireLazy, module, exports) {  var React=require('react-native/Libraries/react-native/react-native.js');
var userService=require('noder/app/services/userService.js');
var storage=require('noder/app/util/storage.js');var 


StatusBarIOS=
React.StatusBarIOS;



StatusBarIOS.setHidden(true,false);
});
;require("noder/index.ios.js");
//@ sourceMappingURL=/index.ios.map