sequenceserver 2.0.0 → 2.2.0

data/public/vendor/npm/react@0.13.3/lib/ReactTransitionEvents.js

@@ -1,68 +0,0 @@
-/* */ 
-'use strict';
-var ExecutionEnvironment = require("./ExecutionEnvironment");
-var EVENT_NAME_MAP = {
-  transitionend: {
-    'transition': 'transitionend',
-    'WebkitTransition': 'webkitTransitionEnd',
-    'MozTransition': 'mozTransitionEnd',
-    'OTransition': 'oTransitionEnd',
-    'msTransition': 'MSTransitionEnd'
-  },
-  animationend: {
-    'animation': 'animationend',
-    'WebkitAnimation': 'webkitAnimationEnd',
-    'MozAnimation': 'mozAnimationEnd',
-    'OAnimation': 'oAnimationEnd',
-    'msAnimation': 'MSAnimationEnd'
-  }
-};
-var endEvents = [];
-function detectEvents() {
-  var testEl = document.createElement('div');
-  var style = testEl.style;
-  if (!('AnimationEvent' in window)) {
-    delete EVENT_NAME_MAP.animationend.animation;
-  }
-  if (!('TransitionEvent' in window)) {
-    delete EVENT_NAME_MAP.transitionend.transition;
-  }
-  for (var baseEventName in EVENT_NAME_MAP) {
-    var baseEvents = EVENT_NAME_MAP[baseEventName];
-    for (var styleName in baseEvents) {
-      if (styleName in style) {
-        endEvents.push(baseEvents[styleName]);
-        break;
-      }
-    }
-  }
-}
-if (ExecutionEnvironment.canUseDOM) {
-  detectEvents();
-}
-function addEventListener(node, eventName, eventListener) {
-  node.addEventListener(eventName, eventListener, false);
-}
-function removeEventListener(node, eventName, eventListener) {
-  node.removeEventListener(eventName, eventListener, false);
-}
-var ReactTransitionEvents = {
-  addEndEventListener: function(node, eventListener) {
-    if (endEvents.length === 0) {
-      window.setTimeout(eventListener, 0);
-      return;
-    }
-    endEvents.forEach(function(endEvent) {
-      addEventListener(node, endEvent, eventListener);
-    });
-  },
-  removeEndEventListener: function(node, eventListener) {
-    if (endEvents.length === 0) {
-      return;
-    }
-    endEvents.forEach(function(endEvent) {
-      removeEventListener(node, endEvent, eventListener);
-    });
-  }
-};
-module.exports = ReactTransitionEvents;

data/public/vendor/npm/react@0.13.3/lib/ReactTransitionGroup.js

