(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.fluxReact = 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})({"/Users/christianalfoni/Development/flux-react/node_modules/eventemitter2/lib/eventemitter2.js":[function(require,module,exports){

/*!

* EventEmitter2

* https://github.com/hij1nx/EventEmitter2

*

* Copyright (c) 2013 hij1nx

* Licensed under the MIT license.

*/

;!function(undefined) {

var isArray = Array.isArray ? Array.isArray : function _isArray(obj) {

return Object.prototype.toString.call(obj) === "[object Array]";

};

var defaultMaxListeners = 10;

function init() {

this._events = {};

if (this._conf) {

configure.call(this, this._conf);

}

}

function configure(conf) {

if (conf) {

this._conf = conf;

conf.delimiter && (this.delimiter = conf.delimiter);

conf.maxListeners && (this._events.maxListeners = conf.maxListeners);

conf.wildcard && (this.wildcard = conf.wildcard);

conf.newListener && (this.newListener = conf.newListener);

if (this.wildcard) {

this.listenerTree = {};

}

}

}

function EventEmitter(conf) {

this._events = {};

this.newListener = false;

configure.call(this, conf);

}

//

// Attention, function return type now is array, always !

// It has zero elements if no any matches found and one or more

// elements (leafs) if there are matches

//

function searchListenerTree(handlers, type, tree, i) {

if (!tree) {

return [];

}

var listeners=[], leaf, len, branch, xTree, xxTree, isolatedBranch, endReached,

typeLength = type.length, currentType = type[i], nextType = type[i+1];

if (i === typeLength && tree._listeners) {

//

// If at the end of the event(s) list and the tree has listeners

// invoke those listeners.

//

if (typeof tree._listeners === 'function') {

handlers && handlers.push(tree._listeners);

return [tree];

} else {

for (leaf = 0, len = tree._listeners.length; leaf < len; leaf++) {

handlers && handlers.push(tree._listeners[leaf]);

}

return [tree];

}

}

if ((currentType === '*' || currentType === '**') || tree[currentType]) {

//

// If the event emitted is '*' at this part

// or there is a concrete match at this patch

//

if (currentType === '*') {

for (branch in tree) {

if (branch !== '_listeners' && tree.hasOwnProperty(branch)) {

listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+1));

}

}

return listeners;

} else if(currentType === '**') {

endReached = (i+1 === typeLength || (i+2 === typeLength && nextType === '*'));

if(endReached && tree._listeners) {

// The next element has a _listeners, add it to the handlers.

listeners = listeners.concat(searchListenerTree(handlers, type, tree, typeLength));

}

for (branch in tree) {

if (branch !== '_listeners' && tree.hasOwnProperty(branch)) {

if(branch === '*' || branch === '**') {

if(tree[branch]._listeners && !endReached) {

listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], typeLength));

}

listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));

} else if(branch === nextType) {

listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+2));

} else {

// No match on this one, shift into the tree but not in the type array.

listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));

}

}

}

return listeners;

}

listeners = listeners.concat(searchListenerTree(handlers, type, tree[currentType], i+1));

}

xTree = tree['*'];

if (xTree) {

//

// If the listener tree will allow any match for this part,

// then recursively explore all branches of the tree

//

searchListenerTree(handlers, type, xTree, i+1);

}

xxTree = tree['**'];

if(xxTree) {

if(i < typeLength) {

if(xxTree._listeners) {

// If we have a listener on a '**', it will catch all, so add its handler.

searchListenerTree(handlers, type, xxTree, typeLength);

}

// Build arrays of matching next branches and others.

for(branch in xxTree) {

if(branch !== '_listeners' && xxTree.hasOwnProperty(branch)) {

if(branch === nextType) {

// We know the next element will match, so jump twice.

searchListenerTree(handlers, type, xxTree[branch], i+2);

} else if(branch === currentType) {

// Current node matches, move into the tree.

searchListenerTree(handlers, type, xxTree[branch], i+1);

} else {

isolatedBranch = {};

isolatedBranch[branch] = xxTree[branch];

searchListenerTree(handlers, type, { '**': isolatedBranch }, i+1);

}

}

}

} else if(xxTree._listeners) {

// We have reached the end and still on a '**'

searchListenerTree(handlers, type, xxTree, typeLength);

} else if(xxTree['*'] && xxTree['*']._listeners) {

searchListenerTree(handlers, type, xxTree['*'], typeLength);

}

}

return listeners;

}

function growListenerTree(type, listener) {

type = typeof type === 'string' ? type.split(this.delimiter) : type.slice();

//

// Looks for two consecutive '**', if so, don't add the event at all.

//

for(var i = 0, len = type.length; i+1 < len; i++) {

if(type[i] === '**' && type[i+1] === '**') {

return;

}

}

var tree = this.listenerTree;

var name = type.shift();

while (name) {

if (!tree[name]) {

tree[name] = {};

}

tree = tree[name];

if (type.length === 0) {

if (!tree._listeners) {

tree._listeners = listener;

}

else if(typeof tree._listeners === 'function') {

tree._listeners = [tree._listeners, listener];

}

else if (isArray(tree._listeners)) {

tree._listeners.push(listener);

if (!tree._listeners.warned) {

var m = defaultMaxListeners;

if (typeof this._events.maxListeners !== 'undefined') {

m = this._events.maxListeners;

}

if (m > 0 && tree._listeners.length > m) {

tree._listeners.warned = true;

console.error('(node) warning: possible EventEmitter memory ' +

'leak detected. %d listeners added. ' +

'Use emitter.setMaxListeners() to increase limit.',

tree._listeners.length);

console.trace();

}

}

}

return true;

}

name = type.shift();

}

return true;

}

