{"version":3,"sources":["webpack:///./node_modules/symbol-observable/es/index.js","webpack:///./node_modules/wouter/use-location.js","webpack:///./node_modules/wouter/matcher.js","webpack:///./node_modules/wouter/index.js","webpack:///./node_modules/symbol-observable/es/ponyfill.js","webpack:///./node_modules/tiny-relative-date/translations/en.js","webpack:///./node_modules/tinytime/dist/tinytime.js","webpack:///./node_modules/tiny-relative-date/src/factory.js","webpack:///./node_modules/tiny-relative-date/src/index.js","webpack:///(webpack)/buildin/harmony-module.js","webpack:///./node_modules/warning/browser.js","webpack:///./node_modules/shallowequal/modules/index.js","webpack:///(webpack)/buildin/global.js"],"names":["global","module","root","_ponyfill_js__WEBPACK_IMPORTED_MODULE_0__","__webpack_require__","self","window","result","Object","__webpack_exports__","use_location","path","update","react","location","pathname","patchHistoryEvents","events","handler","map","e","addEventListener","removeEventListener","to","history","pushState","patched","type","original","apply","this","arguments","event","Event","dispatchEvent","makeMatcher","makeRegexpFn","pathToRegexp","cache","pattern","regexp","keys","getRegexp","out","exec","reduce","params","key","i","name","escapeRx","str","replace","rxForSegment","repeat","optional","prefix","capture","groupRx","match","lastIndex","_","segment","mod","index","prev","substring","push","RegExp","d","useLocation","useRoute","RouterCtx","buildRouter","options","hook","matcher","useRouter","globalRef","v","router","symbolObservablePonyfill","Symbol","observable","exports","justNow","secondsAgo","aMinuteAgo","minutesAgo","anHourAgo","hoursAgo","aDayAgo","daysAgo","aWeekAgo","weeksAgo","aMonthAgo","monthsAgo","aYearAgo","yearsAgo","overAYearAgo","secondsFromNow","aMinuteFromNow","minutesFromNow","anHourFromNow","hoursFromNow","aDayFromNow","daysFromNow","aWeekFromNow","weeksFromNow","aMonthFromNow","monthsFromNow","aYearFromNow","yearsFromNow","overAYearFromNow","UserText","FullMonth","PartialMonth","FullYear","PartialYear","DayOfTheWeek","Hour","Minutes","Seconds","PostOrAnteMeridiem","Day","DayOfTheMonth","NumberMonth","Hour24","SubToTypeIdentifierMap","MMMM","MM","Mo","YYYY","YY","dddd","DD","Do","h","H","mm","ss","a","months","days","paddWithZeros","int","template","length","undefined","templateAST","tokens","position","text","char","t","sub","parser","render","date","month","getMonth","year","getFullYear","hours","getHours","seconds","getSeconds","minutes","getMinutes","day","getDate","compiled","token","slice","mnth","padMonth","getDay","padDays","hour","padHours","hour24","compiler","calculateDelta","now","Math","round","abs","translations","en_default","Date","delta","translate","translatePhrase","timeValue","translation","minute","floor","originalModule","webpackPolyfill","create","children","defineProperty","enumerable","get","l","fetchKeys","objA","objB","compare","compareContext","ret","call","keysA","keysB","len","bHasOwnProperty","prototype","hasOwnProperty","bind","valueA","valueB","_ret","g","Function"],"mappings":"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","file":"vendors~main~ec8c427e.bundle.js","sourcesContent":["/* global window */\nimport ponyfill from './ponyfill.js';\n\nvar root;\n\nif (typeof self !== 'undefined') {\n  root = self;\n} else if (typeof window !== 'undefined') {\n  root = window;\n} else if (typeof global !== 'undefined') {\n  root = global;\n} else if (typeof module !== 'undefined') {\n  root = module;\n} else {\n  root = Function('return this')();\n}\n\nvar result = ponyfill(root);\nexport default result;\n","import { useEffect, useState } from \"./react-deps.js\";\n\nexport default () => {\n  const [path, update] = useState(location.pathname);\n\n  useEffect(() => {\n    patchHistoryEvents();\n\n    const events = [\"popstate\", \"pushState\", \"replaceState\"];\n    const handler = () => update(location.pathname);\n\n    events.map(e => addEventListener(e, handler));\n    return () => events.map(e => removeEventListener(e, handler));\n  }, []);\n\n  return [path, to => history.pushState(0, 0, to)];\n};\n\n// While History API does have `popstate` event, the only\n// proper way to listen to changes via `push/replaceState`\n// is to monkey-patch these methods.\n//\n// See https://stackoverflow.com/a/4585031\n\nlet patched = 0;\n\nconst patchHistoryEvents = () => {\n  if (patched) return;\n\n  [\"pushState\", \"replaceState\"].map(type => {\n    const original = history[type];\n\n    history[type] = function() {\n      const result = original.apply(this, arguments);\n      const event = new Event(type);\n      event.arguments = arguments;\n\n      dispatchEvent(event);\n      return result;\n    };\n  });\n\n  return (patched = 1);\n};\n","// creates a matcher function\nexport default function makeMatcher(makeRegexpFn = pathToRegexp) {\n  let cache = {};\n\n  // obtains a cached regexp version of the pattern\n  const getRegexp = pattern =>\n    (cache[pattern]) || (cache[pattern] = makeRegexpFn(pattern));\n\n  return (pattern, path) => {\n    const { regexp, keys } = getRegexp(pattern || \"\");\n    const out = regexp.exec(path);\n\n    if (!out) return [false, null];\n\n    // formats an object with matched params\n    const params = keys.reduce((params, key, i) => {\n      params[key.name] = out[i + 1];\n      return params;\n    }, {});\n\n    return [true, params];\n  };\n}\n\n// escapes a regexp string (borrowed from path-to-regexp sources)\n// https://github.com/pillarjs/path-to-regexp/blob/v3.0.0/index.js#L202\nconst escapeRx = str => str.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, \"\\\\$1\");\n\n// returns a segment representation in RegExp based on flags\n// adapted and simplified version from path-to-regexp sources\nconst rxForSegment = (repeat, optional, prefix) => {\n  let capture = repeat ? \"((?:[^\\\\/]+?)(?:\\\\/(?:[^\\\\/]+?))*)\" : \"([^\\\\/]+?)\";\n  if (optional && prefix) capture = \"(?:\\\\/\" + capture + \")\";\n  return capture + (optional ? \"?\" : \"\");\n};\n\nconst pathToRegexp = pattern => {\n  const groupRx = /:([A-Za-z0-9_]+)([?+*]?)/g;\n\n  let match = null,\n    lastIndex = 0,\n    keys = [],\n    result = \"\";\n\n  while ((match = groupRx.exec(pattern)) !== null) {\n    const [_, segment, mod] = match;\n\n    // :foo  [1]      (  )\n    // :foo? [0 - 1]  ( o)\n    // :foo+ [1 - ∞]  (r )\n    // :foo* [0 - ∞]  (ro)\n    const repeat = mod === \"+\" || mod === \"*\";\n    const optional = mod === \"?\" || mod === \"*\";\n    const prefix = optional && pattern[match.index - 1] === \"/\" ? 1 : 0;\n\n    const prev = pattern.substring(lastIndex, match.index - prefix);\n\n    keys.push({ name: segment });\n    lastIndex = groupRx.lastIndex;\n\n    result += escapeRx(prev) + rxForSegment(repeat, optional, prefix);\n  }\n\n  result += escapeRx(pattern.substring(lastIndex));\n  return { keys, regexp: new RegExp(\"^\" + result + \"(?:\\\\/)?$\", \"i\") };\n};\n","import locationHook from \"./use-location.js\";\nimport makeMatcher from \"./matcher.js\";\n\nimport {\n  useRef,\n  useEffect,\n  useContext,\n  useCallback,\n  createContext,\n  isValidElement,\n  cloneElement,\n  createElement as h\n} from \"./react-deps.js\";\n\n/*\n * Part 1, Hooks API: useRouter, useRoute and useLocation\n */\n\n// one of the coolest features of `createContext`:\n// when no value is provided — default object is used.\n// allows us to use the router context as a global ref to store\n// the implicitly created router (see `useRouter` below)\nconst RouterCtx = createContext({});\n\nconst buildRouter = (options = {}) => {\n  return {\n    hook: options.hook || locationHook,\n    matcher: options.matcher || makeMatcher()\n  };\n};\n\nexport const useRouter = () => {\n  const globalRef = useContext(RouterCtx);\n\n  // either obtain the router from the outer context (provided by the\n  // `<Router /> component) or create an implicit one on demand.\n  return globalRef.v || (globalRef.v = buildRouter());\n};\n\nexport const useLocation = () => {\n  const router = useRouter();\n  return router.hook(router);\n};\n\nexport const useRoute = pattern => {\n  const router = useRouter();\n  const [path] = useLocation();\n\n  return router.matcher(pattern, path);\n};\n\n/*\n * Part 2, Low Carb Router API: Router, Route, Link, Switch\n */\n\nexport const Router = props => {\n  const ref = useRef(null);\n\n  // this little trick allows to avoid having unnecessary\n  // calls to potentially expensive `buildRouter` method.\n  // https://reactjs.org/docs/hooks-faq.html#how-to-create-expensive-objects-lazily\n  const value = ref.current || (ref.current = { v: buildRouter(props) });\n\n  return h(RouterCtx.Provider, {\n    value: value,\n    children: props.children\n  });\n};\n\nexport const Route = ({ path, match, component, children }) => {\n  const useRouteMatch = useRoute(path);\n\n  // `props.match` is present - Route is controlled by the Switch\n  const [matches, params] = match || useRouteMatch;\n\n  if (!matches) return null;\n\n  // React-Router style `component` prop\n  if (component) return h(component, { params: params });\n\n  // support render prop or plain children\n  return typeof children === \"function\" ? children(params) : children;\n};\n\nexport const Link = props => {\n  const [, navigate] = useLocation();\n\n  const href = props.href || props.to;\n  const { children, onClick } = props;\n\n  const handleClick = useCallback(\n    event => {\n      event.preventDefault();\n      navigate(href);\n      onClick && onClick();\n    },\n    [href, onClick, navigate]\n  );\n\n  // wraps children in `a` if needed\n  const extraProps = { href, onClick: handleClick, to: null };\n  const jsx = isValidElement(children) ? children : h(\"a\", props);\n\n  return cloneElement(jsx, extraProps);\n};\n\nexport const Switch = ({ children, location }) => {\n  const { matcher } = useRouter();\n  const [originalLocation] = useLocation();\n\n  // make sure the `children` prop is always an array\n  // this is a bit hacky, because it returns [[]], in\n  // case of an empty array, but this case should be\n  // properly handled below in the loop.\n  children = children && children.length ? children : [children];\n\n  for (const element of children) {\n    let match = 0;\n\n    if (\n      isValidElement(element) &&\n      // we don't require an element to be of type Route,\n      // but we do require it to contain a truthy `path` prop.\n      // this allows to use different components that wrap Route\n      // inside of a switch, for example <AnimatedRoute />.\n      element.props.path &&\n      (match = matcher(element.props.path, location || originalLocation))[0]\n    )\n      return cloneElement(element, { match });\n  }\n\n  return null;\n};\n\nexport const Redirect = props => {\n  const [, push] = useLocation();\n  useEffect(() => push(props.href || props.to));\n\n  return null;\n};\n\nexport default useRoute;\n","export default function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n","module.exports = {\n  justNow: \"just now\",\n  secondsAgo: \"{{time}} seconds ago\",\n  aMinuteAgo: \"a minute ago\",\n  minutesAgo: \"{{time}} minutes ago\",\n  anHourAgo: \"an hour ago\",\n  hoursAgo: \"{{time}} hours ago\",\n  aDayAgo: \"yesterday\",\n  daysAgo: \"{{time}} days ago\",\n  aWeekAgo: \"a week ago\",\n  weeksAgo: \"{{time}} weeks ago\",\n  aMonthAgo: \"a month ago\",\n  monthsAgo: \"{{time}} months ago\",\n  aYearAgo: \"a year ago\",\n  yearsAgo: \"{{time}} years ago\",\n  overAYearAgo: \"over a year ago\",\n  secondsFromNow: \"{{time}} seconds from now\",\n  aMinuteFromNow: \"a minute from now\",\n  minutesFromNow: \"{{time}} minutes from now\",\n  anHourFromNow: \"an hour from now\",\n  hoursFromNow: \"{{time}} hours from now\",\n  aDayFromNow: \"tomorrow\",\n  daysFromNow: \"{{time}} days from now\",\n  aWeekFromNow: \"a week from now\",\n  weeksFromNow: \"{{time}} weeks from now\",\n  aMonthFromNow: \"a month from now\",\n  monthsFromNow: \"{{time}} months from now\",\n  aYearFromNow: \"a year from now\",\n  yearsFromNow: \"{{time}} years from now\",\n  overAYearFromNow: \"over a year from now\"\n}\n","'use strict';\n\n//      \n\n/**\n * We want to represent each subs. type as minimally as possible,\n * so instead of using strings we just use characters, which lets us\n * represent 27 individual subs. using a single character each.\n */\n\nvar UserText = 'a';\nvar FullMonth = 'b';\nvar PartialMonth = 'c';\nvar FullYear = 'd';\nvar PartialYear = 'e';\nvar DayOfTheWeek = 'f';\nvar Hour = 'g';\nvar Minutes = 'h';\nvar Seconds = 'i';\nvar PostOrAnteMeridiem = 'j';\nvar Day = 'k';\nvar DayOfTheMonth = 'l';\nvar NumberMonth = 'n';\nvar Hour24 = 'm';\n\nvar SubToTypeIdentifierMap = {\n  'MMMM': FullMonth,\n  'MM': PartialMonth,\n  'Mo': NumberMonth,\n  'YYYY': FullYear,\n  'YY': PartialYear,\n  'dddd': DayOfTheWeek,\n  'DD': DayOfTheMonth,\n  'Do': Day,\n  'h': Hour,\n  'H': Hour24,\n  'mm': Minutes,\n  'ss': Seconds,\n  'a': PostOrAnteMeridiem\n};\n\n//      \n\n/**\n * These types help ensure we don't misspell them anywhere. They will be\n * removed during build.\n */\n\nvar months = [\"January\", \"Febuary\", \"March\", \"April\", \"May\", \"June\", \"July\", \"August\", \"September\", \"October\", \"November\", \"December\"];\n\nvar days = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"];\n\n/**\n * Takes an integer and returns a string left padded with\n * a zero to the left. Used to display minutes and hours (1:01:00PM);\n */\nfunction paddWithZeros(int) {\n  return int < 10 ? '0' + int : '' + int;\n}\n\n/**\n * Adds suffix to day, so 16 becomes 16th.\n */\nfunction suffix(int) {\n  return int % 10 == 1 && int != 11 ? int + \"st\" : int % 10 == 2 && int != 12 ? int + \"nd\" : int % 10 == 3 && int != 13 ? int + \"rd\" : int + \"th\";\n}\n\n/**\n * The compiler takes in our array of tokens returned from the parser\n * and returns the formed template. It just iterates over the tokens and\n * appends some text to the returned string depending on the type of token.\n * @param {Array<Tokens>} tokens\n * @param {Date} date\n * @param {TinyTimeOptions} options\n * @returns {String}\n */\nfunction compiler(tokens, date, options) {\n  var month = date.getMonth();\n  var year = date.getFullYear();\n  var hours = date.getHours();\n  var seconds = date.getSeconds();\n  var minutes = date.getMinutes();\n  var day = date.getDate();\n  var compiled = '';\n  var index = 0;\n  while (index < tokens.length) {\n    var token = tokens[index];\n    switch (token.t) {\n      case UserText:\n        // $FlowFixMe flow doesn't know that v is always populated on UserText\n        compiled += token.v;\n        break;\n      case Day:\n        compiled += suffix(day);\n        break;\n      case PartialMonth:\n        compiled += months[month].slice(0, 3);\n        break;\n      case FullMonth:\n        compiled += months[month];\n        break;\n      case NumberMonth:\n        var mnth = month + 1;\n        if (options.padMonth) {\n          mnth = paddWithZeros(mnth);\n        }\n        compiled += mnth;\n        break;\n      case FullYear:\n        compiled += year;\n        break;\n      case PartialYear:\n        compiled += (year + '').slice(2);\n        break;\n      case DayOfTheWeek:\n        compiled += days[date.getDay()];\n        break;\n      case DayOfTheMonth:\n        compiled += options.padDays ? paddWithZeros(day) : day;\n        break;\n      case Hour:\n        var hour = hours === 0 || hours === 12 ? 12 : hours % 12;\n        if (options.padHours) {\n          hour = paddWithZeros(hour);\n        }\n        compiled += hour;\n        break;\n      case Hour24:\n        var hour24 = hours;\n        if (options.padHours) {\n          hour24 = paddWithZeros(hour24);\n        }\n        compiled += hour24;\n        break;\n      case Minutes:\n        compiled += paddWithZeros(minutes);\n        break;\n      case Seconds:\n        compiled += paddWithZeros(seconds);\n        break;\n      case PostOrAnteMeridiem:\n        compiled += hours >= 12 ? 'PM' : 'AM';\n        break;\n    }\n    index++;\n  }\n  return compiled;\n}\n\n//      \n/**\n * t is type and v is value. Minified property\n * names are being used because the current minification\n * step does not mangle property names, and we want to\n * reduce bundle size as much as possible.\n */\n\n/**\n * Rather than using a bunch of potentially confusing regular\n * expressions to match patterns in templates, we use a simple\n * parser, taking the aproach of a compiler. This is equivalent\n * to a lexer as it returns a stream of tokens. Since there is\n * no additional analysis required for semantics we just call\n * it a parser.\n * \n * It will return an array of tokens, each corresponding to either\n * UserText (just text we want to render) or any number of the\n * subsitution types stored in SubToTypeIdentifierMap.\n * \n */\nfunction parser(template) {\n  var tokens = [];\n  /**\n   * We iterate through each character in the template string, and track\n   * the index of the character we're processing with `position`. We start\n   * at 0, the first character.\n   */\n  var position = 0;\n  /**\n   * `text` is used to accumulate what we call \"UserText\", or simply text that\n   * is not a subsitution. For example, in the template:\n   *  \n   *  \"The day is {day}.\"\n   * \n   * There are two instances of `UserText`, \"The day is \" and \".\", which is the text\n   * befor eand after the subsitution. With this template our tokens would look something like:\n   * \n   * [\n   *  { type: UserText, value: \"The day is \"},\n   *  { type : DaySub },\n   *  { type: UserText, value: \".\" }\n   * ]\n   * \n   */\n  var text = '';\n  while (position < template.length) {\n    var char = template[position++];\n    /**\n     * A bracket indicates we're starting a subsitution. Any characters after this,\n     * and before the next '}' will be considered part of the subsitution name.\n     */\n    if (char === '{') {\n      // Push any `UserText` we've accumulated and reset the `text` variable.\n      if (text) {\n        tokens.push({\n          t: UserText,\n          v: text\n        });\n      }\n      text = '';\n      var sub = '';\n      char = template[position++];\n      while (char !== '}') {\n        sub += char;\n        char = template[position++];\n      }\n      tokens.push({\n        t: SubToTypeIdentifierMap[sub]\n      });\n    }\n    // Anything not inside brackets is just plain text.\n    else {\n        text += char;\n      }\n  }\n  /**\n   * We might have some text after we're done iterating through the template if\n   * the template ends with some `UserText`.\n   */\n  if (text) {\n    tokens.push({\n      t: UserText,\n      v: text\n    });\n  }\n  return tokens;\n}\n\n//      \nfunction tinytime(template) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n  var templateAST = parser(template);\n  return {\n    render: function render(date) {\n      return compiler(templateAST, date, options);\n    }\n  };\n}\n\nmodule.exports = tinytime;\n//# sourceMappingURL=tinytime.js.map\n","const calculateDelta = (now, date) => Math.round(Math.abs(now - date) / 1000)\n\nexport default function relativeDateFactory (translations) {\n  return function relativeDate (date, now = new Date()) {\n    if (!(date instanceof Date)) {\n      date = new Date(date)\n    }\n\n    let delta = null\n\n    const minute = 60\n    const hour = minute * 60\n    const day = hour * 24\n    const week = day * 7\n    const month = day * 30\n    const year = day * 365\n\n    delta = calculateDelta(now, date)\n\n    if (delta > day && delta < week) {\n      date = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0)\n      delta = calculateDelta(now, date)\n    }\n\n    const translate = (translatePhrase, timeValue) => {\n      let key\n\n      if (translatePhrase === 'justNow') {\n        key = translatePhrase\n      } else if (now >= date) {\n        key = `${translatePhrase}Ago`\n      } else {\n        key = `${translatePhrase}FromNow`\n      }\n\n      const translation = translations[key]\n\n      if (typeof translation === 'function') {\n        return translation(timeValue)\n      }\n\n      return translation.replace('{{time}}', timeValue)\n    }\n\n    switch (false) {\n      case !(delta < 30):\n        return translate('justNow')\n\n      case !(delta < minute):\n        return translate('seconds', delta)\n\n      case !(delta < 2 * minute):\n        return translate('aMinute')\n\n      case !(delta < hour):\n        return translate('minutes', Math.floor(delta / minute))\n\n      case Math.floor(delta / hour) !== 1:\n        return translate('anHour')\n\n      case !(delta < day):\n        return translate('hours', Math.floor(delta / hour))\n\n      case !(delta < day * 2):\n        return translate('aDay')\n\n      case !(delta < week):\n        return translate('days', Math.floor(delta / day))\n\n      case Math.floor(delta / week) !== 1:\n        return translate('aWeek')\n\n      case !(delta < month):\n        return translate('weeks', Math.floor(delta / week))\n\n      case Math.floor(delta / month) !== 1:\n        return translate('aMonth')\n\n      case !(delta < year):\n        return translate('months', Math.floor(delta / month))\n\n      case Math.floor(delta / year) !== 1:\n        return translate('aYear')\n\n      default:\n        return translate('overAYear')\n    }\n  }\n}\n","import relativeDateFactory from './factory'\nimport enTranslations from '../translations/en'\n\nexport default relativeDateFactory(enTranslations)\n","module.exports = function(originalModule) {\n\tif (!originalModule.webpackPolyfill) {\n\t\tvar module = Object.create(originalModule);\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"exports\", {\n\t\t\tenumerable: true\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n */\n\n'use strict';\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  warning = function(condition, format, args) {\n    var len = arguments.length;\n    args = new Array(len > 2 ? len - 2 : 0);\n    for (var key = 2; key < len; key++) {\n      args[key - 2] = arguments[key];\n    }\n    if (format === undefined) {\n      throw new Error(\n        '`warning(condition, format, ...args)` requires a warning ' +\n        'message argument'\n      );\n    }\n\n    if (format.length < 10 || (/^[s\\W]*$/).test(format)) {\n      throw new Error(\n        'The warning format should be able to uniquely identify this ' +\n        'warning. Please, use a more descriptive format than: ' + format\n      );\n    }\n\n    if (!condition) {\n      var argIndex = 0;\n      var message = 'Warning: ' +\n        format.replace(/%s/g, function() {\n          return args[argIndex++];\n        });\n      if (typeof console !== 'undefined') {\n        console.error(message);\n      }\n      try {\n        // This error was thrown as a convenience so that you can use this stack\n        // to find the callsite that caused this warning to fire.\n        throw new Error(message);\n      } catch(x) {}\n    }\n  };\n}\n\nmodule.exports = warning;\n","'use strict';\n\nvar fetchKeys = require('lodash.keys');\n\nmodule.exports = function shallowEqual(objA, objB, compare, compareContext) {\n\n    var ret = compare ? compare.call(compareContext, objA, objB) : void 0;\n\n    if (ret !== void 0) {\n        return !!ret;\n    }\n\n    if (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    var keysA = fetchKeys(objA);\n    var keysB = fetchKeys(objB);\n\n    var len = keysA.length;\n    if (len !== keysB.length) {\n        return false;\n    }\n\n    compareContext = compareContext || null;\n\n    // Test for A's keys different from B.\n    var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);\n    for (var i = 0; i < len; i++) {\n        var key = keysA[i];\n        if (!bHasOwnProperty(key)) {\n            return false;\n        }\n        var valueA = objA[key];\n        var valueB = objB[key];\n\n        var _ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;\n        if (_ret === false || _ret === void 0 && valueA !== valueB) {\n            return false;\n        }\n    }\n\n    return true;\n};","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}