@@ -1,140 +0,0 @@
-/* */ 
-'use strict';
-var React = require("./React");
-var ReactTransitionChildMapping = require("./ReactTransitionChildMapping");
-var assign = require("./Object.assign");
-var cloneWithProps = require("./cloneWithProps");
-var emptyFunction = require("./emptyFunction");
-var ReactTransitionGroup = React.createClass({
-  displayName: 'ReactTransitionGroup',
-  propTypes: {
-    component: React.PropTypes.any,
-    childFactory: React.PropTypes.func
-  },
-  getDefaultProps: function() {
-    return {
-      component: 'span',
-      childFactory: emptyFunction.thatReturnsArgument
-    };
-  },
-  getInitialState: function() {
-    return {children: ReactTransitionChildMapping.getChildMapping(this.props.children)};
-  },
-  componentWillMount: function() {
-    this.currentlyTransitioningKeys = {};
-    this.keysToEnter = [];
-    this.keysToLeave = [];
-  },
-  componentDidMount: function() {
-    var initialChildMapping = this.state.children;
-    for (var key in initialChildMapping) {
-      if (initialChildMapping[key]) {
-        this.performAppear(key);
-      }
-    }
-  },
-  componentWillReceiveProps: function(nextProps) {
-    var nextChildMapping = ReactTransitionChildMapping.getChildMapping(nextProps.children);
-    var prevChildMapping = this.state.children;
-    this.setState({children: ReactTransitionChildMapping.mergeChildMappings(prevChildMapping, nextChildMapping)});
-    var key;
-    for (key in nextChildMapping) {
-      var hasPrev = prevChildMapping && prevChildMapping.hasOwnProperty(key);
-      if (nextChildMapping[key] && !hasPrev && !this.currentlyTransitioningKeys[key]) {
-        this.keysToEnter.push(key);
-      }
-    }
-    for (key in prevChildMapping) {
-      var hasNext = nextChildMapping && nextChildMapping.hasOwnProperty(key);
-      if (prevChildMapping[key] && !hasNext && !this.currentlyTransitioningKeys[key]) {
-        this.keysToLeave.push(key);
-      }
-    }
-  },
-  componentDidUpdate: function() {
-    var keysToEnter = this.keysToEnter;
-    this.keysToEnter = [];
-    keysToEnter.forEach(this.performEnter);
-    var keysToLeave = this.keysToLeave;
-    this.keysToLeave = [];
-    keysToLeave.forEach(this.performLeave);
-  },
-  performAppear: function(key) {
-    this.currentlyTransitioningKeys[key] = true;
-    var component = this.refs[key];
-    if (component.componentWillAppear) {
-      component.componentWillAppear(this._handleDoneAppearing.bind(this, key));
-    } else {
-      this._handleDoneAppearing(key);
-    }
-  },
-  _handleDoneAppearing: function(key) {
-    var component = this.refs[key];
-    if (component.componentDidAppear) {
-      component.componentDidAppear();
-    }
-    delete this.currentlyTransitioningKeys[key];
-    var currentChildMapping = ReactTransitionChildMapping.getChildMapping(this.props.children);
-    if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
-      this.performLeave(key);
-    }
-  },
-  performEnter: function(key) {
-    this.currentlyTransitioningKeys[key] = true;
-    var component = this.refs[key];
-    if (component.componentWillEnter) {
-      component.componentWillEnter(this._handleDoneEntering.bind(this, key));
-    } else {
-      this._handleDoneEntering(key);
-    }
-  },
-  _handleDoneEntering: function(key) {
-    var component = this.refs[key];
-    if (component.componentDidEnter) {
-      component.componentDidEnter();
-    }
-    delete this.currentlyTransitioningKeys[key];
-    var currentChildMapping = ReactTransitionChildMapping.getChildMapping(this.props.children);
-    if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
-      this.performLeave(key);
-    }
-  },
-  performLeave: function(key) {
-    this.currentlyTransitioningKeys[key] = true;
-    var component = this.refs[key];
-    if (component.componentWillLeave) {
-      component.componentWillLeave(this._handleDoneLeaving.bind(this, key));
-    } else {
-      this._handleDoneLeaving(key);
-    }
-  },
-  _handleDoneLeaving: function(key) {
-    var component = this.refs[key];
-    if (component.componentDidLeave) {
-      component.componentDidLeave();
-    }
-    delete this.currentlyTransitioningKeys[key];
-    var currentChildMapping = ReactTransitionChildMapping.getChildMapping(this.props.children);
-    if (currentChildMapping && currentChildMapping.hasOwnProperty(key)) {
-      this.performEnter(key);
-    } else {
-      var newChildren = assign({}, this.state.children);
-      delete newChildren[key];
-      this.setState({children: newChildren});
-    }
-  },
-  render: function() {
-    var childrenToRender = [];
-    for (var key in this.state.children) {
-      var child = this.state.children[key];
-      if (child) {
-        childrenToRender.push(cloneWithProps(this.props.childFactory(child), {
-          ref: key,
-          key: key
-        }));
-      }
-    }
-    return React.createElement(this.props.component, this.props, childrenToRender);
-  }
-});
-module.exports = ReactTransitionGroup;

data/public/vendor/npm/react@0.13.3/lib/ReactUpdateQueue.js

@@ -1,107 +0,0 @@
-/* */ 
-(function(process) {
-  '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) {
-    ("production" !== process.env.NODE_ENV ? 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) : invariant(ReactCurrentOwner.current == null));
-    var internalInstance = ReactInstanceMap.get(publicInstance);
-    if (!internalInstance) {
-      if ("production" !== process.env.NODE_ENV) {
-        ("production" !== process.env.NODE_ENV ? 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) : null);
-      }
-      return null;
-    }
-    if (internalInstance === ReactLifeCycle.currentlyUnmountingInstance) {
-      return null;
-    }
-    return internalInstance;
-  }
-  var ReactUpdateQueue = {
-    enqueueCallback: function(publicInstance, callback) {
-      ("production" !== process.env.NODE_ENV ? invariant(typeof callback === 'function', 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn\'t callable.') : invariant(typeof callback === 'function'));
-      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) {
-      ("production" !== process.env.NODE_ENV ? invariant(typeof callback === 'function', 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn\'t callable.') : invariant(typeof callback === 'function'));
-      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;
-      }
-      ("production" !== process.env.NODE_ENV ? 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.') : invariant(internalInstance._isTopLevel));
-      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;
-      }
-      ("production" !== process.env.NODE_ENV ? 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.') : invariant(internalInstance._isTopLevel));
-      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;
-})(require("process"));