// By default EventEmitters will print a warning if more than

// 10 listeners are added to it. This is a useful default which

// helps finding memory leaks.

//

// Obviously not all Emitters should be limited to 10. This function allows

// that to be increased. Set to zero for unlimited.

EventEmitter.prototype.delimiter = '.';

EventEmitter.prototype.setMaxListeners = function(n) {

this._events || init.call(this);

this._events.maxListeners = n;

if (!this._conf) this._conf = {};

this._conf.maxListeners = n;

};

EventEmitter.prototype.event = '';

EventEmitter.prototype.once = function(event, fn) {

this.many(event, 1, fn);

return this;

};

EventEmitter.prototype.many = function(event, ttl, fn) {

var self = this;

if (typeof fn !== 'function') {

throw new Error('many only accepts instances of Function');

}

function listener() {

if (--ttl === 0) {

self.off(event, listener);

}

fn.apply(this, arguments);

}

listener._origin = fn;

this.on(event, listener);

return self;

};

EventEmitter.prototype.emit = function() {

this._events || init.call(this);

var type = arguments[0];

if (type === 'newListener' && !this.newListener) {

if (!this._events.newListener) { return false; }

}

// Loop through the *_all* functions and invoke them.

if (this._all) {

var l = arguments.length;

var args = new Array(l - 1);

for (var i = 1; i < l; i++) args[i - 1] = arguments[i];

for (i = 0, l = this._all.length; i < l; i++) {

this.event = type;

this._all[i].apply(this, args);

}

}

// If there is no 'error' event listener then throw.

if (type === 'error') {

if (!this._all &&

!this._events.error &&

!(this.wildcard && this.listenerTree.error)) {

if (arguments[1] instanceof Error) {

throw arguments[1]; // Unhandled 'error' event

} else {

throw new Error("Uncaught, unspecified 'error' event.");

}

return false;

}

}

var handler;

if(this.wildcard) {

handler = [];

var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();

searchListenerTree.call(this, handler, ns, this.listenerTree, 0);

}

else {

handler = this._events[type];

}

if (typeof handler === 'function') {

this.event = type;

if (arguments.length === 1) {

handler.call(this);

}

else if (arguments.length > 1)

switch (arguments.length) {

case 2:

handler.call(this, arguments[1]);

break;

case 3:

handler.call(this, arguments[1], arguments[2]);

break;

// slower

default:

var l = arguments.length;

var args = new Array(l - 1);

for (var i = 1; i < l; i++) args[i - 1] = arguments[i];

handler.apply(this, args);

}

return true;

}

else if (handler) {

var l = arguments.length;

var args = new Array(l - 1);

for (var i = 1; i < l; i++) args[i - 1] = arguments[i];

var listeners = handler.slice();

for (var i = 0, l = listeners.length; i < l; i++) {

this.event = type;

listeners[i].apply(this, args);

}

return (listeners.length > 0) || !!this._all;

}

else {

return !!this._all;

}

};

EventEmitter.prototype.on = function(type, listener) {

if (typeof type === 'function') {

this.onAny(type);

return this;

}

if (typeof listener !== 'function') {

throw new Error('on only accepts instances of Function');

}

this._events || init.call(this);

// To avoid recursion in the case that type == "newListeners"! Before

// adding it to the listeners, first emit "newListeners".

this.emit('newListener', type, listener);

if(this.wildcard) {

growListenerTree.call(this, type, listener);

return this;

}

if (!this._events[type]) {

// Optimize the case of one listener. Don't need the extra array object.

this._events[type] = listener;

}

else if(typeof this._events[type] === 'function') {

// Adding the second element, need to change to array.

this._events[type] = [this._events[type], listener];

}

else if (isArray(this._events[type])) {

// If we've already got an array, just append.

this._events[type].push(listener);

// Check for listener leak

if (!this._events[type].warned) {

var m = defaultMaxListeners;

if (typeof this._events.maxListeners !== 'undefined') {

m = this._events.maxListeners;

}

if (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);

console.trace();

}

}

}

return this;

};

EventEmitter.prototype.onAny = function(fn) {

if (typeof fn !== 'function') {

throw new Error('onAny only accepts instances of Function');

}

if(!this._all) {

this._all = [];

}

// Add the function to the event listener collection.

this._all.push(fn);

return this;

};

EventEmitter.prototype.addListener = EventEmitter.prototype.on;

EventEmitter.prototype.off = function(type, listener) {

if (typeof listener !== 'function') {

throw new Error('removeListener only takes instances of Function');

}

var handlers,leafs=[];

if(this.wildcard) {

var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();

leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);

}

else {

// does not use listeners(), so no side effect of creating _events[type]

if (!this._events[type]) return this;

handlers = this._events[type];

leafs.push({_listeners:handlers});

}

for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) {

var leaf = leafs[iLeaf];

handlers = leaf._listeners;

if (isArray(handlers)) {

var position = -1;

for (var i = 0, length = handlers.length; i < length; i++) {

if (handlers[i] === listener ||

(handlers[i].listener && handlers[i].listener === listener) ||

(handlers[i]._origin && handlers[i]._origin === listener)) {

position = i;

break;

}

}

if (position < 0) {

continue;

}

if(this.wildcard) {

leaf._listeners.splice(position, 1);

}

else {

this._events[type].splice(position, 1);

}

if (handlers.length === 0) {

if(this.wildcard) {

delete leaf._listeners;

}

else {

delete this._events[type];

}

}

return this;

}

else if (handlers === listener ||

(handlers.listener && handlers.listener === listener) ||

(handlers._origin && handlers._origin === listener)) {

if(this.wildcard) {

delete leaf._listeners;

}

else {

delete this._events[type];

}

}

}

