{"version":3,"sources":["webpack:///webpack/bootstrap c03759af578f67a86090","webpack:///./packages/rax/src/index.js","webpack:///./packages/rax/src/element.js","webpack:///./packages/rax/src/vdom/host.js","webpack:///./packages/universal-env/lib/index.js","webpack:///./packages/rax/src/driver.js","webpack:///./packages/rax/src/drivers/weex.js","webpack:///./packages/rax/src/setNativeProps.js","webpack:///./packages/rax/src/findDOMNode.js","webpack:///./packages/rax/src/style/unit.js","webpack:///./packages/rax/src/drivers/browser.js","webpack:///./packages/rax/src/style/flexbox.js","webpack:///./packages/rax/src/debug/devtools.js","webpack:///./packages/rax/src/debug/hook.js","webpack:///./packages/rax/src/vdom/instance.js","webpack:///./packages/rax/src/unmountComponentAtNode.js","webpack:///./packages/rax/src/vdom/instantiateComponent.js","webpack:///./packages/rax/src/vdom/shouldUpdateComponent.js","webpack:///./packages/rax/src/vdom/root.js","webpack:///./packages/rax/src/component.js","webpack:///./packages/rax/src/purecomponent.js","webpack:///./packages/rax/src/proptypes.js","webpack:///./packages/rax/src/render.js","webpack:///./packages/rax/src/vdom/injectComponent.js","webpack:///./packages/rax/src/vdom/empty.js","webpack:///./packages/rax/src/vdom/native.js","webpack:///./packages/rax/src/vdom/ref.js","webpack:///./packages/rax/src/vdom/getElementKeyName.js","webpack:///./packages/rax/src/vdom/text.js","webpack:///./packages/rax/src/vdom/composite.js","webpack:///./packages/rax/src/vdom/stateless.js","webpack:///./packages/rax/src/vdom/updater.js","webpack:///./packages/rax/src/vdom/shallowEqual.js","webpack:///./packages/rax/src/vdom/fragment.js","webpack:///./packages/rax/src/findComponentInstance.js","webpack:///./packages/rax/src/version.js"],"names":["createElement","cloneElement","isValidElement","createFactory","setDriver","getDriver","Component","PureComponent","PropTypes","render","findDOMNode","unmountComponentAtNode","findComponentInstance","setNativeProps","version","RESERVED_PROPS","key","ref","getRenderErrorInfo","component","name","getName","Element","type","props","owner","filterProps","_owner","traverseChildren","children","result","Array","isArray","i","l","length","push","flattenChildren","flattenStyle","style","undefined","computedStyle","value","join","config","Error","propName","String","hasOwnProperty","defaultProps","factory","bind","element","Object","assign","object","driver","mountID","sandbox","rootComponents","rootInstances","defineProperty","exports","_typeof","Symbol","iterator","obj","constructor","prototype","isWeb","navigator","appCodeName","product","isNode","process","versions","node","isWeex","callNative","isReactNative","__fbBatchedBridgeConfig","injectDriver","STYLE","ID","TEXT","FULL_WIDTH_REM","DOCUMENT_FRAGMENT_NODE","nodeMaps","document","__weex_document__","Driver","getElementById","id","getChildNodes","createBody","open","body","documentElement","appendChild","createFragment","nodeType","childNodes","createComment","content","createEmpty","createText","text","updateText","setAttribute","events","originStyle","prop","parent","map","child","removeChild","attr","replaceChild","newChild","oldChild","previousSibling","nextSibling","insertAfter","insertBefore","after","index","before","addEventListener","eventName","eventHandler","addEvent","removeEventListener","removeEvent","removeAllEventListeners","removeAttribute","propKey","propValue","setAttr","setStyles","styles","val","setStyle","beforeRender","getWindowWidth","afterRender","listener","createFinish","close","CHILDREN","disableSetStyles","substring","slice","toLowerCase","instance","ownerDocument","_nativeNode","internal","_internal","_renderedComponent","isRem","calcRem","getRem","setRem","isUnitNumber","convertUnit","UNITLESS_NUMBER_PROPS","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridColumn","fontWeight","lineClamp","opacity","order","orphans","tabSize","widows","zIndex","zoom","lines","SUFFIX","REM_REG","defaultRem","str","indexOf","rem","replace","remValue","parseFloat","DANGEROUSLY_SET_INNER_HTML","createDocumentFragment","createTextNode","textContentAttr","parentNode","nodeName","innerHTML","__html","isFlexProp","clientWidth","BOX_ALIGN","stretch","center","BOX_ORIENT","row","column","BOX_PACK","FLEX_PROPS","display","alignItems","alignSelf","flexDirection","justifyContent","flexWrap","Flexbox","webkitBoxFlex","webkitFlex","webkitBoxAlign","webkitAlignItems","webkitAlignSelf","webkitBoxOrient","webkitFlexDirection","webkitBoxPack","webkitJustifyContent","__REACT_DEVTOOLS_GLOBAL_HOOK__","inject","ComponentTree","getClosestInstanceFromNode","get","getNodeFromInstance","inst","Mount","_instancesByReactRootID","_renderNewRootComponent","Reconciler","mountComponent","receiveComponent","unmountComponent","KEY","set","rootID","remove","container","prevRootInstance","hasPrevRootInstance","isRootComponent","prevRenderedComponent","getRenderedComponent","prevElement","_currentElement","prevUnmaskedContext","_context","updateComponent","wrappedElement","renderedComponent","defaultContext","rootInstance","instantiateComponent","EmptyComponent","FragmentComponent","NativeComponent","CompositeComponent","TextComponent","JSON","stringify","_mountIndex","shouldUpdateComponent","nextElement","prevEmpty","nextEmpty","prevType","nextType","rootCounter","Root","getPublicInstance","context","updater","refs","partialState","callback","setState","forceUpdate","createChainableTypeChecker","validate","checkType","isRequired","componentName","location","propFullName","chainedCheckType","createTypeChecker","expectedType","typeChecker","array","bool","func","number","string","symbol","any","arrayOf","instanceOf","objectOf","oneOf","oneOfType","shape","rootComponent","call","injectComponent","childMounter","_parent","nativeNode","getNativeNode","shouldNotRemoveChild","TREE","_mountID","appendType","append","_instance","_prevStyleCopy","attach","mountChildren","renderedChildren","renderedChildrenImage","renderedChild","mountImage","_renderedChildren","detach","unmountChildren","prevContext","nextContext","update","prevProps","nextProps","updateProperties","updateChildren","styleName","styleUpdates","lastStyle","nextProp","prevProp","nextChildrenElements","prevChildren","nextChildren","oldNodes","prevChild","lastIndex","nextIndex","lastPlacedNode","nextChild","Math","max","currentNode","prevRef","nextRef","ownerComponent","elementKey","hasKey","defaultName","toString","keyName","keyUnique","console","warn","_stringText","performInSandbox","fn","handleError","e","setTimeout","displayName","_updateCount","publicProps","isComponentClass","isStatelessClasss","publicContext","_processContext","renderedElement","initialState","state","componentWillMount","_processPendingState","_processChildContext","componentDidMount","componentWillUnmount","_pendingStateQueue","_pendingForceUpdate","contextTypes","maskedContext","contextName","currentContext","childContext","getChildContext","queue","nextState","partial","nextUnmaskedContext","error","willReceive","componentWillReceiveProps","_pendingState","shouldUpdate","prevState","shouldComponentUpdate","isPureComponentClass","componentWillUpdate","_updateRenderedComponent","componentDidUpdate","prevRenderedElement","nextRenderedElement","StatelessComponent","pureRender","enqueueCallback","callbackQueue","_pendingCallbacks","enqueueState","stateQueue","Updater","runUpdate","callbacks","forEach","is","x","y","shallowEqual","objA","objB","keysA","keys","keysB","fragment"],"mappings":"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","file":"rax.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap c03759af578f67a86090","import './debug/devtools';\n\nexport {createElement, cloneElement, isValidElement, createFactory} from './element';\nexport Component from './component';\nexport PureComponent from './purecomponent';\nexport PropTypes from './proptypes';\nexport render from './render';\nexport findDOMNode from './findDOMNode';\nexport unmountComponentAtNode from './unmountComponentAtNode';\nexport findComponentInstance from './findComponentInstance';\nexport setNativeProps from './setNativeProps';\nexport version from './version';\nexport {setDriver, getDriver} from './driver';\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/index.js","import Host from './vdom/host';\nimport {isWeex} from 'universal-env';\n\nconst RESERVED_PROPS = {\n  key: true,\n  ref: true,\n};\n\nfunction getRenderErrorInfo() {\n  if (Host.component) {\n    var name = Host.component.getName();\n    if (name) {\n      return ' Check the render method of `' + name + '`.';\n    }\n  }\n  return '';\n}\n\n\nconst Element = (type, key, ref, props, owner) => {\n  props = filterProps(type, props);\n\n  return {\n    // Built-in properties that belong on the element\n    type,\n    key,\n    ref,\n    props,\n    // Record the component responsible for creating this element.\n    _owner: owner,\n  };\n};\n\nexport default Element;\n\nfunction traverseChildren(children, result) {\n  if (Array.isArray(children)) {\n    for (let i = 0, l = children.length; i < l; i++) {\n      traverseChildren(children[i], result);\n    }\n  } else {\n    result.push(children);\n  }\n}\n\nfunction flattenChildren(children) {\n  if (children == null) {\n    return children;\n  }\n  let result = [];\n  traverseChildren(children, result);\n\n  if (result.length === 1) {\n    result = result[0];\n  }\n\n  return result;\n}\n\nfunction flattenStyle(style) {\n  if (!style) {\n    return undefined;\n  }\n\n  if (!Array.isArray(style)) {\n    return style;\n  } else {\n    let result = {};\n    for (let i = 0; i < style.length; ++i) {\n      let computedStyle = flattenStyle(style[i]);\n      if (computedStyle) {\n        for (let key in computedStyle) {\n          result[key] = computedStyle[key];\n        }\n      }\n    }\n    return result;\n  }\n}\n\n// TODO: so hack\nfunction filterProps(type, props) {\n  // Only for weex text\n  if (isWeex && type === 'text') {\n    let value = props.children;\n    if (value) {\n      if (Array.isArray(value)) {\n        value = value.join('');\n      }\n      props.children = null;\n      props.value = value;\n    }\n  }\n  return props;\n}\n\nexport function createElement(type, config, ...children) {\n  if (type == null) {\n    throw Error('createElement: type should not be null or undefined.' + getRenderErrorInfo());\n  }\n  // Reserved names are extracted\n  let props = {};\n  let propName;\n  let key = null;\n  let ref = null;\n\n  if (config != null) {\n    ref = config.ref === undefined ? null : config.ref;\n    key = config.key === undefined ? null : String(config.key);\n    // Remaining properties are added to a new props object\n    for (propName in config) {\n      if (config.hasOwnProperty(propName) &&\n          !RESERVED_PROPS.hasOwnProperty(propName)) {\n        props[propName] = config[propName];\n      }\n    }\n  }\n\n  if (children.length) {\n    props.children = flattenChildren(children);\n  }\n\n  // Resolve default props\n  if (type && type.defaultProps) {\n    let defaultProps = type.defaultProps;\n    for (propName in defaultProps) {\n      if (props[propName] === undefined) {\n        props[propName] = defaultProps[propName];\n      }\n    }\n  }\n\n  if (props.style && (Array.isArray(props.style) || typeof props.style === 'object')) {\n    props.style = flattenStyle(props.style);\n  }\n\n  return new Element(\n    type,\n    key,\n    ref,\n    props,\n    Host.component\n  );\n}\n\nexport function createFactory(type) {\n  const factory = createElement.bind(null, type);\n  // Expose the type on the factory and the prototype so that it can be\n  // easily accessed on elements. E.g. `<Foo />.type === Foo`.\n  // This should not be named `constructor` since this may not be the function\n  // that created the element, and it may not even be a constructor.\n  factory.type = type;\n  return factory;\n}\n\nexport function cloneElement(element, config, ...children) {\n  // Original props are copied\n  const props = Object.assign({}, element.props);\n\n  // Reserved names are extracted\n  let key = element.key;\n  let ref = element.ref;\n\n  // Owner will be preserved, unless ref is overridden\n  let owner = element._owner;\n\n  if (config) {\n    // Should reset ref and owner if has a new ref\n    if (config.ref !== undefined) {\n      ref = config.ref;\n      owner = Host.component;\n    }\n\n    if (config.key !== undefined) {\n      key = String(config.key);\n    }\n\n    // Resolve default props\n    let defaultProps;\n    if (element.type && element.type.defaultProps) {\n      defaultProps = element.type.defaultProps;\n    }\n    // Remaining properties override existing props\n    let propName;\n    for (propName in config) {\n      if (config.hasOwnProperty(propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n        if (config[propName] === undefined && defaultProps !== undefined) {\n          // Resolve default props\n          props[propName] = defaultProps[propName];\n        } else {\n          props[propName] = config[propName];\n        }\n      }\n    }\n  }\n\n  if (children.length) {\n    props.children = flattenChildren(children);\n  }\n\n  return new Element(\n    element.type,\n    key,\n    ref,\n    props,\n    owner\n  );\n};\n\nexport function isValidElement(object) {\n  return typeof object === 'object' && object !== null && object.type && object.props;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/element.js","/*\n * Stateful things in runtime\n */\nexport default {\n  component: null,\n  driver: null,\n  mountID: 1,\n  sandbox: true,\n  // Roots\n  rootComponents: {},\n  rootInstances: {},\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/host.js","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n// https://www.w3.org/TR/html5/webappapis.html#dom-navigator-appcodename\nvar isWeb = exports.isWeb = (typeof navigator === 'undefined' ? 'undefined' : _typeof(navigator)) === 'object' && (navigator.appCodeName === 'Mozilla' || navigator.product === 'Gecko');\nvar isNode = exports.isNode = typeof process !== 'undefined' && !!(process.versions && process.versions.node);\nvar isWeex = exports.isWeex = typeof callNative === 'function';\nvar isReactNative = exports.isReactNative = typeof __fbBatchedBridgeConfig !== 'undefined';\n\n\n// WEBPACK FOOTER //\n// ./packages/universal-env/lib/index.js","import Host from './vdom/host';\nimport WeexDriver from './drivers/weex';\nimport BrowserDriver from './drivers/browser';\nimport {isWeb, isWeex} from 'universal-env';\n\nexport const setDriver = (driver) => {\n  Host.driver = driver;\n};\n\nexport const getDriver = () => {\n  return Host.driver;\n};\n\nexport const injectDriver = () => {\n  let driver = getDriver();\n\n  // Inject driver\n  if (!driver) {\n    if (isWeex) {\n      driver = WeexDriver;\n    } else if (isWeb) {\n      driver = BrowserDriver;\n    } else {\n      throw Error('No builtin driver matched');\n    }\n\n    setDriver(driver);\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/driver.js","/**\n * Weex driver\n **/\nimport Host from '../vdom/host';\nimport setNativeProps from '../setNativeProps';\nimport {convertUnit, setRem} from '../style/unit';\n\nconst STYLE = 'style';\nconst ID = 'id';\nconst TEXT = 'text';\nconst FULL_WIDTH_REM = 750;\nconst DOCUMENT_FRAGMENT_NODE = 11;\nconst nodeMaps = {};\n/* global __weex_document__ */\nconst document = typeof __weex_document__ === 'object' ?\n  __weex_document__ : typeof document === 'object' ?\n    document : null;\n\nconst Driver = {\n  getElementById(id) {\n    return nodeMaps[id];\n  },\n\n  getChildNodes(node) {\n    return node.children;\n  },\n\n  createBody() {\n    // Close batched updates\n    document.open();\n\n    if (document.body) {\n      return document.body;\n    }\n\n    let documentElement = document.documentElement;\n    let body = document.createBody();\n    documentElement.appendChild(body);\n\n    return body;\n  },\n\n  createFragment() {\n    return {\n      nodeType: DOCUMENT_FRAGMENT_NODE,\n      childNodes: []\n    };\n  },\n\n  createComment(content) {\n    return document.createComment(content);\n  },\n\n  createEmpty() {\n    return this.createComment(' empty ');\n  },\n\n  createText(text) {\n    return Driver.createElement({\n      type: TEXT,\n      props: {\n        value: text,\n      }\n    });\n  },\n\n  updateText(node, content) {\n    this.setAttribute(node, 'value', content);\n  },\n\n  createElement(component) {\n    let props = component.props;\n    let events = [];\n    let style = {};\n    let originStyle = props[STYLE];\n    for (let prop in originStyle) {\n      style[prop] = convertUnit(originStyle[prop], prop);\n    }\n\n    let node = document.createElement(component.type, {\n      style,\n    });\n\n    setNativeProps(node, props, true);\n\n    return node;\n  },\n\n  appendChild(node, parent) {\n    if (parent.nodeType === DOCUMENT_FRAGMENT_NODE) {\n      return parent.childNodes.push(node);\n    } else if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {\n      return node.childNodes.map(child => {\n        return this.appendChild(child, parent);\n      });\n    } else {\n      return parent.appendChild(node);\n    }\n  },\n\n  removeChild(node, parent) {\n    let id = node.attr && node.attr[ID];\n    if (id != null) {\n      nodeMaps[id] = null;\n    }\n    return parent.removeChild(node);\n  },\n\n  replaceChild(newChild, oldChild, parent) {\n    let previousSibling = oldChild.previousSibling;\n    let nextSibling = oldChild.nextSibling;\n    this.removeChild(oldChild, parent);\n\n    if (previousSibling) {\n      this.insertAfter(newChild, previousSibling, parent);\n    } else if (nextSibling) {\n      this.insertBefore(newChild, nextSibling, parent);\n    } else {\n      this.appendChild(newChild, parent);\n    }\n  },\n\n  insertAfter(node, after, parent) {\n    if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {\n      return node.childNodes.map((child, index) => {\n        return this.insertAfter(child, node.childNodes[index - 1] || after, parent);\n      });\n    } else {\n      return parent.insertAfter(node, after);\n    }\n  },\n\n  insertBefore(node, before, parent) {\n    if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {\n      return node.childNodes.map((child, index) => {\n        return this.insertBefore(child, before, parent);\n      });\n    } else {\n      return parent.insertBefore(node, before);\n    }\n  },\n\n  addEventListener(node, eventName, eventHandler) {\n    return node.addEvent(eventName, eventHandler);\n  },\n\n  removeEventListener(node, eventName, eventHandler) {\n    return node.removeEvent(eventName, eventHandler);\n  },\n\n  removeAllEventListeners(node) {\n    // noop\n  },\n\n  removeAttribute(node, propKey, propValue) {\n    if (propKey == ID) {\n      nodeMaps[propValue] = null;\n    }\n    // Weex native will crash when pass null value\n    return node.setAttr(propKey, undefined, false);\n  },\n\n  setAttribute(node, propKey, propValue) {\n    if (propKey == ID) {\n      nodeMaps[propValue] = node;\n    }\n\n    return node.setAttr(propKey, propValue, false);\n  },\n\n  setStyles(node, styles) {\n    // TODO if more then one style update, call setStyles will be better performance\n    for (let key in styles) {\n      let val = styles[key];\n      val = convertUnit(val, key);\n      node.setStyle(key, val);\n    }\n  },\n\n  beforeRender() {\n    // Init rem unit\n    setRem(this.getWindowWidth() / FULL_WIDTH_REM);\n  },\n\n  afterRender() {\n    if (document && document.listener && document.listener.createFinish) {\n      document.listener.createFinish(\n        () => {\n          // Make updates batched\n          document.close();\n        }\n      );\n    }\n  },\n\n  getWindowWidth() {\n    return FULL_WIDTH_REM;\n  },\n};\n\nexport default Driver;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/drivers/weex.js","import Host from './vdom/host';\nimport findDOMNode from './findDOMNode';\n\nconst STYLE = 'style';\nconst CHILDREN = 'children';\n\nexport default function setNativeProps(node, props, disableSetStyles) {\n  node = findDOMNode(node);\n\n  for (let prop in props) {\n    let value = props[prop];\n    if (prop === CHILDREN) {\n      continue;\n    }\n\n    if (value != null) {\n      if (prop === STYLE) {\n        if (disableSetStyles) {\n          continue;\n        }\n        Host.driver.setStyles(node, value);\n      } else if (prop.substring(0, 2) === 'on') {\n        let eventName = prop.slice(2).toLowerCase();\n        Host.driver.addEventListener(node, eventName, value);\n      } else {\n        Host.driver.setAttribute(node, prop, value);\n      }\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/setNativeProps.js","import Host from './vdom/host';\n\nfunction findDOMNode(instance) {\n  if (instance == null) {\n    return null;\n  }\n\n  // If a native node, weex may not export ownerDocument property\n  if (instance.ownerDocument || instance.nodeType) {\n    return instance;\n  }\n\n  // Native component\n  if (instance._nativeNode) {\n    return instance._nativeNode;\n  }\n\n  if (typeof instance == 'string') {\n    return Host.driver.getElementById(instance);\n  }\n\n  if (typeof instance.render !== 'function') {\n    throw new Error('Appears to be neither Component nor DOMNode.');\n  }\n\n  // Composite component\n  let internal = instance._internal;\n\n  if (internal) {\n    while (!internal._nativeNode) {\n      internal = internal._renderedComponent;\n      // If not mounted\n      if (internal == null) {\n        return null;\n      }\n    }\n    return internal._nativeNode;\n  } else {\n    throw new Error('findDOMNode was called on an unmounted component.');\n  }\n}\n\nexport default findDOMNode;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/findDOMNode.js","/**\n * CSS properties which accept numbers but are not in units of \"px\".\n */\nconst UNITLESS_NUMBER_PROPS = {\n  animationIterationCount: true,\n  borderImageOutset: true,\n  borderImageSlice: true,\n  borderImageWidth: true,\n  boxFlex: true,\n  boxFlexGroup: true,\n  boxOrdinalGroup: true,\n  columnCount: true,\n  flex: true,\n  flexGrow: true,\n  flexPositive: true,\n  flexShrink: true,\n  flexNegative: true,\n  flexOrder: true,\n  gridRow: true,\n  gridColumn: true,\n  fontWeight: true,\n  lineClamp: true,\n  // We make lineHeight default is px that is diff with w3c spec\n  // lineHeight: true,\n  opacity: true,\n  order: true,\n  orphans: true,\n  tabSize: true,\n  widows: true,\n  zIndex: true,\n  zoom: true,\n  // Weex only\n  lines: true,\n};\nconst SUFFIX = 'rem';\nconst REM_REG = /[-+]?\\d*\\.?\\d+rem/g;\n\nlet defaultRem;\n\n/**\n * Is string contains rem\n * @param {String} str\n * @returns {Boolean}\n */\nexport function isRem(str) {\n  return typeof str === 'string' && str.indexOf(SUFFIX) !== -1;\n}\n\n/**\n * Calculate rem to pixels: '1.2rem' => 1.2 * rem\n * @param {String} str\n * @param {Number} rem\n * @returns {number}\n */\nexport function calcRem(str, rem = defaultRem) {\n  return str.replace(REM_REG, function(remValue) {\n    return parseFloat(remValue) * rem + 'px';\n  });\n}\n\nexport function getRem() {\n  return defaultRem;\n}\n\nexport function setRem(rem) {\n  defaultRem = rem;\n}\n\nexport function isUnitNumber(val, prop) {\n  return typeof val === 'number' && !UNITLESS_NUMBER_PROPS[prop];\n}\n\nexport function convertUnit(val, prop) {\n  if (prop && isUnitNumber(val, prop)) {\n    return val * defaultRem + 'px';\n  } else if (isRem(val)) {\n    return calcRem(val);\n  }\n\n  return val;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/style/unit.js","/**\n * Web Browser driver\n **/\n\nimport setNativeProps from '../setNativeProps';\nimport {convertUnit, setRem} from '../style/unit';\nimport flexbox from '../style/flexbox';\n\nconst FULL_WIDTH_REM = 750;\nconst STYLE = 'style';\nconst DANGEROUSLY_SET_INNER_HTML = 'dangerouslySetInnerHTML';\n\nconst Driver = {\n  getElementById(id) {\n    return document.getElementById(id);\n  },\n\n  getChildNodes(node) {\n    return node.childNodes;\n  },\n\n  createBody() {\n    return document.body;\n  },\n\n  createFragment() {\n    return document.createDocumentFragment();\n  },\n\n  createComment(content) {\n    return document.createComment(content);\n  },\n\n  createEmpty() {\n    return this.createComment(' empty ');\n  },\n\n  createText(text) {\n    return document.createTextNode(text);\n  },\n\n  updateText(node, text) {\n    let textContentAttr = 'textContent' in document ? 'textContent' : 'nodeValue';\n    node[textContentAttr] = text;\n  },\n\n  createElement(component) {\n    let node = document.createElement(component.type);\n    let props = component.props;\n\n    setNativeProps(node, props);\n\n    return node;\n  },\n\n  appendChild(node, parent) {\n    return parent.appendChild(node);\n  },\n\n  removeChild(node, parent) {\n    // TODO, maybe has been removed when remove child\n    if (node.parentNode === parent) {\n      parent.removeChild(node);\n    }\n  },\n\n  replaceChild(newChild, oldChild, parent) {\n    parent.replaceChild(newChild, oldChild);\n  },\n\n  insertAfter(node, after, parent) {\n    const nextSibling = after.nextSibling;\n    if (nextSibling) {\n      parent.insertBefore(node, nextSibling);\n    } else {\n      parent.appendChild(node);\n    }\n  },\n\n  insertBefore(node, before, parent) {\n    parent.insertBefore(node, before);\n  },\n\n  addEventListener(node, eventName, eventHandler) {\n    return node.addEventListener(eventName, eventHandler);\n  },\n\n  removeEventListener(node, eventName, eventHandler) {\n    return node.removeEventListener(eventName, eventHandler);\n  },\n\n  removeAllEventListeners(node) {\n    // TODO\n  },\n\n  removeAttribute(node, propKey) {\n    if (propKey === 'className') {\n      propKey = 'class';\n    }\n\n    if (node.nodeName.toLowerCase() == 'input' &&\n      ( propKey == 'checked' && (node.type === 'checkbox' || node.type === 'radio')\n      || propKey == 'value')) {\n      node[propKey] = null;\n    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n      node.innerHTML = null;\n    } else {\n      node.removeAttribute(propKey);\n    }\n  },\n\n  setAttribute(node, propKey, propValue) {\n    if (propKey === 'className') {\n      propKey = 'class';\n    }\n\n    if (node.nodeName.toLowerCase() == 'input' &&\n      ( propKey == 'checked' && (node.type === 'checkbox' || node.type === 'radio')\n      || propKey == 'value')) {\n      node[propKey] = propValue;\n    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n      node.innerHTML = propValue.__html;\n    } else if (propValue != null) {\n      node.setAttribute(propKey, propValue);\n    }\n  },\n\n  setStyles(node, styles) {\n    for (let prop in styles) {\n      if (styles.hasOwnProperty(prop)) {\n        let val = styles[prop];\n        if (flexbox.isFlexProp(prop)) {\n          flexbox[prop](val, node.style);\n        } else {\n          node.style[prop] = convertUnit(val, prop);\n        }\n      }\n    }\n  },\n\n  beforeRender() {\n    // Init rem unit\n    setRem(this.getWindowWidth() / FULL_WIDTH_REM);\n  },\n\n  getWindowWidth() {\n    return document.documentElement.clientWidth;\n  },\n};\n\nexport default Driver;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/drivers/browser.js","const BOX_ALIGN = {\n  stretch: 'stretch',\n  'flex-start': 'start',\n  'flex-end': 'end',\n  center: 'center'\n};\n\nconst BOX_ORIENT = {\n  row: 'horizontal',\n  column: 'vertical'\n};\n\nconst BOX_PACK = {\n  'flex-start': 'start',\n  'flex-end': 'end',\n  center: 'center',\n  'space-between': 'justify',\n  'space-around': 'justify' // Just same as `space-between`\n};\n\nconst FLEX_PROPS = {\n  display: true,\n  flex: true,\n  alignItems: true,\n  alignSelf: true,\n  flexDirection: true,\n  justifyContent: true,\n  flexWrap: true,\n};\n\nlet Flexbox = {\n  isFlexProp(prop) {\n    return FLEX_PROPS[prop];\n  },\n  display(value, style = {}) {\n    if (value === 'flex') {\n      style.display = '-webkit-box';\n      style.display = '-webkit-flex';\n      style.display = 'flex';\n    } else {\n      style.display = value;\n    }\n\n    return style;\n  },\n  flex(value, style = {}) {\n    style.webkitBoxFlex = value;\n    style.webkitFlex = value;\n    style.flex = value;\n    return style;\n  },\n  flexWrap(value, style = {}) {\n    style.flexWrap = value;\n    return style;\n  },\n  alignItems(value, style = {}) {\n    style.webkitBoxAlign = BOX_ALIGN[value];\n    style.webkitAlignItems = value;\n    style.alignItems = value;\n    return style;\n  },\n  alignSelf(value, style = {}) {\n    style.webkitAlignSelf = value;\n    style.alignSelf = value;\n    return style;\n  },\n  flexDirection(value, style = {}) {\n    style.webkitBoxOrient = BOX_ORIENT[value];\n    style.webkitFlexDirection = value;\n    style.flexDirection = value;\n    return style;\n  },\n  justifyContent(value, style = {}) {\n    style.webkitBoxPack = BOX_PACK[value];\n    style.webkitJustifyContent = value;\n    style.justifyContent = value;\n    return style;\n  }\n};\n\nexport default Flexbox;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/style/flexbox.js","import Hook from './hook';\n\n/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {\n  __REACT_DEVTOOLS_GLOBAL_HOOK__.inject(Hook);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/debug/devtools.js","import instance from '../vdom/instance';\nimport Host from '../vdom/host';\n\nexport default {\n  ComponentTree: {\n    getClosestInstanceFromNode(node) {\n      return instance.get(node);\n    },\n    getNodeFromInstance(inst) {\n      // inst is an internal instance (but could be a composite)\n      while (inst._renderedComponent) {\n        inst = inst._renderedComponent;\n      }\n\n      if (inst) {\n        return inst._nativeNode;\n      } else {\n        return null;\n      }\n    }\n  },\n  Mount: {\n    _instancesByReactRootID: Host.rootComponents,\n\n    // Stub - React DevTools expects to find this method and replace it\n    // with a wrapper in order to observe new root components being added\n    _renderNewRootComponent() {}\n  },\n  Reconciler: {\n    // Stubs - React DevTools expects to find these methods and replace them\n    // with wrappers in order to observe components being mounted, updated and\n    // unmounted\n    mountComponent() {},\n    receiveComponent() {},\n    unmountComponent() {},\n  },\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/debug/hook.js","import Host from './host';\nimport {createElement} from '../element';\nimport unmountComponentAtNode from '../unmountComponentAtNode';\nimport instantiateComponent from './instantiateComponent';\nimport shouldUpdateComponent from './shouldUpdateComponent';\nimport Root from './root';\nimport Hook from '../debug/hook';\n\n/**\n * Instance manager\n */\nconst KEY = '$$instance';\n\nexport default {\n  set(node, instance) {\n    if (!node[KEY]) {\n      node[KEY] = instance;\n      // Record root instance to roots map\n      if (instance.rootID) {\n        Host.rootInstances[instance.rootID] = instance;\n        Host.rootComponents[instance.rootID] = instance._internal;\n      }\n    }\n  },\n  get(node) {\n    return node[KEY];\n  },\n  remove(node) {\n    let instance = this.get(node);\n    if (instance) {\n      node[KEY] = null;\n      if (instance.rootID) {\n        delete Host.rootComponents[instance.rootID];\n        delete Host.rootInstances[instance.rootID];\n      }\n    }\n  },\n  render(element, container) {\n    let prevRootInstance = this.get(container);\n    let hasPrevRootInstance = prevRootInstance && prevRootInstance.isRootComponent;\n\n    if (hasPrevRootInstance) {\n      let prevRenderedComponent = prevRootInstance.getRenderedComponent();\n      let prevElement = prevRenderedComponent._currentElement;\n      if (shouldUpdateComponent(prevElement, element)) {\n        let prevUnmaskedContext = prevRenderedComponent._context;\n        prevRenderedComponent.updateComponent(\n          prevElement,\n          element,\n          prevUnmaskedContext,\n          prevUnmaskedContext\n        );\n\n        return prevRootInstance;\n      } else {\n        Hook.Reconciler.unmountComponent(prevRootInstance);\n        unmountComponentAtNode(container);\n      }\n    }\n\n    let wrappedElement = createElement(Root, null, element);\n    let renderedComponent = instantiateComponent(wrappedElement);\n    let defaultContext = {};\n    let rootInstance = renderedComponent.mountComponent(container, defaultContext);\n    this.set(container, rootInstance);\n    Hook.Mount._renderNewRootComponent(rootInstance._internal);\n\n    return rootInstance;\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/instance.js","import instance from './vdom/instance';\n\nexport default function unmountComponentAtNode(node) {\n  let component = instance.get(node);\n\n  if (!component) {\n    return false;\n  }\n\n  instance.remove(node);\n  component._internal.unmountComponent();\n\n  return true;\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/unmountComponentAtNode.js","import Host from './host';\n\nfunction instantiateComponent(element) {\n  let instance;\n\n  if (element === undefined || element === null || element === false || element === true) {\n    instance = new Host.EmptyComponent();\n  } else if (Array.isArray(element)) {\n    instance = new Host.FragmentComponent(element);\n  } else if (typeof element === 'object' && element.type) {\n    // Special case string values\n    if (typeof element.type === 'string') {\n      instance = new Host.NativeComponent(element);\n    } else {\n      instance = new Host.CompositeComponent(element);\n    }\n  } else if (typeof element === 'string' || typeof element === 'number') {\n    instance = new Host.TextComponent(element);\n  } else {\n    throw Error(`Invalid element type ${JSON.stringify(element)}`);\n  }\n\n  instance._mountIndex = 0;\n\n  return instance;\n}\n\nexport default instantiateComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/instantiateComponent.js","function shouldUpdateComponent(prevElement, nextElement) {\n  // TODO: prevElement and nextElement could be array\n  let prevEmpty = prevElement === null;\n  let nextEmpty = nextElement === null;\n  if (prevEmpty || nextEmpty) {\n    return prevEmpty === nextEmpty;\n  }\n\n  let prevType = typeof prevElement;\n  let nextType = typeof nextElement;\n  if (prevType === 'string' || prevType === 'number') {\n    return nextType === 'string' || nextType === 'number';\n  } else {\n    return (\n      prevType === 'object' &&\n      nextType === 'object' &&\n      prevElement.type === nextElement.type &&\n      prevElement.key === nextElement.key\n    );\n  }\n}\n\nexport default shouldUpdateComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/shouldUpdateComponent.js","import Component from '../component';\n\nlet rootCounter = 1;\n\nclass Root extends Component {\n  rootID = rootCounter++;\n  isRootComponent() {}\n  render() {\n    return this.props.children;\n  }\n  getPublicInstance() {\n    return this.getRenderedComponent().getPublicInstance();\n  }\n  getRenderedComponent() {\n    return this._internal._renderedComponent;\n  }\n}\n\nexport default Root;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/root.js","/**\n * Base component class.\n */\nclass Component {\n  constructor(props, context, updater) {\n    this.props = props;\n    this.context = context;\n    this.refs = {};\n    this.updater = updater;\n  }\n\n  isComponentClass() {}\n\n  setState(partialState, callback) {\n    this.updater.setState(this, partialState, callback);\n  }\n\n  forceUpdate(callback) {\n    this.updater.forceUpdate(this, callback);\n  }\n}\n\nexport default Component;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/component.js","import Component from './component';\n\n/**\n * Pure component class.\n */\nclass PureComponent extends Component {\n  constructor(props, context) {\n    super(props, context);\n  }\n\n  isPureComponentClass() {}\n}\n\nexport default PureComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/purecomponent.js","/*\n * Current PropTypes only export some api with react, not validate in runtime.\n */\n\nfunction createChainableTypeChecker(validate) {\n  function checkType(isRequired, props, propName, componentName, location, propFullName) {\n    // Noop\n  }\n\n  let chainedCheckType = checkType.bind(null, false);\n  chainedCheckType.isRequired = checkType.bind(null, true);\n\n  return chainedCheckType;\n}\n\nfunction createTypeChecker(expectedType) {\n  function validate(props, propName, componentName, location, propFullName) {\n    // Noop\n  }\n  return createChainableTypeChecker(validate);\n}\n\nlet typeChecker = createTypeChecker();\n\nexport default {\n  array: typeChecker,\n  bool: typeChecker,\n  func: typeChecker,\n  number: typeChecker,\n  object: typeChecker,\n  string: typeChecker,\n  symbol: typeChecker,\n  element: typeChecker,\n  node: typeChecker,\n  any: typeChecker,\n  arrayOf: typeChecker,\n  instanceOf: typeChecker,\n  objectOf: typeChecker,\n  oneOf: typeChecker,\n  oneOfType: typeChecker,\n  shape: typeChecker,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/proptypes.js","import injectComponent from './vdom/injectComponent';\nimport instance from './vdom/instance';\nimport {setRem} from './style/unit';\nimport {injectDriver, getDriver} from './driver';\n\nfunction render(element, container, callback) {\n  // Inject component\n  injectComponent();\n  // Inject driver\n  injectDriver();\n\n  let driver = getDriver();\n\n  // Before render callback\n  driver.beforeRender && driver.beforeRender(element, container);\n\n  // Real native root node is body\n  if (container == null) {\n    container = driver.createBody();\n  }\n\n  let rootComponent = instance.render(element, container);\n  let component = rootComponent.getPublicInstance();\n\n  if (callback) {\n    callback.call(component);\n  }\n  // After render callback\n  driver.afterRender && driver.afterRender(component);\n\n  return component;\n}\n\nexport default render;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/render.js","import Host from './host';\nimport EmptyComponent from './empty';\nimport NativeComponent from './native';\nimport TextComponent from './text';\nimport CompositeComponent from './composite';\nimport FragmentComponent from './fragment';\n\nexport default function injectComponent() {\n  // Inject component class\n  Host.EmptyComponent = EmptyComponent;\n  Host.NativeComponent = NativeComponent;\n  Host.TextComponent = TextComponent;\n  Host.FragmentComponent = FragmentComponent;\n  Host.CompositeComponent = CompositeComponent;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/injectComponent.js","import Host from './host';\n\n/**\n * Empty Component\n */\nclass EmptyComponent {\n  constructor() {\n    this._currentElement = null;\n  }\n\n  mountComponent(parent, context, childMounter) {\n    this._parent = parent;\n    this._context = context;\n\n    let instance = {\n      _internal: this\n    };\n\n    let nativeNode = this.getNativeNode();\n    if (childMounter) {\n      childMounter(nativeNode, parent);\n    } else {\n      Host.driver.appendChild(nativeNode, parent);\n    }\n\n    return instance;\n  }\n\n  unmountComponent(shouldNotRemoveChild) {\n    if (this._nativeNode && !shouldNotRemoveChild) {\n      Host.driver.removeChild(this._nativeNode, this._parent);\n    }\n\n    this._nativeNode = null;\n    this._parent = null;\n    this._context = null;\n  }\n\n  updateComponent() {\n    // noop\n  }\n\n  getNativeNode() {\n    // Weex native node\n    if (this._nativeNode == null) {\n      this._nativeNode = Host.driver.createEmpty();\n    }\n\n    return this._nativeNode;\n  }\n}\n\nexport default EmptyComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/empty.js","import Host from './host';\nimport Ref from './ref';\nimport instantiateComponent from './instantiateComponent';\nimport shouldUpdateComponent from './shouldUpdateComponent';\nimport getElementKeyName from './getElementKeyName';\nimport instance from './instance';\nimport Hook from '../debug/hook';\n\nconst STYLE = 'style';\nconst CHILDREN = 'children';\nconst TREE = 'tree';\n\n/**\n * Native Component\n */\nclass NativeComponent {\n  constructor(element) {\n    this._currentElement = element;\n  }\n\n  mountComponent(parent, context, childMounter) {\n    // Parent native element\n    this._parent = parent;\n    this._context = context;\n    this._mountID = Host.mountID++;\n\n    let props = this._currentElement.props;\n    let type = this._currentElement.type;\n    let instance = {\n      _internal: this,\n      type,\n      props,\n    };\n    let appendType = props.append; // Default is node\n\n    this._instance = instance;\n\n    // Clone a copy for style diff\n    this._prevStyleCopy = Object.assign({}, props.style);\n\n    let nativeNode = this.getNativeNode();\n\n    if (appendType !== TREE) {\n      if (childMounter) {\n        childMounter(nativeNode, parent);\n      } else {\n        Host.driver.appendChild(nativeNode, parent);\n      }\n    }\n\n    if (this._currentElement && this._currentElement.ref) {\n      Ref.attach(this._currentElement._owner, this._currentElement.ref, this);\n    }\n\n    // Process children\n    let children = props.children;\n    if (children != null) {\n      this.mountChildren(children, context);\n    }\n\n    if (appendType === TREE) {\n      if (childMounter) {\n        childMounter(nativeNode, parent);\n      } else {\n        Host.driver.appendChild(nativeNode, parent);\n      }\n    }\n\n    Hook.Reconciler.mountComponent(this);\n\n    return instance;\n  }\n\n  mountChildren(children, context) {\n    if (!Array.isArray(children)) {\n      children = [children];\n    }\n\n    let renderedChildren = {};\n\n    let renderedChildrenImage = children.map( (element, index) => {\n      let renderedChild = instantiateComponent(element);\n      let name = getElementKeyName(renderedChildren, element, index);\n      renderedChildren[name] = renderedChild;\n      renderedChild._mountIndex = index;\n      // Mount\n      let mountImage = renderedChild.mountComponent(this.getNativeNode(), context);\n      return mountImage;\n    });\n\n    this._renderedChildren = renderedChildren;\n\n    return renderedChildrenImage;\n  }\n\n  unmountChildren() {\n    let renderedChildren = this._renderedChildren;\n\n    if (renderedChildren) {\n      for (let name in renderedChildren) {\n        let renderedChild = renderedChildren[name];\n        renderedChild.unmountComponent();\n      }\n      this._renderedChildren = null;\n    }\n  }\n\n  unmountComponent(shouldNotRemoveChild) {\n    if (this._nativeNode) {\n      let ref = this._currentElement.ref;\n      if (ref) {\n        Ref.detach(this._currentElement._owner, ref, this);\n      }\n\n      instance.remove(this._nativeNode);\n      if (!shouldNotRemoveChild) {\n        Host.driver.removeChild(this._nativeNode, this._parent);\n      }\n      Host.driver.removeAllEventListeners(this._nativeNode);\n    }\n\n    this.unmountChildren();\n\n    Hook.Reconciler.unmountComponent(this);\n\n    this._currentElement = null;\n    this._nativeNode = null;\n    this._parent = null;\n    this._context = null;\n    this._instance = null;\n    this._prevStyleCopy = null;\n  }\n\n  updateComponent(prevElement, nextElement, prevContext, nextContext) {\n    // Replace current element\n    this._currentElement = nextElement;\n\n    Ref.update(prevElement, nextElement, this);\n\n    let prevProps = prevElement.props;\n    let nextProps = nextElement.props;\n\n    this.updateProperties(prevProps, nextProps);\n    this.updateChildren(nextProps.children, nextContext);\n\n    Hook.Reconciler.receiveComponent(this);\n  }\n\n  updateProperties(prevProps, nextProps) {\n    let propKey;\n    let styleName;\n    let styleUpdates;\n    for (propKey in prevProps) {\n      if (propKey === CHILDREN ||\n          nextProps.hasOwnProperty(propKey) ||\n         !prevProps.hasOwnProperty(propKey) ||\n         prevProps[propKey] == null) {\n        continue;\n      }\n      if (propKey === STYLE) {\n        let lastStyle = this._prevStyleCopy;\n        for (styleName in lastStyle) {\n          if (lastStyle.hasOwnProperty(styleName)) {\n            styleUpdates = styleUpdates || {};\n            styleUpdates[styleName] = '';\n          }\n        }\n        this._prevStyleCopy = null;\n      } else if ( propKey.substring(0, 2) === 'on' ) {\n        if (prevProps[propKey]) {\n          Host.driver.removeEventListener(this.getNativeNode(), propKey.slice(2).toLowerCase(), prevProps[propKey]);\n        }\n      } else {\n        Host.driver.removeAttribute(this.getNativeNode(), propKey, prevProps[propKey]);\n      }\n    }\n\n    for (propKey in nextProps) {\n      let nextProp = nextProps[propKey];\n      let prevProp =\n        propKey === STYLE ? this._prevStyleCopy :\n        prevProps != null ? prevProps[propKey] : undefined;\n      if (propKey === CHILDREN ||\n          !nextProps.hasOwnProperty(propKey) ||\n          nextProp === prevProp ||\n          nextProp == null && prevProp == null) {\n        continue;\n      }\n      // Update style\n      if (propKey === STYLE) {\n        if (nextProp) {\n          // Clone property\n          nextProp = this._prevStyleCopy = Object.assign({}, nextProp);\n        } else {\n          this._prevStyleCopy = null;\n        }\n\n        if (prevProp != null) {\n          // Unset styles on `prevProp` but not on `nextProp`.\n          for (styleName in prevProp) {\n            if (prevProp.hasOwnProperty(styleName) &&\n                (!nextProp || !nextProp.hasOwnProperty(styleName))) {\n              styleUpdates = styleUpdates || {};\n              styleUpdates[styleName] = '';\n            }\n          }\n          // Update styles that changed since `prevProp`.\n          for (styleName in nextProp) {\n            if (nextProp.hasOwnProperty(styleName) &&\n                prevProp[styleName] !== nextProp[styleName]) {\n              styleUpdates = styleUpdates || {};\n              styleUpdates[styleName] = nextProp[styleName];\n            }\n          }\n        } else {\n          // Assign next prop when prev style is null\n          styleUpdates = nextProp;\n        }\n\n      // Update event binding\n      } else if (propKey.substring(0, 2) === 'on') {\n        if (prevProp != null) {\n          Host.driver.removeEventListener(this.getNativeNode(), propKey.slice(2).toLowerCase(), prevProp);\n        }\n\n        if (nextProp != null) {\n          Host.driver.addEventListener(this.getNativeNode(), propKey.slice(2).toLowerCase(), nextProp);\n        }\n      // Update other property\n      } else {\n        if (nextProp != null) {\n          Host.driver.setAttribute(this.getNativeNode(), propKey, nextProp);\n        } else {\n          Host.driver.removeAttribute(this.getNativeNode(), propKey, prevProps[propKey]);\n        }\n      }\n    }\n\n    if (styleUpdates) {\n      Host.driver.setStyles(this.getNativeNode(), styleUpdates);\n    }\n  }\n\n  updateChildren(nextChildrenElements, context) {\n    // prev rendered children\n    let prevChildren = this._renderedChildren;\n\n    if (nextChildrenElements == null && prevChildren == null) {\n      return;\n    }\n\n    let nextChildren = {};\n    let oldNodes = {};\n\n    if (nextChildrenElements != null) {\n      if (!Array.isArray(nextChildrenElements)) {\n        nextChildrenElements = [nextChildrenElements];\n      }\n\n      // Update next children elements\n      for (let index = 0, length = nextChildrenElements.length; index < length; index++) {\n        let nextElement = nextChildrenElements[index];\n        let name = getElementKeyName(nextChildren, nextElement, index);\n        let prevChild = prevChildren && prevChildren[name];\n        let prevElement = prevChild && prevChild._currentElement;\n\n        if (prevChild != null && shouldUpdateComponent(prevElement, nextElement)) {\n          // Pass the same context when updating chidren\n          prevChild.updateComponent(prevElement, nextElement, context, context);\n          nextChildren[name] = prevChild;\n        } else {\n          // Unmount the prevChild when nextChild is different element type.\n          if (prevChild) {\n            let oldChild = prevChild.getNativeNode();\n            // Delay remove child\n            prevChild.unmountComponent(true);\n            oldNodes[name] = oldChild;\n          }\n          // The child must be instantiated before it's mounted.\n          nextChildren[name] = instantiateComponent(nextElement);\n        }\n      }\n    }\n\n    // Unmount children that are no longer present.\n    if (prevChildren != null) {\n      for (let name in prevChildren) {\n        if (!prevChildren.hasOwnProperty(name)) {\n          continue;\n        }\n        let prevChild = prevChildren[name];\n        if (!nextChildren[name]) {\n          prevChild.unmountComponent();\n        }\n      }\n    }\n\n    if (nextChildren != null) {\n      // `nextIndex` will increment for each child in `nextChildren`, but\n      // `lastIndex` will be the last index visited in `prevChildren`.\n      let lastIndex = 0;\n      let nextIndex = 0;\n      let lastPlacedNode = null;\n\n      for (let name in nextChildren) {\n        if (!nextChildren.hasOwnProperty(name)) {\n          continue;\n        }\n\n        let nextChild = nextChildren[name];\n        let prevChild = prevChildren && prevChildren[name];\n\n        if (prevChild === nextChild) {\n          // If the index of `child` is less than `lastIndex`, then it needs to\n          // be moved. Otherwise, we do not need to move it because a child will be\n          // inserted or moved before `child`.\n          if (prevChild._mountIndex < lastIndex) {\n            Host.driver.insertAfter(prevChild.getNativeNode(), lastPlacedNode, this.getNativeNode());\n          }\n\n          lastIndex = Math.max(prevChild._mountIndex, lastIndex);\n          prevChild._mountIndex = nextIndex;\n        } else {\n          if (prevChild != null) {\n            // Update `lastIndex` before `_mountIndex` gets unset by unmounting.\n            lastIndex = Math.max(prevChild._mountIndex, lastIndex);\n          }\n\n          nextChild.mountComponent(\n            this.getNativeNode(),\n            context,\n            (newChild, parent) => {\n              const oldChild = oldNodes[name];\n              if (oldChild) {\n                Host.driver.replaceChild(newChild, oldChild, parent);\n              } else {\n                // insert child at a specific index\n                const childNodes = Host.driver.getChildNodes(parent);\n                const currentNode = childNodes[nextIndex];\n                if (currentNode) {\n                  Host.driver.insertBefore(newChild, currentNode, parent);\n                } else {\n                  Host.driver.appendChild(newChild, parent);\n                }\n              }\n            }\n          );\n          nextChild._mountIndex = nextIndex;\n        }\n\n        nextIndex++;\n        lastPlacedNode = nextChild.getNativeNode();\n      }\n    }\n\n    this._renderedChildren = nextChildren;\n  }\n\n  getNativeNode() {\n    if (this._nativeNode == null) {\n      this._nativeNode = Host.driver.createElement(this._instance);\n      instance.set(this._nativeNode, this._instance);\n    }\n\n    return this._nativeNode;\n  }\n\n  getPublicInstance() {\n    return this.getNativeNode();\n  }\n\n  getName() {\n    return this._currentElement.type;\n  }\n}\n\nexport default NativeComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/native.js","/*\n * Ref manager\n */\n\nexport default {\n  update(prevElement, nextElement, component) {\n    let prevRef = prevElement != null && prevElement.ref;\n    let nextRef = nextElement != null && nextElement.ref;\n\n    // Update refs in owner component\n    if (prevRef !== nextRef) {\n      // Detach prev RenderedElement's ref\n      prevRef != null && this.detach(prevElement._owner, prevRef, component);\n      // Attach next RenderedElement's ref\n      nextRef != null && this.attach(nextElement._owner, nextRef, component);\n    }\n  },\n  attach(ownerComponent, ref, component) {\n    if (!ownerComponent) {\n      throw new Error(\n        'You might be adding a ref to a component that was not created inside a component\\'s ' +\n        '`render` method, or you have multiple copies of Rax loaded.'\n      );\n    }\n\n    let instance = component.getPublicInstance();\n    if (typeof ref === 'function') {\n      ref(instance);\n    } else {\n      ownerComponent._instance.refs[ref] = instance;\n    }\n  },\n  detach(ownerComponent, ref, component) {\n    if (typeof ref === 'function') {\n      // When the referenced component is unmounted and whenever the ref changes, the old ref will be called with null as an argument.\n      ref(null);\n    } else {\n      // Must match component and ref could detach the ref on owner when A's before ref is B's current ref\n      let instance = component.getPublicInstance();\n      if (ownerComponent._instance.refs[ref] === instance) {\n        delete ownerComponent._instance.refs[ref];\n      }\n    }\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/ref.js","export default (children, element, index) => {\n  const elementKey = element && element.key;\n  const hasKey = typeof elementKey === 'string';\n  const defaultName = '.' + index.toString(36);\n\n  if (hasKey) {\n    let keyName = '$' + elementKey;\n    // Child keys must be unique.\n    let keyUnique = children[keyName] === undefined;\n    // Only the first child will be used when encountered two children with the same key\n    if (!keyUnique) console.warn(`Encountered two children with the same key \"${elementKey}\".`);\n\n    return keyUnique ? keyName : defaultName;\n  } else {\n    return defaultName;\n  }\n};\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/getElementKeyName.js","import Host from './host';\nimport Hook from '../debug/hook';\n\n/**\n * Text Component\n */\nclass TextComponent {\n  constructor(element) {\n    this._currentElement = element;\n    this._stringText = String(element);\n  }\n\n  mountComponent(parent, context, childMounter) {\n    this._parent = parent;\n    this._context = context;\n    this._mountID = Host.mountID++;\n\n    // Weex dom operation\n    let nativeNode = this.getNativeNode();\n\n    if (childMounter) {\n      childMounter(nativeNode, parent);\n    } else {\n      Host.driver.appendChild(nativeNode, parent);\n    }\n\n    let instance = {\n      _internal: this\n    };\n\n    Hook.Reconciler.mountComponent(this);\n\n    return instance;\n  }\n\n  unmountComponent(shouldNotRemoveChild) {\n    if (this._nativeNode && !shouldNotRemoveChild) {\n      Host.driver.removeChild(this._nativeNode, this._parent);\n    }\n\n    Hook.Reconciler.unmountComponent(this);\n\n    this._currentElement = null;\n    this._nativeNode = null;\n    this._parent = null;\n    this._context = null;\n    this._stringText = null;\n  }\n\n  updateComponent(prevElement, nextElement, context) {\n    // If some text do noting\n    if (prevElement !== nextElement) {\n      // Replace current element\n      this._currentElement = nextElement;\n      // Devtool read the latest stringText value\n      this._stringText = String(nextElement);\n      Host.driver.updateText(this.getNativeNode(), nextElement);\n      Hook.Reconciler.receiveComponent(this);\n    }\n  }\n\n  getNativeNode() {\n    if (this._nativeNode == null) {\n      this._nativeNode = Host.driver.createText(this._stringText);\n    }\n    return this._nativeNode;\n  }\n}\n\nexport default TextComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/text.js","import StatelessComponent from './stateless';\nimport updater from './updater';\nimport Host from './host';\nimport Ref from './ref';\nimport instantiateComponent from './instantiateComponent';\nimport shouldUpdateComponent from './shouldUpdateComponent';\nimport shallowEqual from './shallowEqual';\nimport Hook from '../debug/hook';\n\nfunction performInSandbox(fn, handleError) {\n  try {\n    return fn();\n  } catch (e) {\n    if (handleError) {\n      handleError(e);\n    } else {\n      if (Host.sandbox) {\n        setTimeout(() => {\n          throw e;\n        }, 0);\n      } else {\n        throw e;\n      }\n    }\n  }\n}\n\n/**\n * Composite Component\n */\nclass CompositeComponent {\n  constructor(element) {\n    this._currentElement = element;\n  }\n\n  getName() {\n    let type = this._currentElement.type;\n    let constructor = this._instance && this._instance.constructor;\n    return (\n      type.displayName || constructor && constructor.displayName ||\n      type.name || constructor && constructor.name ||\n      null\n    );\n  }\n\n  mountComponent(parent, context, childMounter) {\n    this._parent = parent;\n    this._context = context;\n    this._mountID = Host.mountID++;\n    this._updateCount = 0;\n\n    let Component = this._currentElement.type;\n    let publicProps = this._currentElement.props;\n    let isComponentClass = Component.prototype && Component.prototype.isComponentClass;\n    // Class stateless component without state but have lifecycles\n    let isStatelessClasss = Component.prototype.render;\n\n    // Context process\n    let publicContext = this._processContext(context);\n\n    // Initialize the public class\n    let instance;\n    let renderedElement;\n\n    if (isComponentClass || isStatelessClasss) {\n      // Component instance\n      instance = new Component(publicProps, publicContext, updater);\n    } else if (typeof Component === 'function') {\n      // Functional stateless component without state and lifecycles\n      instance = new StatelessComponent(Component);\n    } else {\n      throw Error(`Invalid component type ${JSON.stringify(Component)}`);\n    }\n\n    // These should be set up in the constructor, but as a convenience for\n    // simpler class abstractions, we set them up after the fact.\n    instance.props = publicProps;\n    instance.context = publicContext;\n    instance.refs = {};\n\n    // Inject the updater into instance\n    instance.updater = updater;\n    instance._internal = this;\n    this._instance = instance;\n\n    // Init state, must be set to an object or null\n    let initialState = instance.state;\n    if (initialState === undefined) {\n      // TODO clone the state?\n      instance.state = initialState = null;\n    }\n\n    performInSandbox(() => {\n      if (instance.componentWillMount) {\n        instance.componentWillMount();\n      }\n    });\n\n    if (renderedElement == null) {\n      Host.component = this;\n      // Process pending state when call setState in componentWillMount\n      instance.state = this._processPendingState(publicProps, publicContext);\n\n      // FIXME: handleError should named as lifecycles\n      let handleError;\n      if (typeof instance.handleError === 'function') {\n        handleError = (e) => {\n          instance.handleError(e);\n        };\n      }\n\n      performInSandbox(() => {\n        renderedElement = instance.render();\n      }, handleError);\n\n      Host.component = null;\n    }\n\n    this._renderedComponent = instantiateComponent(renderedElement);\n    this._renderedComponent.mountComponent(\n      this._parent,\n      this._processChildContext(context),\n      childMounter\n    );\n\n    if (this._currentElement && this._currentElement.ref) {\n      Ref.attach(this._currentElement._owner, this._currentElement.ref, this);\n    }\n\n    performInSandbox(() => {\n      if (instance.componentDidMount) {\n        instance.componentDidMount();\n      }\n    });\n\n    Hook.Reconciler.mountComponent(this);\n\n    return instance;\n  }\n\n  unmountComponent(shouldNotRemoveChild) {\n    let instance = this._instance;\n\n    performInSandbox(() => {\n      if (instance.componentWillUnmount) {\n        instance.componentWillUnmount();\n      }\n    });\n\n    Hook.Reconciler.unmountComponent(this);\n\n    instance._internal = null;\n\n    if (this._renderedComponent != null) {\n      let ref = this._currentElement.ref;\n      if (ref) {\n        Ref.detach(this._currentElement._owner, ref, this);\n      }\n\n      this._renderedComponent.unmountComponent(shouldNotRemoveChild);\n      this._renderedComponent = null;\n      this._instance = null;\n    }\n\n    this._currentElement = null;\n\n    // Reset pending fields\n    // Even if this component is scheduled for another update in ReactUpdates,\n    // it would still be ignored because these fields are reset.\n    this._pendingStateQueue = null;\n    this._pendingForceUpdate = false;\n\n    // These fields do not really need to be reset since this object is no\n    // longer accessible.\n    this._context = null;\n  }\n\n  /**\n   * Filters the context object to only contain keys specified in\n   * `contextTypes`\n   */\n  _processContext(context) {\n    let Component = this._currentElement.type;\n    let contextTypes = Component.contextTypes;\n    if (!contextTypes) {\n      return {};\n    }\n    let maskedContext = {};\n    for (let contextName in contextTypes) {\n      maskedContext[contextName] = context[contextName];\n    }\n    return maskedContext;\n  }\n\n  _processChildContext(currentContext) {\n    let instance = this._instance;\n    let childContext = instance.getChildContext && instance.getChildContext();\n    if (childContext) {\n      return Object.assign({}, currentContext, childContext);\n    }\n    return currentContext;\n  }\n\n  _processPendingState(props, context) {\n    let instance = this._instance;\n    let queue = this._pendingStateQueue;\n    if (!queue) {\n      return instance.state;\n    }\n    // Reset pending queue\n    this._pendingStateQueue = null;\n    let nextState = Object.assign({}, instance.state);\n    for (let i = 0; i < queue.length; i++) {\n      let partial = queue[i];\n      Object.assign(\n        nextState,\n        typeof partial === 'function' ?\n        partial.call(instance, nextState, props, context) :\n        partial\n      );\n    }\n\n    return nextState;\n  }\n\n  updateComponent(\n    prevElement,\n    nextElement,\n    prevUnmaskedContext,\n    nextUnmaskedContext\n  ) {\n    let instance = this._instance;\n\n    if (!instance) {\n      console.error(\n        `Update component '${this.getName()}' that has already been unmounted (or failed to mount).`\n      );\n    }\n\n    let willReceive = false;\n    let nextContext;\n    let nextProps;\n\n    // Determine if the context has changed or not\n    if (this._context === nextUnmaskedContext) {\n      nextContext = instance.context;\n    } else {\n      nextContext = this._processContext(nextUnmaskedContext);\n      willReceive = true;\n    }\n\n    // Distinguish between a props update versus a simple state update\n    if (prevElement === nextElement) {\n      // Skip checking prop types again -- we don't read component.props to avoid\n      // warning for DOM component props in this upgrade\n      nextProps = nextElement.props;\n    } else {\n      nextProps = nextElement.props;\n      willReceive = true;\n    }\n\n    if (willReceive && instance.componentWillReceiveProps) {\n      // Calling this.setState() within componentWillReceiveProps will not trigger an additional render.\n      this._pendingState = true;\n      performInSandbox(() => {\n        instance.componentWillReceiveProps(nextProps, nextContext);\n      });\n      this._pendingState = false;\n    }\n\n    // Update refs\n    Ref.update(prevElement, nextElement, this);\n\n    // Shoud update always default\n    let shouldUpdate = true;\n    let prevProps = instance.props;\n    let prevState = instance.state;\n    // TODO: could delay execution processPendingState\n    let nextState = this._processPendingState(nextProps, nextContext);\n\n    // ShouldComponentUpdate is not called when forceUpdate is used\n    if (!this._pendingForceUpdate) {\n      if (instance.shouldComponentUpdate) {\n        shouldUpdate = performInSandbox(() => {\n          return instance.shouldComponentUpdate(nextProps, nextState,\n            nextContext);\n        });\n      } else if (instance.isPureComponentClass) {\n        shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(\n          prevState, nextState);\n      }\n    }\n\n    if (shouldUpdate) {\n      this._pendingForceUpdate = false;\n      // Will set `this.props`, `this.state` and `this.context`.\n      let prevContext = instance.context;\n\n      // Cannot use this.setState() in componentWillUpdate.\n      // If need to update state in response to a prop change, use componentWillReceiveProps instead.\n      performInSandbox(() => {\n        if (instance.componentWillUpdate) {\n          instance.componentWillUpdate(nextProps, nextState, nextContext);\n        }\n      });\n\n      // Replace with next\n      this._currentElement = nextElement;\n      this._context = nextUnmaskedContext;\n      instance.props = nextProps;\n      instance.state = nextState;\n      instance.context = nextContext;\n\n      this._updateRenderedComponent(nextUnmaskedContext);\n\n      performInSandbox(() => {\n        if (instance.componentDidUpdate) {\n          instance.componentDidUpdate(prevProps, prevState, prevContext);\n        }\n      });\n\n      this._updateCount++;\n    } else {\n      // If it's determined that a component should not update, we still want\n      // to set props and state but we shortcut the rest of the update.\n      this._currentElement = nextElement;\n      this._context = nextUnmaskedContext;\n      instance.props = nextProps;\n      instance.state = nextState;\n      instance.context = nextContext;\n    }\n\n    Hook.Reconciler.receiveComponent(this);\n  }\n\n  /**\n   * Call the component's `render` method and update the DOM accordingly.\n   */\n  _updateRenderedComponent(context) {\n    let prevRenderedComponent = this._renderedComponent;\n    let prevRenderedElement = prevRenderedComponent._currentElement;\n\n    let instance = this._instance;\n    let nextRenderedElement;\n\n    Host.component = this;\n\n    performInSandbox(() => {\n      nextRenderedElement = instance.render();\n    });\n\n    Host.component = null;\n\n    if (shouldUpdateComponent(prevRenderedElement, nextRenderedElement)) {\n      prevRenderedComponent.updateComponent(\n        prevRenderedElement,\n        nextRenderedElement,\n        prevRenderedComponent._context,\n        this._processChildContext(context)\n      );\n    } else {\n      let oldChild = prevRenderedComponent.getNativeNode();\n      prevRenderedComponent.unmountComponent(true);\n\n      this._renderedComponent = instantiateComponent(nextRenderedElement);\n      this._renderedComponent.mountComponent(\n        this._parent,\n        this._processChildContext(context),\n        (newChild, parent) => {\n          Host.driver.replaceChild(newChild, oldChild, parent);\n        }\n      );\n    }\n  }\n\n  getNativeNode() {\n    let renderedComponent = this._renderedComponent;\n    if (renderedComponent) {\n      return renderedComponent.getNativeNode();\n    }\n  }\n\n  getPublicInstance() {\n    let instance = this._instance;\n    // The Stateless components cannot be given refs\n    if (instance instanceof StatelessComponent) {\n      return null;\n    }\n    return instance;\n  }\n}\n\nexport default CompositeComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/composite.js","/**\n * Stateless Component Class Wrapper\n */\nclass StatelessComponent {\n  constructor(pureRender) {\n    // A stateless class\n\n    // A stateless function\n    this.pureRender = pureRender;\n  }\n  render() {\n    return this.pureRender(this.props, this.context);\n  }\n}\n\nexport default StatelessComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/stateless.js","function enqueueCallback(internal, callback) {\n  if (callback) {\n    let callbackQueue =\n      internal._pendingCallbacks ||\n      (internal._pendingCallbacks = []);\n    callbackQueue.push(callback);\n  }\n}\n\nfunction enqueueState(internal, partialState) {\n  if (partialState) {\n    let stateQueue =\n      internal._pendingStateQueue ||\n      (internal._pendingStateQueue = []);\n    stateQueue.push(partialState);\n  }\n}\n\nconst Updater = {\n  setState: function(component, partialState, callback) {\n    let internal = component._internal;\n\n    if (!internal) {\n      return;\n    }\n\n    enqueueState(internal, partialState);\n    enqueueCallback(internal, callback);\n\n    if (!internal._pendingState) {\n      this.runUpdate(component);\n    }\n  },\n\n  forceUpdate: function(component, callback) {\n    let internal = component._internal;\n\n    if (!internal) {\n      return;\n    }\n\n    internal._pendingForceUpdate = true;\n\n    enqueueCallback(internal, callback);\n    this.runUpdate(component);\n  },\n\n  runUpdate: function(component) {\n    let internal = component._internal;\n\n    if (!internal || !internal._renderedComponent) {\n      return;\n    }\n\n    // If updateComponent happens to enqueue any new updates, we\n    // shouldn't execute the callbacks until the next render happens, so\n    // stash the callbacks first\n    let callbacks = internal._pendingCallbacks;\n    internal._pendingCallbacks = null;\n\n    let prevElement = internal._currentElement;\n    let prevUnmaskedContext = internal._context;\n\n    if (internal._pendingStateQueue || internal._pendingForceUpdate) {\n      internal.updateComponent(\n        prevElement,\n        prevElement,\n        prevUnmaskedContext,\n        prevUnmaskedContext\n      );\n    }\n\n    if (callbacks) {\n      callbacks.forEach(callback => callback());\n    }\n  }\n\n};\n\nexport default Updater;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/updater.js","const hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\nfunction is(x, y) {\n  // SameValue algorithm\n  if (x === y) {\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return x !== 0 || 1 / x === 1 / y;\n  } else {\n    // Step 6.a: NaN == NaN\n    return x !== x && y !== y;\n  }\n}\n\n/**\n * Performs equality by iterating through keys on an object and returning false\n * when any key has values which are not strictly equal between the arguments.\n * Returns true when the values of all keys are strictly equal.\n */\nfunction shallowEqual(objA, objB) {\n  if (is(objA, objB)) {\n    return true;\n  }\n\n  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {\n    return false;\n  }\n\n  let keysA = Object.keys(objA);\n  let keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  // Test for A's keys different from B.\n  for (let i = 0; i < keysA.length; i++) {\n    if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nexport default shallowEqual;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/shallowEqual.js","import Host from './host';\nimport NativeComponent from './native';\nimport instance from './instance';\nimport instantiateComponent from './instantiateComponent';\nimport getElementKeyName from './getElementKeyName';\nimport Hook from '../debug/hook';\n\n/**\n * Fragment Component\n */\nclass FragmentComponent extends NativeComponent {\n  constructor(element) {\n    super(element);\n  }\n\n  mountComponent(parent, context, childMounter) {\n    // Parent native element\n    this._parent = parent;\n    this._context = context;\n    this._mountID = Host.mountID++;\n\n    let instance = {\n      _internal: this,\n    };\n    this._instance = instance;\n\n    let nativeNode = this.getNativeNode();\n    let children = this._currentElement;\n\n    // Process children\n    this.mountChildren(children, context);\n\n    // Fragment child nodes append by tree mode\n    if (childMounter) {\n      childMounter(nativeNode, parent);\n    } else {\n      Host.driver.appendChild(nativeNode, parent);\n    }\n\n    // set to right node when append to parent\n    this._nativeNode = parent;\n\n    Hook.Reconciler.mountComponent(this);\n\n    return instance;\n  }\n\n\n  mountChildren(children, context) {\n    let renderedChildren = {};\n    let fragment = this.getNativeNode();\n\n    let renderedChildrenImage = children.map( (element, index) => {\n      let renderedChild = instantiateComponent(element);\n      let name = getElementKeyName(renderedChildren, element, index);\n      renderedChildren[name] = renderedChild;\n      renderedChild._mountIndex = index;\n      // Mount\n      let mountImage = renderedChild.mountComponent(\n        this._parent,\n        context,\n        (nativeNode) => {\n          Host.driver.appendChild(nativeNode, fragment);\n        }\n      );\n      return mountImage;\n    });\n\n    this._renderedChildren = renderedChildren;\n\n    return renderedChildrenImage;\n  }\n\n  unmountComponent(shouldNotRemoveChild) {\n    if (this._nativeNode) {\n      instance.remove(this._nativeNode);\n      if (!shouldNotRemoveChild) {\n        Host.driver.removeChild(this._nativeNode, this._parent);\n      }\n    }\n\n    this.unmountChildren();\n\n    Hook.Reconciler.unmountComponent(this);\n\n    this._currentElement = null;\n    this._nativeNode = null;\n    this._parent = null;\n    this._context = null;\n    this._instance = null;\n  }\n\n  updateComponent(prevElement, nextElement, prevContext, nextContext) {\n    // Replace current element\n    this._currentElement = nextElement;\n    this.updateChildren(this._currentElement, nextContext);\n\n    Hook.Reconciler.receiveComponent(this);\n  }\n\n  getNativeNode() {\n    if (this._nativeNode == null) {\n      this._nativeNode = Host.driver.createFragment(this._instance);\n      // TODO instance cache\n    }\n\n    return this._nativeNode;\n  }\n\n  getPublicInstance() {\n    // TODO\n    return null;\n  }\n\n  getName() {\n    return 'fragment';\n  }\n}\n\nexport default FragmentComponent;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/vdom/fragment.js","import instance from './vdom/instance';\n\nfunction findComponentInstance(node) {\n  if (node == null) {\n    return null;\n  }\n  return instance.get(node);\n}\n\nexport default findComponentInstance;\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/findComponentInstance.js","export default '0.1.5';\n\n\n\n// WEBPACK FOOTER //\n// ./packages/rax/src/version.js"],"sourceRoot":""}