data/public/vendor/npm/react@0.13.3/lib/ReactUpdates.js

@@ -1,139 +0,0 @@
-/* */ 
-(function(process) {
-  '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() {
-    ("production" !== process.env.NODE_ENV ? invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy, 'ReactUpdates: must inject a reconcile transaction class and batching ' + 'strategy') : invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy));
-  }
-  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;
-    ("production" !== process.env.NODE_ENV ? invariant(len === dirtyComponents.length, 'Expected flush transaction\'s stored dirty-components length (%s) to ' + 'match dirty-components array length (%s).', len, dirtyComponents.length) : invariant(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();
-    ("production" !== process.env.NODE_ENV ? 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.') : null);
-    if (!batchingStrategy.isBatchingUpdates) {
-      batchingStrategy.batchedUpdates(enqueueUpdate, component);
-      return;
-    }
-    dirtyComponents.push(component);
-  }
-  function asap(callback, context) {
-    ("production" !== process.env.NODE_ENV ? invariant(batchingStrategy.isBatchingUpdates, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context where' + 'updates are not being batched.') : invariant(batchingStrategy.isBatchingUpdates));
-    asapCallbackQueue.enqueue(callback, context);
-    asapEnqueued = true;
-  }
-  var ReactUpdatesInjection = {
-    injectReconcileTransaction: function(ReconcileTransaction) {
-      ("production" !== process.env.NODE_ENV ? invariant(ReconcileTransaction, 'ReactUpdates: must provide a reconcile transaction class') : invariant(ReconcileTransaction));
-      ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
-    },
-    injectBatchingStrategy: function(_batchingStrategy) {
-      ("production" !== process.env.NODE_ENV ? invariant(_batchingStrategy, 'ReactUpdates: must provide a batching strategy') : invariant(_batchingStrategy));
-      ("production" !== process.env.NODE_ENV ? invariant(typeof _batchingStrategy.batchedUpdates === 'function', 'ReactUpdates: must provide a batchedUpdates() function') : invariant(typeof _batchingStrategy.batchedUpdates === 'function'));
-      ("production" !== process.env.NODE_ENV ? invariant(typeof _batchingStrategy.isBatchingUpdates === 'boolean', 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : invariant(typeof _batchingStrategy.isBatchingUpdates === 'boolean'));
-      batchingStrategy = _batchingStrategy;
-    }
-  };
-  var ReactUpdates = {
-    ReactReconcileTransaction: null,
-    batchedUpdates: batchedUpdates,
-    enqueueUpdate: enqueueUpdate,
-    flushBatchedUpdates: flushBatchedUpdates,
-    injection: ReactUpdatesInjection,
-    asap: asap
-  };
-  module.exports = ReactUpdates;
-})(require("process"));

data/public/vendor/npm/react@0.13.3/lib/ReactWithAddons.js

@@ -1,30 +0,0 @@
-/* */ 
-(function(process) {
-  'use strict';
-  var LinkedStateMixin = require("./LinkedStateMixin");
-  var React = require("./React");
-  var ReactComponentWithPureRenderMixin = require("./ReactComponentWithPureRenderMixin");
-  var ReactCSSTransitionGroup = require("./ReactCSSTransitionGroup");
-  var ReactFragment = require("./ReactFragment");
-  var ReactTransitionGroup = require("./ReactTransitionGroup");
-  var ReactUpdates = require("./ReactUpdates");
-  var cx = require("./cx");
-  var cloneWithProps = require("./cloneWithProps");
-  var update = require("./update");
-  React.addons = {
-    CSSTransitionGroup: ReactCSSTransitionGroup,
-    LinkedStateMixin: LinkedStateMixin,
-    PureRenderMixin: ReactComponentWithPureRenderMixin,
-    TransitionGroup: ReactTransitionGroup,
-    batchedUpdates: ReactUpdates.batchedUpdates,
-    classSet: cx,
-    cloneWithProps: cloneWithProps,
-    createFragment: ReactFragment.create,
-    update: update
-  };
-  if ("production" !== process.env.NODE_ENV) {
-    React.addons.Perf = require("./ReactDefaultPerf");
-    React.addons.TestUtils = require("./ReactTestUtils");
-  }
-  module.exports = React;
-})(require("process"));

data/public/vendor/npm/react@0.13.3/lib/SVGDOMPropertyConfig.js

@@ -1,76 +0,0 @@
-/* */ 
-'use strict';
-var DOMProperty = require("./DOMProperty");
-var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;
-var SVGDOMPropertyConfig = {
-  Properties: {
-    clipPath: MUST_USE_ATTRIBUTE,
-    cx: MUST_USE_ATTRIBUTE,
-    cy: MUST_USE_ATTRIBUTE,
-    d: MUST_USE_ATTRIBUTE,
-    dx: MUST_USE_ATTRIBUTE,
-    dy: MUST_USE_ATTRIBUTE,
-    fill: MUST_USE_ATTRIBUTE,
-    fillOpacity: MUST_USE_ATTRIBUTE,
-    fontFamily: MUST_USE_ATTRIBUTE,
-    fontSize: MUST_USE_ATTRIBUTE,
-    fx: MUST_USE_ATTRIBUTE,
-    fy: MUST_USE_ATTRIBUTE,
-    gradientTransform: MUST_USE_ATTRIBUTE,
-    gradientUnits: MUST_USE_ATTRIBUTE,
-    markerEnd: MUST_USE_ATTRIBUTE,
-    markerMid: MUST_USE_ATTRIBUTE,
-    markerStart: MUST_USE_ATTRIBUTE,
-    offset: MUST_USE_ATTRIBUTE,
-    opacity: MUST_USE_ATTRIBUTE,
-    patternContentUnits: MUST_USE_ATTRIBUTE,
-    patternUnits: MUST_USE_ATTRIBUTE,
-    points: MUST_USE_ATTRIBUTE,
-    preserveAspectRatio: MUST_USE_ATTRIBUTE,
-    r: MUST_USE_ATTRIBUTE,
-    rx: MUST_USE_ATTRIBUTE,
-    ry: MUST_USE_ATTRIBUTE,
-    spreadMethod: MUST_USE_ATTRIBUTE,
-    stopColor: MUST_USE_ATTRIBUTE,
-    stopOpacity: MUST_USE_ATTRIBUTE,
-    stroke: MUST_USE_ATTRIBUTE,
-    strokeDasharray: MUST_USE_ATTRIBUTE,
-    strokeLinecap: MUST_USE_ATTRIBUTE,
-    strokeOpacity: MUST_USE_ATTRIBUTE,
-    strokeWidth: MUST_USE_ATTRIBUTE,
-    textAnchor: MUST_USE_ATTRIBUTE,
-    transform: MUST_USE_ATTRIBUTE,
-    version: MUST_USE_ATTRIBUTE,
-    viewBox: MUST_USE_ATTRIBUTE,
-    x1: MUST_USE_ATTRIBUTE,
-    x2: MUST_USE_ATTRIBUTE,
-    x: MUST_USE_ATTRIBUTE,
-    y1: MUST_USE_ATTRIBUTE,
-    y2: MUST_USE_ATTRIBUTE,
-    y: MUST_USE_ATTRIBUTE
-  },
-  DOMAttributeNames: {
-    clipPath: 'clip-path',
-    fillOpacity: 'fill-opacity',
-    fontFamily: 'font-family',
-    fontSize: 'font-size',
-    gradientTransform: 'gradientTransform',
-    gradientUnits: 'gradientUnits',
-    markerEnd: 'marker-end',
-    markerMid: 'marker-mid',
-    markerStart: 'marker-start',
-    patternContentUnits: 'patternContentUnits',
-    patternUnits: 'patternUnits',
-    preserveAspectRatio: 'preserveAspectRatio',
-    spreadMethod: 'spreadMethod',
-    stopColor: 'stop-color',
-    stopOpacity: 'stop-opacity',
-    strokeDasharray: 'stroke-dasharray',
-    strokeLinecap: 'stroke-linecap',
-    strokeOpacity: 'stroke-opacity',
-    strokeWidth: 'stroke-width',
-    textAnchor: 'text-anchor',
-    viewBox: 'viewBox'
-  }
-};
-module.exports = SVGDOMPropertyConfig;

data/public/vendor/npm/react@0.13.3/lib/SelectEventPlugin.js

@@ -1,91 +0,0 @@
-/* */ 
-'use strict';
-var EventConstants = require("./EventConstants");
-var EventPropagators = require("./EventPropagators");
-var ReactInputSelection = require("./ReactInputSelection");
-var SyntheticEvent = require("./SyntheticEvent");
-var getActiveElement = require("./getActiveElement");
-var isTextInputElement = require("./isTextInputElement");
-var keyOf = require("./keyOf");
-var shallowEqual = require("./shallowEqual");
-var topLevelTypes = EventConstants.topLevelTypes;
-var eventTypes = {select: {
-    phasedRegistrationNames: {
-      bubbled: keyOf({onSelect: null}),
-      captured: keyOf({onSelectCapture: null})
-    },
-    dependencies: [topLevelTypes.topBlur, topLevelTypes.topContextMenu, topLevelTypes.topFocus, topLevelTypes.topKeyDown, topLevelTypes.topMouseDown, topLevelTypes.topMouseUp, topLevelTypes.topSelectionChange]
-  }};
-var activeElement = null;
-var activeElementID = null;
-var lastSelection = null;
-var mouseDown = false;
-function getSelection(node) {
-  if ('selectionStart' in node && ReactInputSelection.hasSelectionCapabilities(node)) {
-    return {
-      start: node.selectionStart,
-      end: node.selectionEnd
-    };
-  } else if (window.getSelection) {
-    var selection = window.getSelection();
-    return {
-      anchorNode: selection.anchorNode,
-      anchorOffset: selection.anchorOffset,
-      focusNode: selection.focusNode,
-      focusOffset: selection.focusOffset
-    };
-  } else if (document.selection) {
-    var range = document.selection.createRange();
-    return {
-      parentElement: range.parentElement(),
-      text: range.text,
-      top: range.boundingTop,
-      left: range.boundingLeft
-    };
-  }
-}
-function constructSelectEvent(nativeEvent) {
-  if (mouseDown || activeElement == null || activeElement !== getActiveElement()) {
-    return null;
-  }
-  var currentSelection = getSelection(activeElement);
-  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {
-    lastSelection = currentSelection;
-    var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementID, nativeEvent);
-    syntheticEvent.type = 'select';
-    syntheticEvent.target = activeElement;
-    EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);
-    return syntheticEvent;
-  }
-}
-var SelectEventPlugin = {
-  eventTypes: eventTypes,
-  extractEvents: function(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent) {
-    switch (topLevelType) {
-      case topLevelTypes.topFocus:
-        if (isTextInputElement(topLevelTarget) || topLevelTarget.contentEditable === 'true') {
-          activeElement = topLevelTarget;
-          activeElementID = topLevelTargetID;
-          lastSelection = null;
-        }
-        break;
-      case topLevelTypes.topBlur:
-        activeElement = null;
-        activeElementID = null;
-        lastSelection = null;
-        break;
-      case topLevelTypes.topMouseDown:
-        mouseDown = true;
-        break;
-      case topLevelTypes.topContextMenu:
-      case topLevelTypes.topMouseUp:
-        mouseDown = false;
-        return constructSelectEvent(nativeEvent);
-      case topLevelTypes.topSelectionChange:
-      case topLevelTypes.topKeyDown:
-      case topLevelTypes.topKeyUp:
-        return constructSelectEvent(nativeEvent);
-    }
-  }
-};
-module.exports = SelectEventPlugin;

data/public/vendor/npm/react@0.13.3/lib/ServerReactRootIndex.js

@@ -1,29 +0,0 @@
-/**
- * Copyright 2013-2015, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
- *
- * @providesModule ServerReactRootIndex
- * @typechecks
- */
-
-'use strict';
-
-/**
- * Size of the reactRoot ID space. We generate random numbers for React root
- * IDs and if there's a collision the events and DOM update system will
- * get confused. In the future we need a way to generate GUIDs but for
- * now this will work on a smaller scale.
- */
-var GLOBAL_MOUNT_POINT_MAX = Math.pow(2, 53);
-
-var ServerReactRootIndex = {
-  createReactRootIndex: function() {
-    return Math.ceil(Math.random() * GLOBAL_MOUNT_POINT_MAX);
-  }
-};
-
-module.exports = ServerReactRootIndex;