return this;

};

EventEmitter.prototype.offAny = function(fn) {

var i = 0, l = 0, fns;

if (fn && this._all && this._all.length > 0) {

fns = this._all;

for(i = 0, l = fns.length; i < l; i++) {

if(fn === fns[i]) {

fns.splice(i, 1);

return this;

}

}

} else {

this._all = [];

}

return this;

};

EventEmitter.prototype.removeListener = EventEmitter.prototype.off;

EventEmitter.prototype.removeAllListeners = function(type) {

if (arguments.length === 0) {

!this._events || init.call(this);

return this;

}

if(this.wildcard) {

var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();

var leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);

for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) {

var leaf = leafs[iLeaf];

leaf._listeners = null;

}

}

else {

if (!this._events[type]) return this;

this._events[type] = null;

}

return this;

};

EventEmitter.prototype.listeners = function(type) {

if(this.wildcard) {

var handlers = [];

var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();

searchListenerTree.call(this, handlers, ns, this.listenerTree, 0);

return handlers;

}

this._events || init.call(this);

if (!this._events[type]) this._events[type] = [];

if (!isArray(this._events[type])) {

this._events[type] = [this._events[type]];

}

return this._events[type];

};

EventEmitter.prototype.listenersAny = function() {

if(this._all) {

return this._all;

}

else {

return [];

}

};

if (typeof define === 'function' && define.amd) {

// AMD. Register as an anonymous module.

define(function() {

return EventEmitter;

});

} else if (typeof exports === 'object') {

// CommonJS

exports.EventEmitter2 = EventEmitter;

}

