{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///resources/assets/scripts/components/QRCodeComponent/l10n.js","webpack:///resources/assets/scripts/components/QRCodeComponent/habitat.js","webpack:///resources/assets/scripts/components sync /habitat\\.js$","webpack:///resources/assets/scripts/higher-order-components/codeSplit.js","webpack:///resources/assets/scripts/components/ExampleComponent/habitat.js","webpack:///external [\"wp\",\"domReady\"]","webpack:///resources/assets/scripts/util/camelCase.js","webpack:///resources/assets/scripts/util/Router.js","webpack:///resources/assets/scripts/routes/common.js","webpack:///resources/assets/scripts/util/events.js","webpack:///resources/assets/scripts/main.js","webpack:///resources/assets/scripts/routes/home.js","webpack:///resources/assets/scripts/routes/about.js","webpack:///external \"React\"","webpack:///resources/assets/scripts/components/ExampleComponent/l10n.js","webpack:///external \"ReactDOM\"","webpack:///external [\"wp\",\"i18n\"]","webpack:///resources/assets/scripts/components sync /habitat-async\\.js$","webpack:///node_modules/ramda/es/internal/_isPlaceholder.js","webpack:///node_modules/ramda/es/internal/_curry1.js","webpack:///node_modules/ramda/es/internal/_curry2.js","webpack:///node_modules/ramda/es/internal/_isArray.js","webpack:///node_modules/ramda/es/internal/_isTransformer.js","webpack:///node_modules/ramda/es/internal/_dispatchable.js","webpack:///node_modules/ramda/es/internal/_isString.js","webpack:///node_modules/ramda/es/internal/_isArrayLike.js","webpack:///node_modules/ramda/es/internal/_xwrap.js","webpack:///node_modules/ramda/es/internal/_arity.js","webpack:///node_modules/ramda/es/bind.js","webpack:///node_modules/ramda/es/internal/_reduce.js","webpack:///node_modules/ramda/es/internal/_xfBase.js","webpack:///node_modules/ramda/es/internal/_flatCat.js","webpack:///node_modules/ramda/es/internal/_forceReduced.js","webpack:///node_modules/ramda/es/internal/_map.js","webpack:///node_modules/ramda/es/internal/_xmap.js","webpack:///node_modules/ramda/es/internal/_curryN.js","webpack:///node_modules/ramda/es/curryN.js","webpack:///node_modules/ramda/es/internal/_has.js","webpack:///node_modules/ramda/es/internal/_isArguments.js","webpack:///node_modules/ramda/es/keys.js","webpack:///node_modules/ramda/es/map.js","webpack:///node_modules/ramda/es/chain.js","webpack:///node_modules/ramda/es/internal/_xchain.js","webpack:///node_modules/ramda/es/internal/_makeFlat.js","webpack:///node_modules/ramda/es/internal/_pipe.js","webpack:///node_modules/ramda/es/internal/_curry3.js","webpack:///node_modules/ramda/es/reduce.js","webpack:///node_modules/ramda/es/internal/_checkForMethod.js","webpack:///node_modules/ramda/es/slice.js","webpack:///node_modules/ramda/es/tail.js","webpack:///node_modules/ramda/es/pipe.js","webpack:///node_modules/ramda/es/reverse.js","webpack:///node_modules/ramda/es/compose.js","webpack:///node_modules/ramda/es/toPairs.js","webpack:///resources/assets/scripts/init/react/DomFactory.js","webpack:///node_modules/ramda/es/curry.js","webpack:///node_modules/ramda/es/fromPairs.js","webpack:///node_modules/ramda/es/pair.js","webpack:///node_modules/ramda/es/internal/_identity.js","webpack:///node_modules/ramda/es/identity.js","webpack:///node_modules/ramda/es/internal/_arrayFromIterator.js","webpack:///node_modules/ramda/es/internal/_includesWith.js","webpack:///node_modules/ramda/es/internal/_objectIs.js","webpack:///node_modules/ramda/es/type.js","webpack:///node_modules/ramda/es/internal/_equals.js","webpack:///node_modules/ramda/es/internal/_functionName.js","webpack:///node_modules/ramda/es/equals.js","webpack:///node_modules/ramda/es/internal/_includes.js","webpack:///node_modules/ramda/es/internal/_indexOf.js","webpack:///node_modules/ramda/es/internal/_clone.js","webpack:///node_modules/ramda/es/internal/_cloneRegExp.js","webpack:///node_modules/ramda/es/internal/_xreduceBy.js","webpack:///node_modules/ramda/es/countBy.js","webpack:///node_modules/ramda/es/reduceBy.js","webpack:///node_modules/ramda/es/internal/_reduced.js","webpack:///node_modules/ramda/es/internal/_xfilter.js","webpack:///node_modules/ramda/es/filter.js","webpack:///node_modules/ramda/es/internal/_isObject.js","webpack:///node_modules/ramda/es/internal/_filter.js","webpack:///node_modules/ramda/es/internal/_isFunction.js","webpack:///node_modules/ramda/es/internal/_quote.js","webpack:///node_modules/ramda/es/internal/_toISOString.js","webpack:///node_modules/ramda/es/reject.js","webpack:///node_modules/ramda/es/internal/_complement.js","webpack:///node_modules/ramda/es/toString.js","webpack:///node_modules/ramda/es/internal/_toString.js","webpack:///node_modules/ramda/es/join.js","webpack:///node_modules/ramda/es/invoker.js","webpack:///resources/assets/scripts/util/state.js","webpack:///resources/assets/scripts/init/react/Bootstrapper.js","webpack:///external [\"wp\",\"apiFetch\"]"],"names":["webpackJsonpCallback","data","moduleId","chunkId","chunkIds","moreModules","executeModules","i","resolves","length","Object","prototype","hasOwnProperty","call","installedChunks","push","modules","parentJsonpFunction","shift","deferredModules","apply","checkDeferredModules","result","deferredModule","fulfilled","j","depId","splice","__webpack_require__","s","installedModules","installedCssChunks","1","exports","module","l","e","promises","Promise","resolve","reject","href","fullhref","p","existingLinkTags","document","getElementsByTagName","datahref","tag","getAttribute","rel","existingStyleTags","linkTag","createElement","type","onload","onerror","event","request","target","src","err","Error","code","parentNode","removeChild","appendChild","then","installedChunkData","promise","onScriptComplete","script","charset","timeout","nc","setAttribute","jsonpScriptSrc","error","clearTimeout","chunk","errorType","realSrc","message","name","undefined","setTimeout","head","all","m","c","d","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","oe","console","jsonpArray","window","oldJsonpFunction","slice","__","downloadMessage","QRCodeGenerator","codeSplit","l10n","loadComponent","System","map","webpackContext","req","id","webpackContextResolve","keys","loadingIndicator","props","Component","lazy","React","Suspense","fallback","_extends","ExampleComponent","str","charAt","toLowerCase","replace","split","part","toUpperCase","join","Router","constructor","routes","this","fire","route","arg","loadEvents","body","className","camelCase","forEach","init","button","querySelector","log","stickyContact","blankTmplHeader","addEventListener","scrollY","classList","add","remove","blankTmplStickyHeader","finalize","domReady","querySelectorAll","select","size","options","common","home","aboutUs","readyCallback","readyState","webpackEmptyContext","_isPlaceholder","a","_curry1","fn","f1","arguments","_curry2","f2","b","_b","_a","Array","val","toString","_isTransformer","obj","_dispatchable","methodNames","transducerCreator","_isArray","idx","transducer","_isString","x","XWrap","f","acc","_arity","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","thisObj","_iterableReduce","xf","iter","step","next","done","_methodReduce","methodName","symIterator","iterator","_reduce","list","_xwrap","len","_arrayReduce","reduce","TypeError","rxf","_xfBase","input","ret","preservingReduced","_map","functor","XMap","_curryN","received","combined","argsIdx","left","combinedIdx","_has","prop","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","hasArgsEnumBug","contains","item","nIdx","ks","checkArgsLength","monad","recursive","flatt","jlen","ilen","_pipe","g","_curry3","f3","_c","_checkForMethod","methodname","fromIndex","toIndex","Infinity","pipe","reverse","compose","pairs","DomFactory","inject","ReactDOM","render","warn","dispose","unmountComponentAtNode","fst","snd","_identity","_arrayFromIterator","_includesWith","pred","_uniqContentEquals","aIterator","bIterator","stackA","stackB","eq","_equals","aItem","match","typeA","equals","String","valueOf","source","global","ignoreCase","multiline","sticky","unicode","entries","concat","values","keysA","extendedStackA","extendedStackB","_includes","inf","indexOf","_indexOf","_clone","refFrom","refTo","deep","pattern","copy","copiedValue","getPrototypeOf","Date","RegExp","XReduceBy","valueFn","valueAcc","keyFn","inputs","elt","elem","XFilter","filterable","_filter","_isFunction","_quote","pad","toISOString","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","toFixed","_toString","seen","recur","y","xs","mapPairs","k","sort","test","isNaN","NaN","repr","arity","method","curry","arr","fromPairs","pair","objs","filter","countBy","identity","chain","contexts","require","asyncContexts","getRegisteredComponents","context","default","ReactApp","ReactHabitat","Bootstrapper","super","updateComponents","builder","ContainerBuilder","factory","components","asyncComponents","componentPairs","toPairs","asyncComponentPairs","component","register","as","registerAsync","setContainer","build"],"mappings":"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","file":"scripts/main.js","sourcesContent":[" \t// install a JSONP callback for chunk loading\n \tfunction webpackJsonpCallback(data) {\n \t\tvar chunkIds = data[0];\n \t\tvar moreModules = data[1];\n \t\tvar executeModules = data[2];\n\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(data);\n\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n\n \t\t// add entry modules from loaded chunk to deferred list\n \t\tdeferredModules.push.apply(deferredModules, executeModules || []);\n\n \t\t// run deferred modules when all chunks ready\n \t\treturn checkDeferredModules();\n \t};\n \tfunction checkDeferredModules() {\n \t\tvar result;\n \t\tfor(var i = 0; i < deferredModules.length; i++) {\n \t\t\tvar deferredModule = deferredModules[i];\n \t\t\tvar fulfilled = true;\n \t\t\tfor(var j = 1; j < deferredModule.length; j++) {\n \t\t\t\tvar depId = deferredModule[j];\n \t\t\t\tif(installedChunks[depId] !== 0) fulfilled = false;\n \t\t\t}\n \t\t\tif(fulfilled) {\n \t\t\t\tdeferredModules.splice(i--, 1);\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = deferredModule[0]);\n \t\t\t}\n \t\t}\n\n \t\treturn result;\n \t}\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded CSS chunks\n \tvar installedCssChunks = {\n \t\t1: 0\n \t}\n\n \t// object to store loaded and loading chunks\n \t// undefined = chunk not loaded, null = chunk preloaded/prefetched\n \t// Promise = chunk loading, 0 = chunk loaded\n \tvar installedChunks = {\n \t\t1: 0\n \t};\n\n \tvar deferredModules = [];\n\n \t// script path function\n \tfunction jsonpScriptSrc(chunkId) {\n \t\treturn __webpack_require__.p + \"scripts/\" + ({\"2\":\"QRCodeGenerator\",\"7\":\"ExampleComponent\"}[chunkId]||chunkId) + \"_\" + {\"2\":\"e65efc7c2bec3cdebb8e\",\"7\":\"9e9df2b518fde14cf5a6\",\"8\":\"3822b301e8f368e049da\"}[chunkId] + \".js\"\n \t}\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 \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\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.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n \t// This file contains only the entry chunk.\n \t// The chunk loading function for additional chunks\n \t__webpack_require__.e = function requireEnsure(chunkId) {\n \t\tvar promises = [];\n\n\n \t\t// mini-css-extract-plugin CSS loading\n \t\tvar cssChunks = {\"2\":1,\"7\":1};\n \t\tif(installedCssChunks[chunkId]) promises.push(installedCssChunks[chunkId]);\n \t\telse if(installedCssChunks[chunkId] !== 0 && cssChunks[chunkId]) {\n \t\t\tpromises.push(installedCssChunks[chunkId] = new Promise(function(resolve, reject) {\n \t\t\t\tvar href = \"styles/\" + ({\"2\":\"QRCodeGenerator\",\"7\":\"ExampleComponent\"}[chunkId]||chunkId) + \"_\" + {\"2\":\"45485ae7a0fb7e9e6e19\",\"7\":\"f6aba453bf5e37066edc\",\"8\":\"31d6cfe0d16ae931b73c\"}[chunkId] + \".css\";\n \t\t\t\tvar fullhref = __webpack_require__.p + href;\n \t\t\t\tvar existingLinkTags = document.getElementsByTagName(\"link\");\n \t\t\t\tfor(var i = 0; i < existingLinkTags.length; i++) {\n \t\t\t\t\tvar tag = existingLinkTags[i];\n \t\t\t\t\tvar datahref = tag.getAttribute(\"data-href\") || tag.getAttribute(\"href\");\n \t\t\t\t\tif(tag.rel === \"stylesheet\" && (datahref === href || datahref === fullhref)) return resolve();\n \t\t\t\t}\n \t\t\t\tvar existingStyleTags = document.getElementsByTagName(\"style\");\n \t\t\t\tfor(var i = 0; i < existingStyleTags.length; i++) {\n \t\t\t\t\tvar tag = existingStyleTags[i];\n \t\t\t\t\tvar datahref = tag.getAttribute(\"data-href\");\n \t\t\t\t\tif(datahref === href || datahref === fullhref) return resolve();\n \t\t\t\t}\n \t\t\t\tvar linkTag = document.createElement(\"link\");\n \t\t\t\tlinkTag.rel = \"stylesheet\";\n \t\t\t\tlinkTag.type = \"text/css\";\n \t\t\t\tlinkTag.onload = resolve;\n \t\t\t\tlinkTag.onerror = function(event) {\n \t\t\t\t\tvar request = event && event.target && event.target.src || fullhref;\n \t\t\t\t\tvar err = new Error(\"Loading CSS chunk \" + chunkId + \" failed.\\n(\" + request + \")\");\n \t\t\t\t\terr.code = \"CSS_CHUNK_LOAD_FAILED\";\n \t\t\t\t\terr.request = request;\n \t\t\t\t\tdelete installedCssChunks[chunkId]\n \t\t\t\t\tlinkTag.parentNode.removeChild(linkTag)\n \t\t\t\t\treject(err);\n \t\t\t\t};\n \t\t\t\tlinkTag.href = fullhref;\n\n \t\t\t\tvar head = document.getElementsByTagName(\"head\")[0];\n \t\t\t\thead.appendChild(linkTag);\n \t\t\t}).then(function() {\n \t\t\t\tinstalledCssChunks[chunkId] = 0;\n \t\t\t}));\n \t\t}\n\n \t\t// JSONP chunk loading for javascript\n\n \t\tvar installedChunkData = installedChunks[chunkId];\n \t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n \t\t\t// a Promise means \"currently loading\".\n \t\t\tif(installedChunkData) {\n \t\t\t\tpromises.push(installedChunkData[2]);\n \t\t\t} else {\n \t\t\t\t// setup Promise in chunk cache\n \t\t\t\tvar promise = new Promise(function(resolve, reject) {\n \t\t\t\t\tinstalledChunkData = installedChunks[chunkId] = [resolve, reject];\n \t\t\t\t});\n \t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n \t\t\t\t// start chunk loading\n \t\t\t\tvar script = document.createElement('script');\n \t\t\t\tvar onScriptComplete;\n\n \t\t\t\tscript.charset = 'utf-8';\n \t\t\t\tscript.timeout = 120;\n \t\t\t\tif (__webpack_require__.nc) {\n \t\t\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n \t\t\t\t}\n \t\t\t\tscript.src = jsonpScriptSrc(chunkId);\n\n \t\t\t\t// create error before stack unwound to get useful stacktrace later\n \t\t\t\tvar error = new Error();\n \t\t\t\tonScriptComplete = function (event) {\n \t\t\t\t\t// avoid mem leaks in IE.\n \t\t\t\t\tscript.onerror = script.onload = null;\n \t\t\t\t\tclearTimeout(timeout);\n \t\t\t\t\tvar chunk = installedChunks[chunkId];\n \t\t\t\t\tif(chunk !== 0) {\n \t\t\t\t\t\tif(chunk) {\n \t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n \t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n \t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n \t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n \t\t\t\t\t\t\terror.type = errorType;\n \t\t\t\t\t\t\terror.request = realSrc;\n \t\t\t\t\t\t\tchunk[1](error);\n \t\t\t\t\t\t}\n \t\t\t\t\t\tinstalledChunks[chunkId] = undefined;\n \t\t\t\t\t}\n \t\t\t\t};\n \t\t\t\tvar timeout = setTimeout(function(){\n \t\t\t\t\tonScriptComplete({ type: 'timeout', target: script });\n \t\t\t\t}, 120000);\n \t\t\t\tscript.onerror = script.onload = onScriptComplete;\n \t\t\t\tdocument.head.appendChild(script);\n \t\t\t}\n \t\t}\n \t\treturn Promise.all(promises);\n \t};\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// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/wp-content/themes/360vier-theme/dist/\";\n\n \t// on error function for async loading\n \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n\n \tvar jsonpArray = window[\"webpackJsonp\"] = window[\"webpackJsonp\"] || [];\n \tvar oldJsonpFunction = jsonpArray.push.bind(jsonpArray);\n \tjsonpArray.push = webpackJsonpCallback;\n \tjsonpArray = jsonpArray.slice();\n \tfor(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);\n \tvar parentJsonpFunction = oldJsonpFunction;\n\n\n \t// add entry module to deferred list\n \tdeferredModules.push([0,9]);\n \t// run deferred modules when ready\n \treturn checkDeferredModules();\n","import { __ } from '@wordpress/i18n'\n\nexport default {\n  message: __('Share via QR Code', 'dhsv_theme'),\n  downloadMessage: __('Download QR Code', 'dhsv_theme'),\n}\n","/* global System */\n// register component(s) with react habitat\nimport codeSplit from 'scripts/higher-order-components/codeSplit'\nimport l10n from './l10n'\n\nexport default {\n  QRCodeGenerator: codeSplit({\n    l10n,\n    loadComponent: () =>\n      System.import(\n        /* webpackChunkName: \"QRCodeGenerator\" */\n        './index'\n      ),\n  }),\n}\n","var map = {\n\t\"./ExampleComponent/habitat.js\": \"Q3E4\",\n\t\"./QRCodeComponent/habitat.js\": \"+Rn0\"\n};\n\n\nfunction webpackContext(req) {\n\tvar id = webpackContextResolve(req);\n\treturn __webpack_require__(id);\n}\nfunction webpackContextResolve(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\n\treturn map[req];\n}\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = \"3Y+R\";","import React, { Suspense, lazy } from 'react'\n\n/*\n\t\n\tcode-split out component, passing translations via props\n\tso we can have both: code splitting and l10n via @wordpress/i18n\n\t(because @wordpress/i18n can not translate strings inside split chunks)\n\n*/\n\nconst codeSplit = ({ loadComponent, l10n = {}, loadingIndicator = null }) => {\n  const CodeSplit = props => {\n    const Component = lazy(loadComponent)\n    return (\n      <Suspense fallback={loadingIndicator}>\n        <Component l10n={l10n} {...props} />\n      </Suspense>\n    )\n  }\n\n  return CodeSplit\n}\n\nexport default codeSplit\n","/* global System */\n// register component(s) with react habitat\nimport codeSplit from 'scripts/higher-order-components/codeSplit'\nimport l10n from './l10n'\n\nexport default {\n  ExampleComponent: codeSplit({\n    l10n,\n    loadComponent: () =>\n      System.import(\n        /* webpackChunkName: \"ExampleComponent\" */\n        './index'\n      ),\n  }),\n}\n","(function() { module.exports = window[\"wp\"][\"domReady\"]; }());","/**\n * the most terrible camelizer on the internet, guaranteed!\n * @param {string} str String that isn't camel-case, e.g., CAMeL_CaSEiS-harD\n * @return {string} String converted to camel-case, e.g., camelCaseIsHard\n */\nexport default str =>\n  `${str.charAt(0).toLowerCase()}${str\n    .replace(/[\\W_]/g, '|')\n    .split('|')\n    .map(part => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)\n    .join('')\n    .slice(1)}`\n","import camelCase from './camelCase'\n\n/**\n * DOM-based Routing\n *\n * Based on {@link http://goo.gl/EUTi53|Markup-based Unobtrusive Comprehensive DOM-ready Execution} by Paul Irish\n *\n * The routing fires all common scripts, followed by the page specific scripts.\n * Add additional events for more control over timing e.g. a finalize event\n */\nclass Router {\n  /**\n   * Create a new Router\n   * @param {Object} routes\n   */\n  constructor(routes) {\n    this.routes = routes\n  }\n\n  /**\n   * Fire Router events\n   * @param {string} route DOM-based route derived from body classes (`<body class=\"...\"><h1><a href="/">²ÊÉñix¹ÙÍø</a></h1>`)\n   * @param {string} [event] Events on the route. By default, `init` and `finalize` events are called.\n   * @param {string} [arg] Any custom argument to be passed to the event.\n   */\n  fire(route, event = 'init', arg) {\n    const fire =\n      route !== '' &&\n      this.routes[route] &&\n      typeof this.routes[route][event] === 'function'\n    if (fire) {\n      this.routes[route][event](arg)\n    }\n  }\n\n  /**\n   * Automatically load and fire Router events\n   *\n   * Events are fired in the following order:\n   *  * common init\n   *  * page-specific init\n   *  * page-specific finalize\n   *  * common finalize\n   */\n  loadEvents() {\n    // Fire common init JS\n    this.fire('common')\n\n    // Fire page-specific init JS, and then finalize JS\n    document.body.className\n      .toLowerCase()\n      .replace(/-/g, '_')\n      .split(/\\s+/)\n      .map(camelCase)\n      .forEach(className => {\n        this.fire(className)\n        this.fire(className, 'finalize')\n      })\n\n    // Fire common finalize JS\n    this.fire('common', 'finalize')\n  }\n}\n\nexport default Router\n","import domReady from '@wordpress/dom-ready'\n\nexport default {\n  init() {\n    stickyContact()\n    blankTmplStickyHeader()\n  },\n  finalize() {\n    // JavaScript to be fired on all pages, after page specific JS is fired\n  },\n}\n\nfunction stickyContact() {\n  const button = document.querySelector('.sticky-contact button')\n  console.log(button) //eslint-disable-line\n}\n\n// Stikcy header on blank with logo template\nfunction blankTmplStickyHeader() {\n  let blankTmplHeader = document.querySelector('.js-blank-tmpl-logo')\n\n  if (blankTmplHeader) {\n    window.addEventListener('scroll', function () {\n      if (window.scrollY > 200) {\n        blankTmplHeader.classList.add('is-sticky')\n      } else {\n        blankTmplHeader.classList.remove('is-sticky')\n      }\n    })\n  }\n}\n\ndomReady(() => {\n  setMultiSelectHeight()\n})\n\nfunction setMultiSelectHeight() {\n  const selects = document.querySelectorAll('.gfield select[multiple]')\n  selects.forEach(select => {\n    select.size = select.options.length < 5 ? select.options.length : 5\n  })\n}\n","export const onDocumentReady = readyCallback => {\n  if (document.readyState !== 'loading') {\n    readyCallback()\n  } else {\n    window.addEventListener('DOMContentLoaded', readyCallback, false)\n  }\n}\n","// import everything from autoload\nimport './autoload/_bootstrap.js' // eslint-disable-line\n\n// import react habitat and react components\nimport './init/react'\n\n// import local dependencies\nimport Router from './util/Router'\nimport common from './routes/common'\nimport home from './routes/home'\nimport aboutUs from './routes/about'\n\nimport { onDocumentReady } from './util/events'\n\n/** Populate Router instance with DOM routes */\nconst routes = new Router({\n  // All pages\n  common,\n  // Home page\n  home,\n  // About Us page, note the change from about-us to aboutUs.\n  aboutUs,\n})\n\n// Load Events\nonDocumentReady(() => routes.loadEvents())\n","export default {\n  init() {\n    // JavaScript to be fired on the home page\n  },\n  finalize() {\n    // JavaScript to be fired on the home page, after the init JS\n  },\n}\n","export default {\n  init() {\n    // JavaScript to be fired on the about us page\n  },\n}\n","(function() { module.exports = window[\"React\"]; }());","import { __ } from '@wordpress/i18n'\n\nexport default { message: __('React is working :)', 'dhsv_theme') }\n","(function() { module.exports = window[\"ReactDOM\"]; }());","(function() { module.exports = window[\"wp\"][\"i18n\"]; }());","function webpackEmptyContext(req) {\n\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\te.code = 'MODULE_NOT_FOUND';\n\tthrow e;\n}\nwebpackEmptyContext.keys = function() { return []; };\nwebpackEmptyContext.resolve = webpackEmptyContext;\nmodule.exports = webpackEmptyContext;\nwebpackEmptyContext.id = \"lUg7\";","export default function _isPlaceholder(a) {\n  return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}","import _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n}","import _curry1 from \"./_curry1.js\";\nimport _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n\n      case 1:\n        return _isPlaceholder(a) ? f2 : _curry1(function (_b) {\n          return fn(a, _b);\n        });\n\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b);\n        }) : fn(a, b);\n    }\n  };\n}","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nexport default Array.isArray || function _isArray(val) {\n  return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n};","export default function _isTransformer(obj) {\n  return obj != null && typeof obj['@@transducer/step'] === 'function';\n}","import _isArray from \"./_isArray.js\";\nimport _isTransformer from \"./_isTransformer.js\";\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a function with one of the given method names, it will\n * execute that function (functor case). Otherwise, if it is a transformer,\n * uses transducer created by [transducerCreator] to return a new transformer\n * (transducer case).\n * Otherwise, it will default to executing [fn].\n *\n * @private\n * @param {Array} methodNames properties to check for a custom implementation\n * @param {Function} transducerCreator transducer factory if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\n\nexport default function _dispatchable(methodNames, transducerCreator, fn) {\n  return function () {\n    if (arguments.length === 0) {\n      return fn();\n    }\n\n    var obj = arguments[arguments.length - 1];\n\n    if (!_isArray(obj)) {\n      var idx = 0;\n\n      while (idx < methodNames.length) {\n        if (typeof obj[methodNames[idx]] === 'function') {\n          return obj[methodNames[idx]].apply(obj, Array.prototype.slice.call(arguments, 0, -1));\n        }\n\n        idx += 1;\n      }\n\n      if (_isTransformer(obj)) {\n        var transducer = transducerCreator.apply(null, Array.prototype.slice.call(arguments, 0, -1));\n        return transducer(obj);\n      }\n    }\n\n    return fn.apply(this, arguments);\n  };\n}","export default function _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n}","import _curry1 from \"./_curry1.js\";\nimport _isArray from \"./_isArray.js\";\nimport _isString from \"./_isString.js\";\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @private\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      _isArrayLike([]); //=> true\n *      _isArrayLike(true); //=> false\n *      _isArrayLike({}); //=> false\n *      _isArrayLike({length: 10}); //=> false\n *      _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n *      _isArrayLike({nodeType: 1, length: 1}) // => false\n */\n\nvar _isArrayLike =\n/*#__PURE__*/\n_curry1(function isArrayLike(x) {\n  if (_isArray(x)) {\n    return true;\n  }\n\n  if (!x) {\n    return false;\n  }\n\n  if (typeof x !== 'object') {\n    return false;\n  }\n\n  if (_isString(x)) {\n    return false;\n  }\n\n  if (x.length === 0) {\n    return true;\n  }\n\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n\n  return false;\n});\n\nexport default _isArrayLike;","var XWrap =\n/*#__PURE__*/\nfunction () {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n\n  XWrap.prototype['@@transducer/init'] = function () {\n    throw new Error('init not implemented on XWrap');\n  };\n\n  XWrap.prototype['@@transducer/result'] = function (acc) {\n    return acc;\n  };\n\n  XWrap.prototype['@@transducer/step'] = function (acc, x) {\n    return this.f(acc, x);\n  };\n\n  return XWrap;\n}();\n\nexport default function _xwrap(fn) {\n  return new XWrap(fn);\n}","export default function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0:\n      return function () {\n        return fn.apply(this, arguments);\n      };\n\n    case 1:\n      return function (a0) {\n        return fn.apply(this, arguments);\n      };\n\n    case 2:\n      return function (a0, a1) {\n        return fn.apply(this, arguments);\n      };\n\n    case 3:\n      return function (a0, a1, a2) {\n        return fn.apply(this, arguments);\n      };\n\n    case 4:\n      return function (a0, a1, a2, a3) {\n        return fn.apply(this, arguments);\n      };\n\n    case 5:\n      return function (a0, a1, a2, a3, a4) {\n        return fn.apply(this, arguments);\n      };\n\n    case 6:\n      return function (a0, a1, a2, a3, a4, a5) {\n        return fn.apply(this, arguments);\n      };\n\n    case 7:\n      return function (a0, a1, a2, a3, a4, a5, a6) {\n        return fn.apply(this, arguments);\n      };\n\n    case 8:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n        return fn.apply(this, arguments);\n      };\n\n    case 9:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n        return fn.apply(this, arguments);\n      };\n\n    case 10:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n        return fn.apply(this, arguments);\n      };\n\n    default:\n      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n}","import _arity from \"./internal/_arity.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @category Object\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n * @see R.partial\n * @example\n *\n *      const log = R.bind(console.log, console);\n *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}\n *      // logs {a: 2}\n * @symb R.bind(f, o)(a, b) = f.call(o, a, b)\n */\n\nvar bind =\n/*#__PURE__*/\n_curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function () {\n    return fn.apply(thisObj, arguments);\n  });\n});\n\nexport default bind;","import _isArrayLike from \"./_isArrayLike.js\";\nimport _xwrap from \"./_xwrap.js\";\nimport bind from \"../bind.js\";\n\nfunction _arrayReduce(xf, acc, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    acc = xf['@@transducer/step'](acc, list[idx]);\n\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n\n    idx += 1;\n  }\n\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _iterableReduce(xf, acc, iter) {\n  var step = iter.next();\n\n  while (!step.done) {\n    acc = xf['@@transducer/step'](acc, step.value);\n\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n\n    step = iter.next();\n  }\n\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _methodReduce(xf, acc, obj, methodName) {\n  return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));\n}\n\nvar symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\nexport default function _reduce(fn, acc, list) {\n  if (typeof fn === 'function') {\n    fn = _xwrap(fn);\n  }\n\n  if (_isArrayLike(list)) {\n    return _arrayReduce(fn, acc, list);\n  }\n\n  if (typeof list['fantasy-land/reduce'] === 'function') {\n    return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\n  }\n\n  if (list[symIterator] != null) {\n    return _iterableReduce(fn, acc, list[symIterator]());\n  }\n\n  if (typeof list.next === 'function') {\n    return _iterableReduce(fn, acc, list);\n  }\n\n  if (typeof list.reduce === 'function') {\n    return _methodReduce(fn, acc, list, 'reduce');\n  }\n\n  throw new TypeError('reduce: list must be array or iterable');\n}","export default {\n  init: function () {\n    return this.xf['@@transducer/init']();\n  },\n  result: function (result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};","import _forceReduced from \"./_forceReduced.js\";\nimport _isArrayLike from \"./_isArrayLike.js\";\nimport _reduce from \"./_reduce.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar preservingReduced = function (xf) {\n  return {\n    '@@transducer/init': _xfBase.init,\n    '@@transducer/result': function (result) {\n      return xf['@@transducer/result'](result);\n    },\n    '@@transducer/step': function (result, input) {\n      var ret = xf['@@transducer/step'](result, input);\n      return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n    }\n  };\n};\n\nvar _flatCat = function _xcat(xf) {\n  var rxf = preservingReduced(xf);\n  return {\n    '@@transducer/init': _xfBase.init,\n    '@@transducer/result': function (result) {\n      return rxf['@@transducer/result'](result);\n    },\n    '@@transducer/step': function (result, input) {\n      return !_isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n    }\n  };\n};\n\nexport default _flatCat;","export default function _forceReduced(x) {\n  return {\n    '@@transducer/value': x,\n    '@@transducer/reduced': true\n  };\n}","export default function _map(fn, functor) {\n  var idx = 0;\n  var len = functor.length;\n  var result = Array(len);\n\n  while (idx < len) {\n    result[idx] = fn(functor[idx]);\n    idx += 1;\n  }\n\n  return result;\n}","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XMap =\n/*#__PURE__*/\nfunction () {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n\n  XMap.prototype['@@transducer/step'] = function (result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return XMap;\n}();\n\nvar _xmap =\n/*#__PURE__*/\n_curry2(function _xmap(f, xf) {\n  return new XMap(f, xf);\n});\n\nexport default _xmap;","import _arity from \"./_arity.js\";\nimport _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curryN(length, received, fn) {\n  return function () {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n\n      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n\n      combined[combinedIdx] = result;\n\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n\n      combinedIdx += 1;\n    }\n\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n}","import _arity from \"./internal/_arity.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _curryN from \"./internal/_curryN.js\";\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      const sumArgs = (...args) => R.sum(args);\n *\n *      const curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\nvar curryN =\n/*#__PURE__*/\n_curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n\n  return _arity(length, _curryN(length, [], fn));\n});\n\nexport default curryN;","export default function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}","import _has from \"./_has.js\";\nvar toString = Object.prototype.toString;\n\nvar _isArguments =\n/*#__PURE__*/\nfunction () {\n  return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {\n    return toString.call(x) === '[object Arguments]';\n  } : function _isArguments(x) {\n    return _has('callee', x);\n  };\n}();\n\nexport default _isArguments;","import _curry1 from \"./internal/_curry1.js\";\nimport _has from \"./internal/_has.js\";\nimport _isArguments from \"./internal/_isArguments.js\"; // cover IE < 9 keys issues\n\nvar hasEnumBug = !\n/*#__PURE__*/\n{\n  toString: null\n}.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; // Safari bug\n\nvar hasArgsEnumBug =\n/*#__PURE__*/\nfunction () {\n  'use strict';\n\n  return arguments.propertyIsEnumerable('length');\n}();\n\nvar contains = function contains(list, item) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (list[idx] === item) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n};\n/**\n * Returns a list containing the names of all the enumerable own properties of\n * the supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @see R.keysIn, R.values, R.toPairs\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\n\n\nvar keys = typeof Object.keys === 'function' && !hasArgsEnumBug ?\n/*#__PURE__*/\n_curry1(function keys(obj) {\n  return Object(obj) !== obj ? [] : Object.keys(obj);\n}) :\n/*#__PURE__*/\n_curry1(function keys(obj) {\n  if (Object(obj) !== obj) {\n    return [];\n  }\n\n  var prop, nIdx;\n  var ks = [];\n\n  var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n\n  for (prop in obj) {\n    if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n      ks[ks.length] = prop;\n    }\n  }\n\n  if (hasEnumBug) {\n    nIdx = nonEnumerableProps.length - 1;\n\n    while (nIdx >= 0) {\n      prop = nonEnumerableProps[nIdx];\n\n      if (_has(prop, obj) && !contains(ks, prop)) {\n        ks[ks.length] = prop;\n      }\n\n      nIdx -= 1;\n    }\n  }\n\n  return ks;\n});\nexport default keys;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _map from \"./internal/_map.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _xmap from \"./internal/_xmap.js\";\nimport curryN from \"./curryN.js\";\nimport keys from \"./keys.js\";\n/**\n * Takes a function and\n * a [functor](https://github.com/fantasyland/fantasy-land#functor),\n * applies the function to each of the functor's values, and returns\n * a functor of the same shape.\n *\n * Ramda provides suitable `map` implementations for `Array` and `Object`,\n * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.\n *\n * Dispatches to the `map` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * Also treats functions as functors and will compose them together.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => (a -> b) -> f a -> f b\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @see R.transduce, R.addIndex, R.pluck, R.project\n * @example\n *\n *      const double = x => x * 2;\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n *\n *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}\n * @symb R.map(f, [a, b]) = [f(a), f(b)]\n * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }\n * @symb R.map(f, functor_o) = functor_o.map(f)\n */\n\nvar map =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {\n  switch (Object.prototype.toString.call(functor)) {\n    case '[object Function]':\n      return curryN(functor.length, function () {\n        return fn.call(this, functor.apply(this, arguments));\n      });\n\n    case '[object Object]':\n      return _reduce(function (acc, key) {\n        acc[key] = fn(functor[key]);\n        return acc;\n      }, {}, keys(functor));\n\n    default:\n      return _map(fn, functor);\n  }\n}));\n\nexport default map;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _makeFlat from \"./internal/_makeFlat.js\";\nimport _xchain from \"./internal/_xchain.js\";\nimport map from \"./map.js\";\n/**\n * `chain` maps a function over a list and concatenates the results. `chain`\n * is also known as `flatMap` in some libraries.\n *\n * Dispatches to the `chain` method of the second argument, if present,\n * according to the [FantasyLand Chain spec](https://github.com/fantasyland/fantasy-land#chain).\n *\n * If second argument is a function, `chain(f, g)(x)` is equivalent to `f(g(x), x)`.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig Chain m => (a -> m b) -> m a -> m b\n * @param {Function} fn The function to map with\n * @param {Array} list The list to map over\n * @return {Array} The result of flat-mapping `list` with `fn`\n * @example\n *\n *      const duplicate = n => [n, n];\n *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n *\n *      R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1]\n */\n\nvar chain =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/chain', 'chain'], _xchain, function chain(fn, monad) {\n  if (typeof monad === 'function') {\n    return function (x) {\n      return fn(monad(x))(x);\n    };\n  }\n\n  return _makeFlat(false)(map(fn, monad));\n}));\n\nexport default chain;","import _curry2 from \"./_curry2.js\";\nimport _flatCat from \"./_flatCat.js\";\nimport map from \"../map.js\";\n\nvar _xchain =\n/*#__PURE__*/\n_curry2(function _xchain(f, xf) {\n  return map(f, _flatCat(xf));\n});\n\nexport default _xchain;","import _isArrayLike from \"./_isArrayLike.js\";\n/**\n * `_makeFlat` is a helper function that returns a one-level or fully recursive\n * function based on the flag passed in.\n *\n * @private\n */\n\nexport default function _makeFlat(recursive) {\n  return function flatt(list) {\n    var value, jlen, j;\n    var result = [];\n    var idx = 0;\n    var ilen = list.length;\n\n    while (idx < ilen) {\n      if (_isArrayLike(list[idx])) {\n        value = recursive ? flatt(list[idx]) : list[idx];\n        j = 0;\n        jlen = value.length;\n\n        while (j < jlen) {\n          result[result.length] = value[j];\n          j += 1;\n        }\n      } else {\n        result[result.length] = list[idx];\n      }\n\n      idx += 1;\n    }\n\n    return result;\n  };\n}","export default function _pipe(f, g) {\n  return function () {\n    return g.call(this, f.apply(this, arguments));\n  };\n}","import _curry1 from \"./_curry1.js\";\nimport _curry2 from \"./_curry2.js\";\nimport _isPlaceholder from \"./_isPlaceholder.js\";\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\nexport default function _curry3(fn) {\n  return function f3(a, b, c) {\n    switch (arguments.length) {\n      case 0:\n        return f3;\n\n      case 1:\n        return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        });\n\n      case 2:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _curry1(function (_c) {\n          return fn(a, b, _c);\n        });\n\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {\n          return fn(_a, _b, c);\n        }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b, c);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b, c);\n        }) : _isPlaceholder(c) ? _curry1(function (_c) {\n          return fn(a, b, _c);\n        }) : fn(a, b, c);\n    }\n  };\n}","import _curry3 from \"./internal/_curry3.js\";\nimport _reduce from \"./internal/_reduce.js\";\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It may use\n * [`R.reduced`](#reduced) to shortcut the iteration.\n *\n * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function\n * is *(value, acc)*.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduce` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n *\n * Dispatches to the `reduce` method of the third argument, if present. When\n * doing so, it is up to the user to handle the [`R.reduced`](#reduced)\n * shortcuting, as this is not implemented by `reduce`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduced, R.addIndex, R.reduceRight\n * @example\n *\n *      R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10\n *      //          -               -10\n *      //         / \\              / \\\n *      //        -   4           -6   4\n *      //       / \\              / \\\n *      //      -   3   ==>     -3   3\n *      //     / \\              / \\\n *      //    -   2           -1   2\n *      //   / \\              / \\\n *      //  0   1            0   1\n *\n * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)\n */\n\nvar reduce =\n/*#__PURE__*/\n_curry3(_reduce);\n\nexport default reduce;","import _isArray from \"./_isArray.js\";\n/**\n * This checks whether a function has a [methodname] function. If it isn't an\n * array it will execute that function otherwise it will default to the ramda\n * implementation.\n *\n * @private\n * @param {Function} fn ramda implementation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\n\nexport default function _checkForMethod(methodname, fn) {\n  return function () {\n    var length = arguments.length;\n\n    if (length === 0) {\n      return fn();\n    }\n\n    var obj = arguments[length - 1];\n    return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));\n  };\n}","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry3 from \"./internal/_curry3.js\";\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * Dispatches to the `slice` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\n\nvar slice =\n/*#__PURE__*/\n_curry3(\n/*#__PURE__*/\n_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n\nexport default slice;","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * Dispatches to the `slice` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.head, R.init, R.last\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\n\nvar tail =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_checkForMethod('tail',\n/*#__PURE__*/\nslice(1, Infinity)));\n\nexport default tail;","import _arity from \"./internal/_arity.js\";\nimport _pipe from \"./internal/_pipe.js\";\nimport reduce from \"./reduce.js\";\nimport tail from \"./tail.js\";\n/**\n * Performs left-to-right function composition. The first argument may have\n * any arity; the remaining arguments must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * **Note:** The result of pipe is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      const f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))\n * @symb R.pipe(f, g, h)(a)(b) = h(g(f(a)))(b)\n */\n\nexport default function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n\n  return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _isString from \"./internal/_isString.js\";\n/**\n * Returns a new list or string with the elements or characters in reverse\n * order.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {Array|String} list\n * @return {Array|String}\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n *\n *      R.reverse('abc');      //=> 'cba'\n *      R.reverse('ab');       //=> 'ba'\n *      R.reverse('a');        //=> 'a'\n *      R.reverse('');         //=> ''\n */\n\nvar reverse =\n/*#__PURE__*/\n_curry1(function reverse(list) {\n  return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();\n});\n\nexport default reverse;","import pipe from \"./pipe.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Performs right-to-left function composition. The last argument may have\n * any arity; the remaining arguments must be unary.\n *\n * **Note:** The result of compose is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)\n * @param {...Function} ...functions The functions to compose\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      const classyGreeting = (firstName, lastName) => \"The name's \" + lastName + \", \" + firstName + \" \" + lastName\n *      const yellGreeting = R.compose(R.toUpper, classyGreeting);\n *      yellGreeting('James', 'Bond'); //=> \"THE NAME'S BOND, JAMES BOND\"\n *\n *      R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7\n *\n * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))\n * @symb R.compose(f, g, h)(a)(b) = f(g(h(a)))(b)\n */\n\nexport default function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n\n  return pipe.apply(this, reverse(arguments));\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Converts an object into an array of key, value arrays. Only the object's\n * own properties are used.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Object\n * @sig {String: *} -> [[String,*]]\n * @param {Object} obj The object to extract from\n * @return {Array} An array of key, value arrays from the object's own properties.\n * @see R.fromPairs, R.keys, R.values\n * @example\n *\n *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n */\n\nvar toPairs =\n/*#__PURE__*/\n_curry1(function toPairs(obj) {\n  var pairs = [];\n\n  for (var prop in obj) {\n    if (_has(prop, obj)) {\n      pairs[pairs.length] = [prop, obj[prop]];\n    }\n  }\n\n  return pairs;\n});\n\nexport default toPairs;","/*\n * this factory adds the react-redux provider\n * */\nimport React from 'react'\nimport ReactDOM from 'react-dom'\n\nexport default class DomFactory {\n  /**\n   * Injects a react component\n   * @param {object}\t\t\tmodule\t\t- The react component\n   * @param {object}\t\t\tprops\t\t- Props to initiate component with\n   * @param {HTMLElement}\t\ttarget\t\t- The target element to inject to\n   */\n  inject(module, props = {}, target) {\n    if (target) {\n      ReactDOM.render(React.createElement(module, props || {}), target)\n    } else {\n      // eslint-disable-next-line\n      console.warn('RHW07', 'Target element is null or undefined.')\n    }\n  }\n\n  /**\n   *  Disposes a react component\n   * @param {HTMLElement}\t\ttarget\t\t- The target element to dispose\n   */\n  dispose(target) {\n    if (target) {\n      ReactDOM.unmountComponentAtNode(target)\n    }\n  }\n}\n","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Returns a curried equivalent of the provided function. The curried function\n * has two unusual capabilities. First, its arguments needn't be provided one\n * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN, R.partial\n * @example\n *\n *      const addFourNumbers = (a, b, c, d) => a + b + c + d;\n *\n *      const curriedAddFourNumbers = R.curry(addFourNumbers);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\nvar curry =\n/*#__PURE__*/\n_curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n\nexport default curry;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Creates a new object from a list key-value pairs. If a key appears in\n * multiple pairs, the rightmost pair is included in the object.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [[k,v]] -> {k: v}\n * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n * @return {Object} The object made by pairing up `keys` and `values`.\n * @see R.toPairs, R.pair\n * @example\n *\n *      R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n */\n\nvar fromPairs =\n/*#__PURE__*/\n_curry1(function fromPairs(pairs) {\n  var result = {};\n  var idx = 0;\n\n  while (idx < pairs.length) {\n    result[pairs[idx][0]] = pairs[idx][1];\n    idx += 1;\n  }\n\n  return result;\n});\n\nexport default fromPairs;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Takes two arguments, `fst` and `snd`, and returns `[fst, snd]`.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category List\n * @sig a -> b -> (a,b)\n * @param {*} fst\n * @param {*} snd\n * @return {Array}\n * @see R.objOf, R.of\n * @example\n *\n *      R.pair('foo', 'bar'); //=> ['foo', 'bar']\n */\n\nvar pair =\n/*#__PURE__*/\n_curry2(function pair(fst, snd) {\n  return [fst, snd];\n});\n\nexport default pair;","export default function _identity(x) {\n  return x;\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _identity from \"./internal/_identity.js\";\n/**\n * A function that does nothing but return the parameter supplied to it. Good\n * as a default or placeholder function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> a\n * @param {*} x The value to return.\n * @return {*} The input value, `x`.\n * @example\n *\n *      R.identity(1); //=> 1\n *\n *      const obj = {};\n *      R.identity(obj) === obj; //=> true\n * @symb R.identity(a) = a\n */\n\nvar identity =\n/*#__PURE__*/\n_curry1(_identity);\n\nexport default identity;","export default function _arrayFromIterator(iter) {\n  var list = [];\n  var next;\n\n  while (!(next = iter.next()).done) {\n    list.push(next.value);\n  }\n\n  return list;\n}","export default function _includesWith(pred, x, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (pred(x, list[idx])) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n}","// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\nfunction _objectIs(a, b) {\n  // SameValue algorithm\n  if (a === b) {\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n}\n\nexport default typeof Object.is === 'function' ? Object.is : _objectIs;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Gives a single-word string description of the (native) type of a value,\n * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not\n * attempt to distinguish user Object types any further, reporting them all as\n * 'Object'.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n *      R.type(() => {}); //=> \"Function\"\n *      R.type(undefined); //=> \"Undefined\"\n */\n\nvar type =\n/*#__PURE__*/\n_curry1(function type(val) {\n  return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n});\n\nexport default type;","import _arrayFromIterator from \"./_arrayFromIterator.js\";\nimport _includesWith from \"./_includesWith.js\";\nimport _functionName from \"./_functionName.js\";\nimport _has from \"./_has.js\";\nimport _objectIs from \"./_objectIs.js\";\nimport keys from \"../keys.js\";\nimport type from \"../type.js\";\n/**\n * private _uniqContentEquals function.\n * That function is checking equality of 2 iterator contents with 2 assumptions\n * - iterators lengths are the same\n * - iterators values are unique\n *\n * false-positive result will be returned for comparison of, e.g.\n * - [1,2,3] and [1,2,3,4]\n * - [1,1,1] and [1,2,3]\n * */\n\nfunction _uniqContentEquals(aIterator, bIterator, stackA, stackB) {\n  var a = _arrayFromIterator(aIterator);\n\n  var b = _arrayFromIterator(bIterator);\n\n  function eq(_a, _b) {\n    return _equals(_a, _b, stackA.slice(), stackB.slice());\n  } // if *a* array contains any element that is not included in *b*\n\n\n  return !_includesWith(function (b, aItem) {\n    return !_includesWith(eq, aItem, b);\n  }, b, a);\n}\n\nexport default function _equals(a, b, stackA, stackB) {\n  if (_objectIs(a, b)) {\n    return true;\n  }\n\n  var typeA = type(a);\n\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {\n    return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);\n  }\n\n  if (typeof a.equals === 'function' || typeof b.equals === 'function') {\n    return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);\n  }\n\n  switch (typeA) {\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n      if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {\n        return a === b;\n      }\n\n      break;\n\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n      if (!(typeof a === typeof b && _objectIs(a.valueOf(), b.valueOf()))) {\n        return false;\n      }\n\n      break;\n\n    case 'Date':\n      if (!_objectIs(a.valueOf(), b.valueOf())) {\n        return false;\n      }\n\n      break;\n\n    case 'Error':\n      return a.name === b.name && a.message === b.message;\n\n    case 'RegExp':\n      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {\n        return false;\n      }\n\n      break;\n  }\n\n  var idx = stackA.length - 1;\n\n  while (idx >= 0) {\n    if (stackA[idx] === a) {\n      return stackB[idx] === b;\n    }\n\n    idx -= 1;\n  }\n\n  switch (typeA) {\n    case 'Map':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));\n\n    case 'Set':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));\n\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n    case 'Date':\n    case 'Error':\n    case 'RegExp':\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'ArrayBuffer':\n      break;\n\n    default:\n      // Values of other types are only equal if identical.\n      return false;\n  }\n\n  var keysA = keys(a);\n\n  if (keysA.length !== keys(b).length) {\n    return false;\n  }\n\n  var extendedStackA = stackA.concat([a]);\n  var extendedStackB = stackB.concat([b]);\n  idx = keysA.length - 1;\n\n  while (idx >= 0) {\n    var key = keysA[idx];\n\n    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {\n      return false;\n    }\n\n    idx -= 1;\n  }\n\n  return true;\n}","export default function _functionName(f) {\n  // String(x => x) evaluates to \"x => x\", so the pattern may not match.\n  var match = String(f).match(/^function (\\w*)/);\n  return match == null ? '' : match[1];\n}","import _curry2 from \"./internal/_curry2.js\";\nimport _equals from \"./internal/_equals.js\";\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise. Handles\n * cyclical data structures.\n *\n * Dispatches symmetrically to the `equals` methods of both arguments, if\n * present.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      const a = {}; a.v = a;\n *      const b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\n\nvar equals =\n/*#__PURE__*/\n_curry2(function equals(a, b) {\n  return _equals(a, b, [], []);\n});\n\nexport default equals;","import _indexOf from \"./_indexOf.js\";\nexport default function _includes(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n}","import equals from \"../equals.js\";\nexport default function _indexOf(list, a, idx) {\n  var inf, item; // Array.prototype.indexOf doesn't exist below IE9\n\n  if (typeof list.indexOf === 'function') {\n    switch (typeof a) {\n      case 'number':\n        if (a === 0) {\n          // manually crawl the list to distinguish between +0 and -0\n          inf = 1 / a;\n\n          while (idx < list.length) {\n            item = list[idx];\n\n            if (item === 0 && 1 / item === inf) {\n              return idx;\n            }\n\n            idx += 1;\n          }\n\n          return -1;\n        } else if (a !== a) {\n          // NaN\n          while (idx < list.length) {\n            item = list[idx];\n\n            if (typeof item === 'number' && item !== item) {\n              return idx;\n            }\n\n            idx += 1;\n          }\n\n          return -1;\n        } // non-zero numbers can utilise Set\n\n\n        return list.indexOf(a, idx);\n      // all these types can utilise Set\n\n      case 'string':\n      case 'boolean':\n      case 'function':\n      case 'undefined':\n        return list.indexOf(a, idx);\n\n      case 'object':\n        if (a === null) {\n          // null can utilise Set\n          return list.indexOf(a, idx);\n        }\n\n    }\n  } // anything else not covered above, defer to R.equals\n\n\n  while (idx < list.length) {\n    if (equals(list[idx], a)) {\n      return idx;\n    }\n\n    idx += 1;\n  }\n\n  return -1;\n}","import _cloneRegExp from \"./_cloneRegExp.js\";\nimport type from \"../type.js\";\n/**\n * Copies an object.\n *\n * @private\n * @param {*} value The value to be copied\n * @param {Array} refFrom Array containing the source references\n * @param {Array} refTo Array containing the copied source references\n * @param {Boolean} deep Whether or not to perform deep cloning.\n * @return {*} The copied value.\n */\n\nexport default function _clone(value, refFrom, refTo, deep) {\n  var copy = function copy(copiedValue) {\n    var len = refFrom.length;\n    var idx = 0;\n\n    while (idx < len) {\n      if (value === refFrom[idx]) {\n        return refTo[idx];\n      }\n\n      idx += 1;\n    }\n\n    refFrom[idx] = value;\n    refTo[idx] = copiedValue;\n\n    for (var key in value) {\n      if (value.hasOwnProperty(key)) {\n        copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key];\n      }\n    }\n\n    return copiedValue;\n  };\n\n  switch (type(value)) {\n    case 'Object':\n      return copy(Object.create(Object.getPrototypeOf(value)));\n\n    case 'Array':\n      return copy([]);\n\n    case 'Date':\n      return new Date(value.valueOf());\n\n    case 'RegExp':\n      return _cloneRegExp(value);\n\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'BigInt64Array':\n    case 'BigUint64Array':\n      return value.slice();\n\n    default:\n      return value;\n  }\n}","export default function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n}","import _curryN from \"./_curryN.js\";\nimport _has from \"./_has.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XReduceBy =\n/*#__PURE__*/\nfunction () {\n  function XReduceBy(valueFn, valueAcc, keyFn, xf) {\n    this.valueFn = valueFn;\n    this.valueAcc = valueAcc;\n    this.keyFn = keyFn;\n    this.xf = xf;\n    this.inputs = {};\n  }\n\n  XReduceBy.prototype['@@transducer/init'] = _xfBase.init;\n\n  XReduceBy.prototype['@@transducer/result'] = function (result) {\n    var key;\n\n    for (key in this.inputs) {\n      if (_has(key, this.inputs)) {\n        result = this.xf['@@transducer/step'](result, this.inputs[key]);\n\n        if (result['@@transducer/reduced']) {\n          result = result['@@transducer/value'];\n          break;\n        }\n      }\n    }\n\n    this.inputs = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XReduceBy.prototype['@@transducer/step'] = function (result, input) {\n    var key = this.keyFn(input);\n    this.inputs[key] = this.inputs[key] || [key, this.valueAcc];\n    this.inputs[key][1] = this.valueFn(this.inputs[key][1], input);\n    return result;\n  };\n\n  return XReduceBy;\n}();\n\nvar _xreduceBy =\n/*#__PURE__*/\n_curryN(4, [], function _xreduceBy(valueFn, valueAcc, keyFn, xf) {\n  return new XReduceBy(valueFn, valueAcc, keyFn, xf);\n});\n\nexport default _xreduceBy;","import reduceBy from \"./reduceBy.js\";\n/**\n * Counts the elements of a list according to how many match each value of a\n * key generated by the supplied function. Returns an object mapping the keys\n * produced by `fn` to the number of occurrences in the list. Note that all\n * keys are coerced to strings because of how JavaScript objects work.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig (a -> String) -> [a] -> {*}\n * @param {Function} fn The function used to map values to keys.\n * @param {Array} list The list to count elements from.\n * @return {Object} An object mapping keys to number of occurrences in the list.\n * @example\n *\n *      const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n *\n *      const letters = ['a', 'b', 'A', 'a', 'B', 'c'];\n *      R.countBy(R.toLower)(letters);   //=> {'a': 3, 'b': 2, 'c': 1}\n */\n\nvar countBy =\n/*#__PURE__*/\nreduceBy(function (acc, elem) {\n  return acc + 1;\n}, 0);\nexport default countBy;","import _clone from \"./internal/_clone.js\";\nimport _curryN from \"./internal/_curryN.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _has from \"./internal/_has.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _reduced from \"./internal/_reduced.js\";\nimport _xreduceBy from \"./internal/_xreduceBy.js\";\n/**\n * Groups the elements of the list according to the result of calling\n * the String-returning function `keyFn` on each element and reduces the elements\n * of each group to a single value via the reducer function `valueFn`.\n *\n * The value function receives two values: *(acc, value)*. It may use\n * [`R.reduced`](#reduced) to short circuit the iteration.\n *\n * This function is basically a more general [`groupBy`](#groupBy) function.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category List\n * @sig ((a, b) -> a) -> a -> (b -> String) -> [b] -> {String: a}\n * @param {Function} valueFn The function that reduces the elements of each group to a single\n *        value. Receives two values, accumulator for a particular group and the current element.\n * @param {*} acc The (initial) accumulator value for each group.\n * @param {Function} keyFn The function that maps the list's element into a key.\n * @param {Array} list The array to group.\n * @return {Object} An object with the output of `keyFn` for keys, mapped to the output of\n *         `valueFn` for elements which produced that key when passed to `keyFn`.\n * @see R.groupBy, R.reduce, R.reduced\n * @example\n *\n *      const groupNames = (acc, {name}) => acc.concat(name)\n *      const toGrade = ({score}) =>\n *        score < 65 ? 'F' :\n *        score < 70 ? 'D' :\n *        score < 80 ? 'C' :\n *        score < 90 ? 'B' : 'A'\n *\n *      var students = [\n *        {name: 'Abby', score: 83},\n *        {name: 'Bart', score: 62},\n *        {name: 'Curt', score: 88},\n *        {name: 'Dora', score: 92},\n *      ]\n *\n *      reduceBy(groupNames, [], toGrade, students)\n *      //=> {\"A\": [\"Dora\"], \"B\": [\"Abby\", \"Curt\"], \"F\": [\"Bart\"]}\n */\n\nvar reduceBy =\n/*#__PURE__*/\n_curryN(4, [],\n/*#__PURE__*/\n_dispatchable([], _xreduceBy, function reduceBy(valueFn, valueAcc, keyFn, list) {\n  return _reduce(function (acc, elt) {\n    var key = keyFn(elt);\n    var value = valueFn(_has(key, acc) ? acc[key] : _clone(valueAcc, [], [], false), elt);\n\n    if (value && value['@@transducer/reduced']) {\n      return _reduced(acc);\n    }\n\n    acc[key] = value;\n    return acc;\n  }, {}, list);\n}));\n\nexport default reduceBy;","export default function _reduced(x) {\n  return x && x['@@transducer/reduced'] ? x : {\n    '@@transducer/value': x,\n    '@@transducer/reduced': true\n  };\n}","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFilter =\n/*#__PURE__*/\nfunction () {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n\n  XFilter.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return XFilter;\n}();\n\nvar _xfilter =\n/*#__PURE__*/\n_curry2(function _xfilter(f, xf) {\n  return new XFilter(f, xf);\n});\n\nexport default _xfilter;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _filter from \"./internal/_filter.js\";\nimport _isObject from \"./internal/_isObject.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _xfilter from \"./internal/_xfilter.js\";\nimport keys from \"./keys.js\";\n/**\n * Takes a predicate and a `Filterable`, and returns a new filterable of the\n * same type containing the members of the given filterable which satisfy the\n * given predicate. Filterable objects include plain objects or any object\n * that has a filter method such as `Array`.\n *\n * Dispatches to the `filter` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array} Filterable\n * @see R.reject, R.transduce, R.addIndex\n * @example\n *\n *      const isEven = n => n % 2 === 0;\n *\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\n\nvar filter =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/filter', 'filter'], _xfilter, function (pred, filterable) {\n  return _isObject(filterable) ? _reduce(function (acc, key) {\n    if (pred(filterable[key])) {\n      acc[key] = filterable[key];\n    }\n\n    return acc;\n  }, {}, keys(filterable)) : // else\n  _filter(pred, filterable);\n}));\n\nexport default filter;","export default function _isObject(x) {\n  return Object.prototype.toString.call(x) === '[object Object]';\n}","export default function _filter(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n\n    idx += 1;\n  }\n\n  return result;\n}","export default function _isFunction(x) {\n  var type = Object.prototype.toString.call(x);\n  return type === '[object Function]' || type === '[object AsyncFunction]' || type === '[object GeneratorFunction]' || type === '[object AsyncGeneratorFunction]';\n}","export default function _quote(s) {\n  var escaped = s.replace(/\\\\/g, '\\\\\\\\').replace(/[\\b]/g, '\\\\b') // \\b matches word boundary; [\\b] matches backspace\n  .replace(/\\f/g, '\\\\f').replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r').replace(/\\t/g, '\\\\t').replace(/\\v/g, '\\\\v').replace(/\\0/g, '\\\\0');\n  return '\"' + escaped.replace(/\"/g, '\\\\\"') + '\"';\n}","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nvar pad = function pad(n) {\n  return (n < 10 ? '0' : '') + n;\n};\n\nvar _toISOString = typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n  return d.toISOString();\n} : function _toISOString(d) {\n  return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n};\n\nexport default _toISOString;","import _complement from \"./internal/_complement.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport filter from \"./filter.js\";\n/**\n * The complement of [`filter`](#filter).\n *\n * Acts as a transducer if a transformer is given in list position. Filterable\n * objects include plain objects or any object that has a filter method such\n * as `Array`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array}\n * @see R.filter, R.transduce, R.addIndex\n * @example\n *\n *      const isOdd = (n) => n % 2 !== 0;\n *\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\n\nvar reject =\n/*#__PURE__*/\n_curry2(function reject(pred, filterable) {\n  return filter(_complement(pred), filterable);\n});\n\nexport default reject;","export default function _complement(f) {\n  return function () {\n    return !f.apply(this, arguments);\n  };\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _toString from \"./internal/_toString.js\";\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\n\nvar toString =\n/*#__PURE__*/\n_curry1(function toString(val) {\n  return _toString(val, []);\n});\n\nexport default toString;","import _includes from \"./_includes.js\";\nimport _map from \"./_map.js\";\nimport _quote from \"./_quote.js\";\nimport _toISOString from \"./_toISOString.js\";\nimport keys from \"../keys.js\";\nimport reject from \"../reject.js\";\nexport default function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _includes(y, xs) ? '<Circular>' : _toString(y, xs);\n  }; //  mapPairs :: (Object, [String]) -> [String]\n\n\n  var mapPairs = function (obj, keys) {\n    return _map(function (k) {\n      return _quote(k) + ': ' + recur(obj[k]);\n    }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {\n        return /^\\d+$/.test(k);\n      }, keys(x)))).join(', ') + ']';\n\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n\n    case '[object Date]':\n      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';\n\n    case '[object Null]':\n      return 'null';\n\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n\n    case '[object Undefined]':\n      return 'undefined';\n\n    default:\n      if (typeof x.toString === 'function') {\n        var repr = x.toString();\n\n        if (repr !== '[object Object]') {\n          return repr;\n        }\n      }\n\n      return '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n}","import invoker from \"./invoker.js\";\n/**\n * Returns a string made by inserting the `separator` between each element and\n * concatenating all the elements into a single string.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig String -> [a] -> String\n * @param {Number|String} separator The string used to separate the elements.\n * @param {Array} xs The elements to join into a string.\n * @return {String} str The string made by concatenating `xs` with `separator`.\n * @see R.split\n * @example\n *\n *      const spacer = R.join(' ');\n *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n */\n\nvar join =\n/*#__PURE__*/\ninvoker(1, 'join');\nexport default join;","import _curry2 from \"./internal/_curry2.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport curryN from \"./curryN.js\";\nimport toString from \"./toString.js\";\n/**\n * Turns a named method with a specified arity into a function that can be\n * called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {String} method Name of any of the target object's methods to call.\n * @return {Function} A new curried function.\n * @see R.construct\n * @example\n *\n *      const sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      const sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n *\n *      const dog = {\n *        speak: async () => 'Woof!'\n *      };\n *      const speak = R.invoker(0, 'speak');\n *      speak(dog).then(console.log) //~> 'Woof!'\n *\n * @symb R.invoker(0, 'method')(o) = o['method']()\n * @symb R.invoker(1, 'method')(a, o) = o['method'](a)\n * @symb R.invoker(2, 'method')(a, b, o) = o['method'](a, b)\n */\n\nvar invoker =\n/*#__PURE__*/\n_curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function () {\n    var target = arguments[arity];\n\n    if (target != null && _isFunction(target[method])) {\n      return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));\n    }\n\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n\nexport default invoker;","import curry from 'ramda/es/curry'\nimport compose from 'ramda/es/compose'\nimport fromPairs from 'ramda/es/fromPairs'\nimport map from 'ramda/es/map'\nimport pair from 'ramda/es/pair'\nimport keys from 'ramda/es/keys'\nimport length from 'ramda/es/length'\nimport chain from 'ramda/es/chain'\nimport uniq from 'ramda/es/uniq'\nimport countBy from 'ramda/es/countBy'\nimport identity from 'ramda/es/identity'\nimport filter from 'ramda/es/filter'\nimport join from 'ramda/es/join'\n\n/*\nconvert\n\n [{key: 1},{key: 2},{key: 3},{key: 4},{key: 5}]\n\nto\n\n  {\n    \"1\": {key: 1},\n    \"2\": {key: 2},\n    \"3\": {key: 3},\n    \"4\": {key: 4},\n  }\n*/\n// normalizeByKey :: string -> array -> object\nexport const normalizeByKey = curry((key, arr) =>\n  compose(\n    fromPairs,\n    map(e => pair(e[key], e))\n  )(arr)\n)\n\n// determine if two or more objects share at least one key\n// [object] -> bool\nexport const objectsShareKey = objs => {\n  const objKeys = chain(keys, objs)\n  return length(objKeys) > length(uniq(objKeys))\n}\n\n// get all keys that appear at least twice in an array of objects\n// [object] -> [string]\nexport const getDuplicateKeys = objs =>\n  compose(\n    keys,\n    filter(c => c > 1),\n    countBy(identity),\n    chain(keys)\n  )(objs)\n\n// get all keys that appear at least twice in an array of objects as a comma-separated string\n// [object] -> string\nexport const getDuplicateKeysString = compose(join(', '), getDuplicateKeys)\n","import ReactHabitat from 'react-habitat'\nimport chain from 'ramda/es/chain'\nimport compose from 'ramda/es/compose'\nimport map from 'ramda/es/map'\nimport toPairs from 'ramda/es/toPairs'\nimport DomFactory from './DomFactory'\nimport { getDuplicateKeysString, objectsShareKey } from '../../util/state'\n\nconst contexts = [require.context('../../components/', true, /habitat\\.js$/)]\n\nconst asyncContexts = [\n  require.context('../../components/', true, /habitat-async\\.js$/),\n]\n\nconst getRegisteredComponents = compose(\n  chain(context => map(key => context(key).default)(context.keys()))\n)\n\nclass ReactApp extends ReactHabitat.Bootstrapper {\n  constructor() {\n    super()\n\n    this.updateComponents(contexts, asyncContexts)\n\n    if (module.hot) {\n      const dependencies = [...contexts, ...asyncContexts].map(c => c.id)\n\n      module.hot.accept(dependencies, () => {\n        const contexts = [\n          require.context('../../components/', true, /habitat\\.js$/),\n        ]\n\n        const asyncContexts = [\n          require.context('../../components/', true, /habitat-async\\.js$/),\n        ]\n\n        this.dispose()\n        this.updateComponents(contexts, asyncContexts)\n      })\n    }\n  }\n\n  updateComponents(contexts, asyncContexts) {\n    // Create a new container builder\n    const builder = new ReactHabitat.ContainerBuilder()\n\n    builder.factory = new DomFactory()\n\n    const components = getRegisteredComponents(contexts)\n    const asyncComponents = getRegisteredComponents(asyncContexts)\n\n    const allComponents = [...components, ...asyncComponents]\n\n    const componentPairs = chain(toPairs, components)\n    const asyncComponentPairs = chain(toPairs, asyncComponents)\n\n    if (\n      process.env.NODE_ENV !== 'production' &&\n      objectsShareKey(allComponents)\n    ) {\n      const duplicateKeys = getDuplicateKeysString(allComponents)\n      // eslint-disable-next-line\n      console.error(\n        `react-habitat: there are duplicate components registered under the following names: ${duplicateKeys}`,\n        '\\nplease check your habitat.js and habitat-async.js files!'\n      )\n    }\n\n    // Register components with react habitat\n    componentPairs.forEach(([name, component]) =>\n      builder.register(component).as(name)\n    )\n    asyncComponentPairs.forEach(([name, component]) =>\n      builder.registerAsync(component).as(name)\n    )\n\n    // Finally, set the container\n    this.setContainer(builder.build())\n  }\n}\n\n// Always export a 'new' instance so it immediately evokes\nexport default new ReactApp()\n","(function() { module.exports = window[\"wp\"][\"apiFetch\"]; }());"],"sourceRoot":""}