else {

// Browser global.

window.EventEmitter2 = EventEmitter;

}

}();

},{}],"/Users/christianalfoni/Development/flux-react/src/RenderMixin.js":[function(require,module,exports){

var isObject = function (obj) {

return typeof obj === 'object' && obj !== null && !Array.isArray(obj);

};

var isSame = function (a, b) {

var keys = Object.keys(a);

for (var x = 0; x < keys.length; x++) {

if (!b[keys[x]] || a[keys[x]] !== b[keys[x]]) {

return false;

}

}

return true;

};

module.exports = {

update: function () {

this.setState({});

},

shouldComponentUpdate: function (nextProps, nextState) {

var currentPropsLength = this.props ? Object.keys(this.props).length : 0;

var nextPropsLength = nextProps ? Object.keys(nextProps).length : 0;

var currentStateLength = this.state ? Object.keys(this.state).length : 0;

var nextStateLength = nextState ? Object.keys(nextState).length : 0;

if (!currentPropsLength && !nextPropsLength && !currentStateLength && !nextStateLength) {

return false;

} else if (currentPropsLength !== nextPropsLength || currentStateLength !== nextStateLength) {

return true;

} else {

return !isSame(nextProps, this.props) || !isSame(nextState, this.state);

}

}

};

},{}],"/Users/christianalfoni/Development/flux-react/src/action.js":[function(require,module,exports){

/*

* ACTION

* ====================================================================================

* Creates a single function or a map of functions that when called with arguments will

* emit a "trigger" event, passing the arguments

* ====================================================================================

*/

var EventEmitter = require('eventemitter2').EventEmitter2 || require('eventemitter2');

var safeDeepClone = require('./safeDeepClone.js');

var createActionFunction = function (actionName) {

// Create the action function

var fn = function () {

// Grab all the arguments and convert to array

var args = safeDeepClone('[Circular]', [], Array.prototype.slice.call(arguments, 0));

if (!fn._events) {

throw new Error('You are triggering the action: ' + fn.handlerName + ', and nobody is listening to it yet. Remember to load up the store first');

}

// Merge arguments array with "trigger", which is the

// event that will be triggered, passing the original arguments

// as arguments to the "trigger" event

args = ['trigger'].concat(args);

fn.emit.apply(fn, args);

};

var emitter = new EventEmitter();

// It is possible to listen to the function and to achieve that we

// have to manually inherit methods from EventEmitter

for (var prop in EventEmitter.prototype) {

if (EventEmitter.prototype.hasOwnProperty(prop)) {

fn[prop] = EventEmitter.prototype[prop];

}

}

// Add handlerName

fn.handlerName = actionName;

return fn;

};

var action = function () {

if (Array.isArray(arguments[0])) {

var actionMap = {};

arguments[0].forEach(function (actionName) {

actionMap[actionName] = createActionFunction(actionName);

});

return actionMap;

}

throw new Error('You are not passing an array to createActions');

};

module.exports = action;

},{"./safeDeepClone.js":"/Users/christianalfoni/Development/flux-react/src/safeDeepClone.js","eventemitter2":"/Users/christianalfoni/Development/flux-react/node_modules/eventemitter2/lib/eventemitter2.js"}],"/Users/christianalfoni/Development/flux-react/src/main.js":[function(require,module,exports){

(function (global){

var React = global.React || require('react');

var action = require('./action.js');

var EventEmitter = require('eventemitter2').EventEmitter2 || require('eventemitter2');

var safeDeepClone = require('./safeDeepClone.js');

var RenderMixin = require('./RenderMixin.js');

var flux = {};

function mergeStore (mixins, source) {

source.actions = source.actions || [];

source.exports = source.exports || {};

if (mixins && Array.isArray(mixins)) {

// Merge mixins and state

mixins.forEach(function (mixin) {

Object.keys(mixin).forEach(function (key) {

switch(key) {

case 'mixins':

return mergeStore(mixin.mixins, mixin);

case 'actions':

source.actions = source.actions.concat(mixin.actions);

break;

case 'exports':

Object.keys(mixin.exports).forEach(function (key) {

source.exports[key] = mixin.exports[key];

});

break;

default:

if (source[key]) {

throw new Error('The property: ' + key + ', already exists. Can not merge mixin with keys: ' + Object.keys(mixin).join(', '));

}

source[key] = mixin[key];

}

});

});

}

var exports = new EventEmitter({

wildcard: true

});

source.emitChange = function () {

setTimeout(function () { // Async to avoid running within render of component

exports.emit('change');

}, 0);

};

source.emit = function () {

var args = arguments;

setTimeout(function () { // Async to avoid running within render of component

exports.emit.apply(exports, args);

}, 0);

};

exports.addChangeListener = function (callback) {

exports.on('change', callback);

};

exports.removeChangeListener = function (callback) {

exports.removeListener('change', callback);

};

// Register actions

source.actions.forEach(function (action) {

if (!action || !action.handlerName) {

throw new Error('This is not an action ' + action);

}

if (!source[action.handlerName]) {

throw new Error('There is no handler for action: ' + action);

}

action.on('trigger', source[action.handlerName].bind(source));

});

// Register exports

Object.keys(source.exports).forEach(function (key) {

exports[key] = function () {

return safeDeepClone('[Circular]', [], source.exports[key].apply(source, arguments));

};

});

return exports;

};

flux.debug = function () {

global.React = React;

};

flux.createActions = function () {

return action.apply(null, arguments);

};

flux.createStore = function (definition) {

return mergeStore(definition.mixins, definition);

};

flux.RenderMixin = RenderMixin;

// If running in global mode, expose $$

if (!global.exports && !global.module && (!global.define || !global.define.amd)) {

global.flux = flux;

}

module.exports = flux;

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{"./RenderMixin.js":"/Users/christianalfoni/Development/flux-react/src/RenderMixin.js","./action.js":"/Users/christianalfoni/Development/flux-react/src/action.js","./safeDeepClone.js":"/Users/christianalfoni/Development/flux-react/src/safeDeepClone.js","eventemitter2":"/Users/christianalfoni/Development/flux-react/node_modules/eventemitter2/lib/eventemitter2.js","react":"react"}],"/Users/christianalfoni/Development/flux-react/src/safeDeepClone.js":[function(require,module,exports){

(function (global){

function safeDeepClone(circularValue, refs, obj) {

var copy, tmp;

// object is a false or empty value, or otherwise not an object

if (!obj || "object" !== typeof obj ||

('ArrayBuffer' in global && obj instanceof ArrayBuffer) ||

('Blob' in global && obj instanceof Blob) ||

('File' in global && obj instanceof File))

{

return obj;

}

// Handle Date

if (obj instanceof Date) {

copy = new Date();

copy.setTime(obj.getTime());

return copy;

}

// Handle Array - or array-like items (Buffers)

if (obj instanceof Array || obj.length) {

refs.push(obj);

copy = [];

for (var i = 0, len = obj.length; i < len; i++) {

if (refs.indexOf(obj[i]) >= 0) {

copy[i] = circularValue;

} else {

copy[i] = safeDeepClone(circularValue, refs, obj[i]);

}

}

refs.pop();

return copy;

}

// Handle Object

refs.push(obj);

copy = {};

if (obj instanceof Error) {

//raise inherited error properties for the clone

copy.name = obj.name;

copy.message = obj.message;

copy.stack = obj.stack;

}

for (var attr in obj) {

if (obj.hasOwnProperty(attr)) {

if (refs.indexOf(obj[attr]) >= 0) {

copy[attr] = circularValue;

} else {

copy[attr] = safeDeepClone(circularValue, refs, obj[attr]);

}

}

}

refs.pop();

return copy;

}

module.exports = safeDeepClone;

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

},{}]},{},["/Users/christianalfoni/Development/flux-react/src/main.js"])("/Users/christianalfoni/Development/flux-react/src/main.js")

});

//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/eventemitter2/lib/eventemitter2.js","src/RenderMixin.js","src/action.js","src/main.js","src/safeDeepClone.js"],"names":[],"mappings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jBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AC7GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(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})","/*!\n * EventEmitter2\n * https://github.com/hij1nx/EventEmitter2\n *\n * Copyright (c) 2013 hij1nx\n * Licensed under the MIT license.\n */\n;!function(undefined) {\n\n  var isArray = Array.isArray ? Array.isArray : function _isArray(obj) {\n    return Object.prototype.toString.call(obj) === \"[object Array]\";\n  };\n  var defaultMaxListeners = 10;\n\n  function init() {\n    this._events = {};\n    if (this._conf) {\n      configure.call(this, this._conf);\n    }\n  }\n\n  function configure(conf) {\n    if (conf) {\n\n      this._conf = conf;\n\n      conf.delimiter && (this.delimiter = conf.delimiter);\n      conf.maxListeners && (this._events.maxListeners = conf.maxListeners);\n      conf.wildcard && (this.wildcard = conf.wildcard);\n      conf.newListener && (this.newListener = conf.newListener);\n\n      if (this.wildcard) {\n        this.listenerTree = {};\n      }\n    }\n  }\n\n  function EventEmitter(conf) {\n    this._events = {};\n    this.newListener = false;\n    configure.call(this, conf);\n  }\n\n  //\n  // Attention, function return type now is array, always !\n  // It has zero elements if no any matches found and one or more\n  // elements (leafs) if there are matches\n  //\n  function searchListenerTree(handlers, type, tree, i) {\n    if (!tree) {\n      return [];\n    }\n    var listeners=[], leaf, len, branch, xTree, xxTree, isolatedBranch, endReached,\n        typeLength = type.length, currentType = type[i], nextType = type[i+1];\n    if (i === typeLength && tree._listeners) {\n      //\n      // If at the end of the event(s) list and the tree has listeners\n      // invoke those listeners.\n      //\n      if (typeof tree._listeners === 'function') {\n        handlers && handlers.push(tree._listeners);\n        return [tree];\n      } else {\n        for (leaf = 0, len = tree._listeners.length; leaf < len; leaf++) {\n          handlers && handlers.push(tree._listeners[leaf]);\n        }\n        return [tree];\n      }\n    }\n\n    if ((currentType === '*' || currentType === '**') || tree[currentType]) {\n      //\n      // If the event emitted is '*' at this part\n      // or there is a concrete match at this patch\n      //\n      if (currentType === '*') {\n        for (branch in tree) {\n          if (branch !== '_listeners' && tree.hasOwnProperty(branch)) {\n            listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+1));\n          }\n        }\n        return listeners;\n      } else if(currentType === '**') {\n        endReached = (i+1 === typeLength || (i+2 === typeLength && nextType === '*'));\n        if(endReached && tree._listeners) {\n          // The next element has a _listeners, add it to the handlers.\n          listeners = listeners.concat(searchListenerTree(handlers, type, tree, typeLength));\n        }\n\n        for (branch in tree) {\n          if (branch !== '_listeners' && tree.hasOwnProperty(branch)) {\n            if(branch === '*' || branch === '**') {\n              if(tree[branch]._listeners && !endReached) {\n                listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], typeLength));\n              }\n              listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));\n            } else if(branch === nextType) {\n              listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i+2));\n            } else {\n              // No match on this one, shift into the tree but not in the type array.\n              listeners = listeners.concat(searchListenerTree(handlers, type, tree[branch], i));\n            }\n          }\n        }\n        return listeners;\n      }\n\n      listeners = listeners.concat(searchListenerTree(handlers, type, tree[currentType], i+1));\n    }\n\n    xTree = tree['*'];\n    if (xTree) {\n      //\n      // If the listener tree will allow any match for this part,\n      // then recursively explore all branches of the tree\n      //\n      searchListenerTree(handlers, type, xTree, i+1);\n    }\n\n    xxTree = tree['**'];\n    if(xxTree) {\n      if(i < typeLength) {\n        if(xxTree._listeners) {\n          // If we have a listener on a '**', it will catch all, so add its handler.\n          searchListenerTree(handlers, type, xxTree, typeLength);\n        }\n\n        // Build arrays of matching next branches and others.\n        for(branch in xxTree) {\n          if(branch !== '_listeners' && xxTree.hasOwnProperty(branch)) {\n            if(branch === nextType) {\n              // We know the next element will match, so jump twice.\n              searchListenerTree(handlers, type, xxTree[branch], i+2);\n            } else if(branch === currentType) {\n              // Current node matches, move into the tree.\n              searchListenerTree(handlers, type, xxTree[branch], i+1);\n            } else {\n              isolatedBranch = {};\n              isolatedBranch[branch] = xxTree[branch];\n              searchListenerTree(handlers, type, { '**': isolatedBranch }, i+1);\n            }\n          }\n        }\n      } else if(xxTree._listeners) {\n        // We have reached the end and still on a '**'\n        searchListenerTree(handlers, type, xxTree, typeLength);\n      } else if(xxTree['*'] && xxTree['*']._listeners) {\n        searchListenerTree(handlers, type, xxTree['*'], typeLength);\n      }\n    }\n\n    return listeners;\n  }\n\n  function growListenerTree(type, listener) {\n\n    type = typeof type === 'string' ? type.split(this.delimiter) : type.slice();\n\n    //\n    // Looks for two consecutive '**', if so, don't add the event at all.\n    //\n    for(var i = 0, len = type.length; i+1 < len; i++) {\n      if(type[i] === '**' && type[i+1] === '**') {\n        return;\n      }\n    }\n\n    var tree = this.listenerTree;\n    var name = type.shift();\n\n    while (name) {\n\n      if (!tree[name]) {\n        tree[name] = {};\n      }\n\n      tree = tree[name];\n\n      if (type.length === 0) {\n\n        if (!tree._listeners) {\n          tree._listeners = listener;\n        }\n        else if(typeof tree._listeners === 'function') {\n          tree._listeners = [tree._listeners, listener];\n        }\n        else if (isArray(tree._listeners)) {\n\n          tree._listeners.push(listener);\n\n          if (!tree._listeners.warned) {\n\n            var m = defaultMaxListeners;\n\n            if (typeof this._events.maxListeners !== 'undefined') {\n              m = this._events.maxListeners;\n            }\n\n            if (m > 0 && tree._listeners.length > m) {\n\n              tree._listeners.warned = true;\n              console.error('(node) warning: possible EventEmitter memory ' +\n                            'leak detected. %d listeners added. ' +\n                            'Use emitter.setMaxListeners() to increase limit.',\n                            tree._listeners.length);\n              console.trace();\n            }\n          }\n        }\n        return true;\n      }\n      name = type.shift();\n    }\n    return true;\n  }\n\n  // By default EventEmitters will print a warning if more than\n  // 10 listeners are added to it. This is a useful default which\n  // helps finding memory leaks.\n  //\n  // Obviously not all Emitters should be limited to 10. This function allows\n  // that to be increased. Set to zero for unlimited.\n\n  EventEmitter.prototype.delimiter = '.';\n\n  EventEmitter.prototype.setMaxListeners = function(n) {\n    this._events || init.call(this);\n    this._events.maxListeners = n;\n    if (!this._conf) this._conf = {};\n    this._conf.maxListeners = n;\n  };\n\n  EventEmitter.prototype.event = '';\n\n  EventEmitter.prototype.once = function(event, fn) {\n    this.many(event, 1, fn);\n    return this;\n  };\n\n  EventEmitter.prototype.many = function(event, ttl, fn) {\n    var self = this;\n\n    if (typeof fn !== 'function') {\n      throw new Error('many only accepts instances of Function');\n    }\n\n    function listener() {\n      if (--ttl === 0) {\n        self.off(event, listener);\n      }\n      fn.apply(this, arguments);\n    }\n\n    listener._origin = fn;\n\n    this.on(event, listener);\n\n    return self;\n  };\n\n  EventEmitter.prototype.emit = function() {\n\n    this._events || init.call(this);\n\n    var type = arguments[0];\n\n    if (type === 'newListener' && !this.newListener) {\n      if (!this._events.newListener) { return false; }\n    }\n\n    // Loop through the *_all* functions and invoke them.\n    if (this._all) {\n      var l = arguments.length;\n      var args = new Array(l - 1);\n      for (var i = 1; i < l; i++) args[i - 1] = arguments[i];\n      for (i = 0, l = this._all.length; i < l; i++) {\n        this.event = type;\n        this._all[i].apply(this, args);\n      }\n    }\n\n    // If there is no 'error' event listener then throw.\n    if (type === 'error') {\n\n      if (!this._all &&\n        !this._events.error &&\n        !(this.wildcard && this.listenerTree.error)) {\n\n        if (arguments[1] instanceof Error) {\n          throw arguments[1]; // Unhandled 'error' event\n        } else {\n          throw new Error(\"Uncaught, unspecified 'error' event.\");\n        }\n        return false;\n      }\n    }\n\n    var handler;\n\n    if(this.wildcard) {\n      handler = [];\n      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();\n      searchListenerTree.call(this, handler, ns, this.listenerTree, 0);\n    }\n    else {\n      handler = this._events[type];\n    }\n\n    if (typeof handler === 'function') {\n      this.event = type;\n      if (arguments.length === 1) {\n        handler.call(this);\n      }\n      else if (arguments.length > 1)\n        switch (arguments.length) {\n          case 2:\n            handler.call(this, arguments[1]);\n            break;\n          case 3:\n            handler.call(this, arguments[1], arguments[2]);\n            break;\n          // slower\n          default:\n            var l = arguments.length;\n            var args = new Array(l - 1);\n            for (var i = 1; i < l; i++) args[i - 1] = arguments[i];\n            handler.apply(this, args);\n        }\n      return true;\n    }\n    else if (handler) {\n      var l = arguments.length;\n      var args = new Array(l - 1);\n      for (var i = 1; i < l; i++) args[i - 1] = arguments[i];\n\n      var listeners = handler.slice();\n      for (var i = 0, l = listeners.length; i < l; i++) {\n        this.event = type;\n        listeners[i].apply(this, args);\n      }\n      return (listeners.length > 0) || !!this._all;\n    }\n    else {\n      return !!this._all;\n    }\n\n  };\n\n  EventEmitter.prototype.on = function(type, listener) {\n\n    if (typeof type === 'function') {\n      this.onAny(type);\n      return this;\n    }\n\n    if (typeof listener !== 'function') {\n      throw new Error('on only accepts instances of Function');\n    }\n    this._events || init.call(this);\n\n    // To avoid recursion in the case that type == \"newListeners\"! Before\n    // adding it to the listeners, first emit \"newListeners\".\n    this.emit('newListener', type, listener);\n\n    if(this.wildcard) {\n      growListenerTree.call(this, type, listener);\n      return this;\n    }\n\n    if (!this._events[type]) {\n      // Optimize the case of one listener. Don't need the extra array object.\n      this._events[type] = listener;\n    }\n    else if(typeof this._events[type] === 'function') {\n      // Adding the second element, need to change to array.\n      this._events[type] = [this._events[type], listener];\n    }\n    else if (isArray(this._events[type])) {\n      // If we've already got an array, just append.\n      this._events[type].push(listener);\n\n      // Check for listener leak\n      if (!this._events[type].warned) {\n\n        var m = defaultMaxListeners;\n\n        if (typeof this._events.maxListeners !== 'undefined') {\n          m = this._events.maxListeners;\n        }\n\n        if (m > 0 && this._events[type].length > m) {\n\n          this._events[type].warned = true;\n          console.error('(node) warning: possible EventEmitter memory ' +\n                        'leak detected. %d listeners added. ' +\n                        'Use emitter.setMaxListeners() to increase limit.',\n                        this._events[type].length);\n          console.trace();\n        }\n      }\n    }\n    return this;\n  };\n\n  EventEmitter.prototype.onAny = function(fn) {\n\n    if (typeof fn !== 'function') {\n      throw new Error('onAny only accepts instances of Function');\n    }\n\n    if(!this._all) {\n      this._all = [];\n    }\n\n    // Add the function to the event listener collection.\n    this._all.push(fn);\n    return this;\n  };\n\n  EventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n  EventEmitter.prototype.off = function(type, listener) {\n    if (typeof listener !== 'function') {\n      throw new Error('removeListener only takes instances of Function');\n    }\n\n    var handlers,leafs=[];\n\n    if(this.wildcard) {\n      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();\n      leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);\n    }\n    else {\n      // does not use listeners(), so no side effect of creating _events[type]\n      if (!this._events[type]) return this;\n      handlers = this._events[type];\n      leafs.push({_listeners:handlers});\n    }\n\n    for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) {\n      var leaf = leafs[iLeaf];\n      handlers = leaf._listeners;\n      if (isArray(handlers)) {\n\n        var position = -1;\n\n        for (var i = 0, length = handlers.length; i < length; i++) {\n          if (handlers[i] === listener ||\n            (handlers[i].listener && handlers[i].listener === listener) ||\n            (handlers[i]._origin && handlers[i]._origin === listener)) {\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0) {\n          continue;\n        }\n\n        if(this.wildcard) {\n          leaf._listeners.splice(position, 1);\n        }\n        else {\n          this._events[type].splice(position, 1);\n        }\n\n        if (handlers.length === 0) {\n          if(this.wildcard) {\n            delete leaf._listeners;\n          }\n          else {\n            delete this._events[type];\n          }\n        }\n        return this;\n      }\n      else if (handlers === listener ||\n        (handlers.listener && handlers.listener === listener) ||\n        (handlers._origin && handlers._origin === listener)) {\n        if(this.wildcard) {\n          delete leaf._listeners;\n        }\n        else {\n          delete this._events[type];\n        }\n      }\n    }\n\n    return this;\n  };\n\n  EventEmitter.prototype.offAny = function(fn) {\n    var i = 0, l = 0, fns;\n    if (fn && this._all && this._all.length > 0) {\n      fns = this._all;\n      for(i = 0, l = fns.length; i < l; i++) {\n        if(fn === fns[i]) {\n          fns.splice(i, 1);\n          return this;\n        }\n      }\n    } else {\n      this._all = [];\n    }\n    return this;\n  };\n\n  EventEmitter.prototype.removeListener = EventEmitter.prototype.off;\n\n  EventEmitter.prototype.removeAllListeners = function(type) {\n    if (arguments.length === 0) {\n      !this._events || init.call(this);\n      return this;\n    }\n\n    if(this.wildcard) {\n      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();\n      var leafs = searchListenerTree.call(this, null, ns, this.listenerTree, 0);\n\n      for (var iLeaf=0; iLeaf<leafs.length; iLeaf++) {\n        var leaf = leafs[iLeaf];\n        leaf._listeners = null;\n      }\n    }\n    else {\n      if (!this._events[type]) return this;\n      this._events[type] = null;\n    }\n    return this;\n  };\n\n  EventEmitter.prototype.listeners = function(type) {\n    if(this.wildcard) {\n      var handlers = [];\n      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();\n      searchListenerTree.call(this, handlers, ns, this.listenerTree, 0);\n      return handlers;\n    }\n\n    this._events || init.call(this);\n\n    if (!this._events[type]) this._events[type] = [];\n    if (!isArray(this._events[type])) {\n      this._events[type] = [this._events[type]];\n    }\n    return this._events[type];\n  };\n\n  EventEmitter.prototype.listenersAny = function() {\n\n    if(this._all) {\n      return this._all;\n    }\n    else {\n      return [];\n    }\n\n  };\n\n  if (typeof define === 'function' && define.amd) {\n     // AMD. Register as an anonymous module.\n    define(function() {\n      return EventEmitter;\n    });\n  } else if (typeof exports === 'object') {\n    // CommonJS\n    exports.EventEmitter2 = EventEmitter;\n  }\n  else {\n    // Browser global.\n    window.EventEmitter2 = EventEmitter;\n  }\n}();\n","var isObject = function (obj) {\n  return typeof obj === 'object' && obj !== null && !Array.isArray(obj);\n};\n\nvar isSame = function (a, b) {\n  var keys = Object.keys(a);\n  for (var x = 0; x < keys.length; x++) {\n    if (!b[keys[x]] || a[keys[x]] !== b[keys[x]]) {\n      return false;\n    }\n  }\n  return true;\n};\n\nmodule.exports = {\n  update: function () {\n    this.setState({});\n  },\n  shouldComponentUpdate: function (nextProps, nextState) {\n    \n    var currentPropsLength = this.props ? Object.keys(this.props).length : 0; \n    var nextPropsLength = nextProps ? Object.keys(nextProps).length : 0;\n    var currentStateLength = this.state ? Object.keys(this.state).length : 0;\n    var nextStateLength = nextState ? Object.keys(nextState).length : 0;\n\n    if (!currentPropsLength && !nextPropsLength && !currentStateLength && !nextStateLength) {\n      return false;\n    } else if (currentPropsLength !== nextPropsLength || currentStateLength !== nextStateLength) {\n      return true;\n    } else {\n      return !isSame(nextProps, this.props) || !isSame(nextState, this.state);\n    }\n\n  }\n};\n","/*\n * ACTION\n * ====================================================================================\n * Creates a single function or a map of functions that when called with arguments will\n * emit a \"trigger\" event, passing the arguments\n * ====================================================================================\n */\n\nvar EventEmitter = require('eventemitter2').EventEmitter2 || require('eventemitter2');\nvar safeDeepClone = require('./safeDeepClone.js');\n\nvar createActionFunction = function (actionName) {\n\n  // Create the action function\n  var fn = function () {\n\n    // Grab all the arguments and convert to array\n    var args = safeDeepClone('[Circular]', [], Array.prototype.slice.call(arguments, 0));\n\n    if (!fn._events) {\n      throw new Error('You are triggering the action: ' + fn.handlerName + ', and nobody is listening to it yet. Remember to load up the store first');\n    }\n\n    // Merge arguments array with \"trigger\", which is the\n    // event that will be triggered, passing the original arguments\n    // as arguments to the \"trigger\" event\n    args = ['trigger'].concat(args);\n    fn.emit.apply(fn, args);\n\n  };\n\n  var emitter = new EventEmitter();\n\n  // It is possible to listen to the function and to achieve that we\n  // have to manually inherit methods from EventEmitter\n  for (var prop in EventEmitter.prototype) {\n    if (EventEmitter.prototype.hasOwnProperty(prop)) {\n      fn[prop] = EventEmitter.prototype[prop];\n    }\n  }\n  \n  // Add handlerName\n  fn.handlerName = actionName;\n\n  return fn;\n\n};\n\nvar action = function () {\n\n  if (Array.isArray(arguments[0])) {\n    var actionMap = {};\n    arguments[0].forEach(function (actionName) {\n      actionMap[actionName] = createActionFunction(actionName);\n    });\n    return actionMap;\n  }\n\n  throw new Error('You are not passing an array to createActions');\n\n};\n\nmodule.exports = action;\n","var React = global.React || require('react');\nvar action = require('./action.js');\nvar EventEmitter = require('eventemitter2').EventEmitter2 || require('eventemitter2');\nvar safeDeepClone = require('./safeDeepClone.js');\nvar RenderMixin = require('./RenderMixin.js');\n\nvar flux = {};\n\nfunction mergeStore (mixins, source) {\n\n  source.actions = source.actions || [];\n  source.exports = source.exports || {};\n\n  if (mixins && Array.isArray(mixins)) {\n\n    // Merge mixins and state\n    mixins.forEach(function (mixin) {\n      Object.keys(mixin).forEach(function (key) {\n\n        switch(key) {\n          case 'mixins':\n            return mergeStore(mixin.mixins, mixin);\n          case 'actions':\n            source.actions = source.actions.concat(mixin.actions);\n            break;\n          case 'exports':\n            Object.keys(mixin.exports).forEach(function (key) {\n              source.exports[key] = mixin.exports[key];\n            });\n            break;\n          default:\n            if (source[key]) {\n              throw new Error('The property: ' + key + ', already exists. Can not merge mixin with keys: ' + Object.keys(mixin).join(', '));\n            }\n            source[key] = mixin[key];\n        }\n\n      });\n    });\n\n  }\n\n  var exports = new EventEmitter({\n    wildcard: true\n  });\n\n  source.emitChange = function () {\n    setTimeout(function () { // Async to avoid running within render of component\n      exports.emit('change');\n    }, 0);\n  };\n\n  source.emit = function () {\n    var args = arguments;\n    setTimeout(function () { // Async to avoid running within render of component\n      exports.emit.apply(exports, args);\n    }, 0);\n  };\n\n  exports.addChangeListener = function (callback) {\n    exports.on('change', callback);\n  };\n\n  exports.removeChangeListener = function (callback) {\n    exports.removeListener('change', callback);\n  };\n\n  // Register actions\n  source.actions.forEach(function (action) {\n    if (!action || !action.handlerName) {\n      throw new Error('This is not an action ' + action);\n    }\n    if (!source[action.handlerName]) {\n      throw new Error('There is no handler for action: ' + action);\n    }\n    action.on('trigger', source[action.handlerName].bind(source));\n  });\n\n  // Register exports\n  Object.keys(source.exports).forEach(function (key) {\n    exports[key] = function () {\n      return safeDeepClone('[Circular]', [], source.exports[key].apply(source, arguments));\n    };\n  });\n\n  return exports;\n\n};\n\nflux.debug = function () {\n  global.React = React;\n};\n\nflux.createActions = function () {\n  return action.apply(null, arguments);\n};\n\nflux.createStore = function (definition) {\n  return mergeStore(definition.mixins, definition);\n};\n\nflux.RenderMixin = RenderMixin;\n\n// If running in global mode, expose $$\nif (!global.exports && !global.module && (!global.define || !global.define.amd)) {\n  global.flux = flux;\n}\n\nmodule.exports = flux;\n","function safeDeepClone(circularValue, refs, obj) {\n  var copy, tmp;\n\n  // object is a false or empty value, or otherwise not an object\n  if (!obj || \"object\" !== typeof obj ||\n    ('ArrayBuffer' in global && obj instanceof ArrayBuffer) ||\n    ('Blob' in global && obj instanceof Blob) ||\n    ('File' in global && obj instanceof File))\n  {\n    return obj;\n  }\n\n  // Handle Date\n  if (obj instanceof Date) {\n    copy = new Date();\n    copy.setTime(obj.getTime());\n    return copy;\n  }\n\n  // Handle Array - or array-like items (Buffers)\n  if (obj instanceof Array || obj.length) {\n    \n    refs.push(obj);\n    copy = [];\n    for (var i = 0, len = obj.length; i < len; i++) {\n      if (refs.indexOf(obj[i]) >= 0) {\n        copy[i] = circularValue;\n      } else {\n        copy[i] = safeDeepClone(circularValue, refs, obj[i]);\n      }\n    }\n    refs.pop();\n    return copy;\n  }\n\n  // Handle Object\n  refs.push(obj);\n  copy = {};\n\n  if (obj instanceof Error) {\n    //raise inherited error properties for the clone\n    copy.name = obj.name;\n    copy.message = obj.message;\n    copy.stack = obj.stack;\n  }\n\n  for (var attr in obj) {\n    if (obj.hasOwnProperty(attr)) {\n      if (refs.indexOf(obj[attr]) >= 0) {\n        copy[attr] = circularValue;\n      } else {\n        copy[attr] = safeDeepClone(circularValue, refs, obj[attr]);\n      }\n    }\n  }\n  refs.pop();\n  return copy;\n}\n\nmodule.exports = safeDeepClone;"]}