{"version":3,"sources":["webpack:///./node_modules/ramda/es/reverse.js","webpack:///./node_modules/gatsby-link/index.js","webpack:///./node_modules/ramda/es/pathEq.js","webpack:///./node_modules/ramda/es/lensProp.js","webpack:///./node_modules/ramda/es/join.js","webpack:///./node_modules/core-js/internals/to-indexed-object.js","webpack:///./node_modules/ramda/es/internal/_isArray.js","webpack:///./node_modules/ramda/es/zipObj.js","webpack:///./node_modules/core-js/internals/use-symbol-as-uid.js","webpack:///./node_modules/gatsby-react-router-scroll/session-storage.js","webpack:///./node_modules/ramda/es/internal/_filter.js","webpack:///./node_modules/core-js/internals/hidden-keys.js","webpack:///./node_modules/core-js/internals/fails.js","webpack:///./node_modules/core-js/internals/get-built-in.js","webpack:///./node_modules/core-js/internals/object-property-is-enumerable.js","webpack:///./node_modules/core-js/internals/object-set-prototype-of.js","webpack:///./node_modules/core-js/internals/set-to-string-tag.js","webpack:///./node_modules/ramda/es/internal/_curry3.js","webpack:///./node_modules/@babel/runtime/helpers/interopRequireWildcard.js","webpack:///./node_modules/ramda/es/min.js","webpack:///./node_modules/ramda/es/splitAt.js","webpack:///./node_modules/ramda/es/internal/_flatCat.js","webpack:///./node_modules/ramda/es/internal/_forceReduced.js","webpack:///./node_modules/ramda/es/internal/_xchain.js","webpack:///./node_modules/ramda/es/chain.js","webpack:///./node_modules/ramda/es/internal/_makeFlat.js","webpack:///./node_modules/core-js/internals/global.js","webpack:///./.cache/normalize-page-path.js","webpack:///./.cache/find-path.js","webpack:///./node_modules/core-js/internals/object-keys.js","webpack:///./node_modules/ramda/es/internal/_xwrap.js","webpack:///./node_modules/gatsby-react-router-scroll/use-scroll-restoration.js","webpack:///./node_modules/ramda/es/ap.js","webpack:///./node_modules/ramda/es/curry.js","webpack:///./node_modules/core-js/internals/object-get-prototype-of.js","webpack:///./node_modules/core-js/internals/correct-prototype-getter.js","webpack:///./node_modules/core-js/modules/es.array.iterator.js","webpack:///./node_modules/core-js/internals/redefine-all.js","webpack:///./node_modules/ramda/es/invoker.js","webpack:///./node_modules/ramda/es/toUpper.js","webpack:///./.cache/emitter.js","webpack:///./node_modules/mitt/dist/mitt.es.js","webpack:///./node_modules/ramda/es/indexOf.js","webpack:///./node_modules/core-js/internals/copy-constructor-properties.js","webpack:///./node_modules/core-js/internals/is-array-iterator-method.js","webpack:///./node_modules/ramda/es/reject.js","webpack:///./node_modules/ramda/es/when.js","webpack:///./node_modules/ramda/es/add.js","webpack:///./node_modules/ramda/es/sum.js","webpack:///./node_modules/ramda/es/anyPass.js","webpack:///./node_modules/gatsby-react-router-scroll/index.js","webpack:///./node_modules/ramda/es/internal/_xreduceBy.js","webpack:///./node_modules/ramda/es/reduceBy.js","webpack:///./node_modules/ramda/es/internal/_isFunction.js","webpack:///./node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js","webpack:///./node_modules/ramda/es/includes.js","webpack:///./node_modules/ramda/es/groupBy.js","webpack:///./node_modules/core-js/internals/shared-key.js","webpack:///./.cache/react-lifecycles-compat.js","webpack:///./node_modules/ramda/es/match.js","webpack:///./node_modules/ramda/es/last.js","webpack:///./node_modules/@reach/router/es/lib/history.js","webpack:///./node_modules/core-js/internals/classof.js","webpack:///./node_modules/ramda/es/internal/_isNumber.js","webpack:///./node_modules/ramda/es/internal/_xfindIndex.js","webpack:///./node_modules/ramda/es/findIndex.js","webpack:///./node_modules/core-js/internals/function-bind-context.js","webpack:///./node_modules/core-js/internals/to-string-tag-support.js","webpack:///./node_modules/ramda/es/propEq.js","webpack:///./node_modules/ramda/es/internal/_xall.js","webpack:///./node_modules/ramda/es/all.js","webpack:///./node_modules/ramda/es/T.js","webpack:///./node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack:///./node_modules/ramda/es/propOr.js","webpack:///./node_modules/ramda/es/prop.js","webpack:///./node_modules/ramda/es/mapObjIndexed.js","webpack:///./node_modules/ramda/es/internal/_quote.js","webpack:///./node_modules/ramda/es/internal/_toISOString.js","webpack:///./node_modules/ramda/es/internal/_toString.js","webpack:///./node_modules/core-js/internals/ie8-dom-define.js","webpack:///./node_modules/core-js/internals/native-url.js","webpack:///./node_modules/gatsby-react-router-scroll/scroll-handler.js","webpack:///./node_modules/core-js/internals/html.js","webpack:///./node_modules/ramda/es/__.js","webpack:///./node_modules/ramda/es/compose.js","webpack:///./node_modules/core-js/internals/an-instance.js","webpack:///./gatsby-browser.js","webpack:///./node_modules/ramda/es/identity.js","webpack:///./node_modules/core-js/internals/a-function.js","webpack:///./node_modules/core-js/internals/require-object-coercible.js","webpack:///./node_modules/core-js/internals/export.js","webpack:///./node_modules/ramda/es/replace.js","webpack:///./node_modules/ramda/es/path.js","webpack:///./node_modules/core-js/internals/to-absolute-index.js","webpack:///./node_modules/ramda/es/either.js","webpack:///./.cache/page-renderer.js","webpack:///./node_modules/ramda/es/internal/_xtake.js","webpack:///./node_modules/ramda/es/take.js","webpack:///./node_modules/core-js/internals/object-get-own-property-names.js","webpack:///./node_modules/ramda/es/internal/_isString.js","webpack:///./node_modules/gatsby-plugin-google-tagmanager/gatsby-browser.js","webpack:///./node_modules/ramda/es/internal/_arity.js","webpack:///./node_modules/ramda/es/internal/_xfilter.js","webpack:///./node_modules/ramda/es/filter.js","webpack:///./node_modules/ramda/es/internal/_identity.js","webpack:///./node_modules/core-js/internals/iterator-close.js","webpack:///./node_modules/ramda/es/sortBy.js","webpack:///./node_modules/core-js/modules/web.url.js","webpack:///./node_modules/ramda/es/internal/_curry2.js","webpack:///./node_modules/core-js/internals/engine-v8-version.js","webpack:///./node_modules/@reach/router/es/lib/utils.js","webpack:///./.cache/api-runner-browser-plugins.js","webpack:///./node_modules/ramda/es/internal/_complement.js","webpack:///./node_modules/@mikaelkristiansson/domready/ready.js","webpack:///./node_modules/ramda/es/assocPath.js","webpack:///./node_modules/core-js/internals/object-define-properties.js","webpack:///./node_modules/core-js/internals/engine-user-agent.js","webpack:///./.cache/register-service-worker.js","webpack:///./node_modules/core-js/internals/get-iterator-method.js","webpack:///./.cache/_this_is_virtual_fs_path_/$virtual/async-requires.js","webpack:///./node_modules/core-js/internals/a-possible-prototype.js","webpack:///./node_modules/ramda/es/internal/_reduce.js","webpack:///./node_modules/ramda/es/not.js","webpack:///./node_modules/core-js/internals/iterators.js","webpack:///./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack:///./node_modules/core-js/modules/es.string.iterator.js","webpack:///./node_modules/ramda/es/liftN.js","webpack:///./node_modules/ramda/es/pathOr.js","webpack:///./node_modules/ramda/es/difference.js","webpack:///./node_modules/ramda/es/and.js","webpack:///./node_modules/invariant/browser.js","webpack:///./node_modules/ramda/es/internal/_Set.js","webpack:///./node_modules/core-js/internals/path.js","webpack:///./node_modules/core-js/internals/indexed-object.js","webpack:///./node_modules/core-js/internals/add-to-unscopables.js","webpack:///./node_modules/ramda/es/unnest.js","webpack:///./node_modules/ramda/es/internal/_map.js","webpack:///./node_modules/core-js/internals/native-symbol.js","webpack:///./node_modules/ramda/es/ifElse.js","webpack:///./node_modules/ramda/es/tail.js","webpack:///./node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack:///./node_modules/ramda/es/internal/_curry1.js","webpack:///./node_modules/ramda/es/isEmpty.js","webpack:///./node_modules/ramda/es/applySpec.js","webpack:///./node_modules/ramda/es/split.js","webpack:///./node_modules/core-js/internals/array-includes.js","webpack:///./node_modules/core-js/internals/array-from.js","webpack:///./node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack:///./node_modules/ramda/es/values.js","webpack:///./node_modules/ramda/es/symmetricDifference.js","webpack:///./node_modules/core-js/internals/to-length.js","webpack:///./node_modules/ramda/es/indexBy.js","webpack:///./node_modules/core-js/internals/has.js","webpack:///./node_modules/ramda/es/isNil.js","webpack:///./node_modules/ramda/es/internal/_xfind.js","webpack:///./node_modules/ramda/es/find.js","webpack:///./.cache/route-announcer-props.js","webpack:///./.cache/navigation.js","webpack:///./node_modules/shallow-compare/es/index.js","webpack:///./.cache/ensure-resources.js","webpack:///./.cache/production-app.js","webpack:///./node_modules/ramda/es/apply.js","webpack:///./node_modules/ramda/es/internal/_isInteger.js","webpack:///./node_modules/ramda/es/internal/_curryN.js","webpack:///./node_modules/ramda/es/pluck.js","webpack:///./node_modules/@babel/runtime/helpers/inheritsLoose.js","webpack:///./node_modules/core-js/internals/shared.js","webpack:///./node_modules/core-js/internals/own-keys.js","webpack:///./.cache/gatsby-browser-entry.js","webpack:///./node_modules/core-js/internals/string-punycode-to-ascii.js","webpack:///./node_modules/core-js/internals/create-property-descriptor.js","webpack:///./node_modules/ramda/es/internal/_includesWith.js","webpack:///./node_modules/ramda/es/bind.js","webpack:///./node_modules/ramda/es/evolve.js","webpack:///./node_modules/core-js/internals/object-assign.js","webpack:///./node_modules/ramda/es/nth.js","webpack:///./node_modules/ramda/es/curryN.js","webpack:///./node_modules/gatsby/dist/internal-plugins/bundle-optimisations/polyfills/object-assign.js","webpack:///./node_modules/ramda/es/toLower.js","webpack:///./node_modules/@reach/router/es/index.js","webpack:///./node_modules/ramda/es/reduce.js","webpack:///./node_modules/ramda/es/length.js","webpack:///./node_modules/ramda/es/descend.js","webpack:///./node_modules/ramda/es/internal/_xfBase.js","webpack:///./node_modules/core-js/internals/string-multibyte.js","webpack:///./node_modules/ramda/es/hasPath.js","webpack:///./node_modules/ramda/es/keys.js","webpack:///./node_modules/ramda/es/slice.js","webpack:///./node_modules/core-js/internals/internal-state.js","webpack:///./node_modules/ramda/es/internal/_isObject.js","webpack:///./node_modules/core-js/internals/redefine.js","webpack:///./node_modules/ramda/es/internal/_isArguments.js","webpack:///./node_modules/@babel/runtime/helpers/typeof.js","webpack:///./node_modules/ramda/es/pickAll.js","webpack:///./.cache/strip-prefix.js","webpack:///./node_modules/gatsby-link/parse-path.js","webpack:///./node_modules/core-js/internals/object-get-own-property-symbols.js","webpack:///./node_modules/ramda/es/internal/_reduced.js","webpack:///./node_modules/ramda/es/concat.js","webpack:///./node_modules/ramda/es/internal/_arrayFromIterator.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/assoc.js","webpack:///./node_modules/ramda/es/uniqBy.js","webpack:///./node_modules/core-js/internals/enum-bug-keys.js","webpack:///./.cache/prefetch.js","webpack:///./.cache/loader.js","webpack:///./node_modules/core-js/internals/to-object.js","webpack:///./node_modules/core-js/internals/native-weak-map.js","webpack:///./node_modules/core-js/internals/object-create.js","webpack:///./node_modules/ramda/es/toPairs.js","webpack:///./node_modules/ramda/es/internal/_checkForMethod.js","webpack:///./node_modules/core-js/internals/define-iterator.js","webpack:///./node_modules/ramda/es/head.js","webpack:///./node_modules/core-js/internals/descriptors.js","webpack:///./node_modules/ramda/es/internal/_dispatchable.js","webpack:///./node_modules/ramda/es/uniq.js","webpack:///./node_modules/core-js/internals/an-object.js","webpack:///./node_modules/ramda/es/max.js","webpack:///./node_modules/core-js/internals/create-property.js","webpack:///./node_modules/ramda/es/internal/_cloneRegExp.js","webpack:///./node_modules/ramda/es/lens.js","webpack:///./node_modules/gatsby-react-router-scroll/scroll-container.js","webpack:///./node_modules/core-js/internals/is-object.js","webpack:///./node_modules/ramda/es/internal/_pipe.js","webpack:///./node_modules/ramda/es/pipe.js","webpack:///./node_modules/ramda/es/flatten.js","webpack:///./node_modules/core-js/internals/inspect-source.js","webpack:///./node_modules/ramda/es/lift.js","webpack:///./node_modules/core-js/internals/uid.js","webpack:///./node_modules/core-js/internals/create-non-enumerable-property.js","webpack:///./node_modules/ramda/es/toString.js","webpack:///./node_modules/ramda/es/over.js","webpack:///./node_modules/core-js/internals/is-forced.js","webpack:///./node_modules/ramda/es/lensPath.js","webpack:///./node_modules/ramda/es/merge.js","webpack:///./.cache/public-page-renderer.js","webpack:///./node_modules/core-js/internals/object-define-property.js","webpack:///./node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack:///./node_modules/core-js/modules/web.url-search-params.js","webpack:///./node_modules/core-js/internals/get-iterator.js","webpack:///./node_modules/ramda/es/internal/_concat.js","webpack:///./node_modules/ramda/es/internal/_isTransformer.js","webpack:///./node_modules/ramda/es/type.js","webpack:///./.cache/create-react-context.js","webpack:///./node_modules/ramda/es/internal/_isPlaceholder.js","webpack:///./node_modules/core-js/internals/create-iterator-constructor.js","webpack:///./node_modules/ramda/es/paths.js","webpack:///./node_modules/ramda/es/internal/_clone.js","webpack:///./node_modules/@babel/runtime/helpers/extends.js","webpack:///./node_modules/core-js/internals/to-integer.js","webpack:///./node_modules/ramda/es/internal/_isArrayLike.js","webpack:///./node_modules/core-js/internals/iterators-core.js","webpack:///./node_modules/ramda/es/cond.js","webpack:///./.cache/public-page-renderer-prod.js","webpack:///./node_modules/ramda/es/internal/_xmap.js","webpack:///./node_modules/ramda/es/map.js","webpack:///./node_modules/ramda/es/startsWith.js","webpack:///./node_modules/ramda/es/or.js","webpack:///./node_modules/ramda/es/F.js","webpack:///./node_modules/ramda/es/addIndex.js","webpack:///./node_modules/ramda/es/adjust.js","webpack:///./node_modules/ramda/es/always.js","webpack:///./node_modules/ramda/es/internal/_xany.js","webpack:///./node_modules/ramda/es/any.js","webpack:///./node_modules/ramda/es/internal/_aperture.js","webpack:///./node_modules/ramda/es/internal/_xaperture.js","webpack:///./node_modules/ramda/es/aperture.js","webpack:///./node_modules/ramda/es/append.js","webpack:///./node_modules/ramda/es/applyTo.js","webpack:///./node_modules/ramda/es/nAry.js","webpack:///./node_modules/ramda/es/binary.js","webpack:///./node_modules/ramda/es/call.js","webpack:///./node_modules/ramda/es/clamp.js","webpack:///./node_modules/ramda/es/clone.js","webpack:///./node_modules/ramda/es/comparator.js","webpack:///./node_modules/ramda/es/composeK.js","webpack:///./node_modules/ramda/es/internal/_pipeP.js","webpack:///./node_modules/ramda/es/pipeP.js","webpack:///./node_modules/ramda/es/composeP.js","webpack:///./node_modules/ramda/es/pipeWith.js","webpack:///./node_modules/ramda/es/composeWith.js","webpack:///./node_modules/ramda/es/constructN.js","webpack:///./node_modules/ramda/es/construct.js","webpack:///./node_modules/ramda/es/contains.js","webpack:///./node_modules/ramda/es/converge.js","webpack:///./node_modules/ramda/es/countBy.js","webpack:///./node_modules/ramda/es/dec.js","webpack:///./node_modules/ramda/es/differenceWith.js","webpack:///./node_modules/ramda/es/dissoc.js","webpack:///./node_modules/ramda/es/remove.js","webpack:///./node_modules/ramda/es/update.js","webpack:///./node_modules/ramda/es/dissocPath.js","webpack:///./node_modules/ramda/es/divide.js","webpack:///./node_modules/ramda/es/internal/_xdrop.js","webpack:///./node_modules/ramda/es/drop.js","webpack:///./node_modules/ramda/es/internal/_dropLast.js","webpack:///./node_modules/ramda/es/internal/_xdropLast.js","webpack:///./node_modules/ramda/es/dropLast.js","webpack:///./node_modules/ramda/es/internal/_dropLastWhile.js","webpack:///./node_modules/ramda/es/internal/_xdropLastWhile.js","webpack:///./node_modules/ramda/es/dropLastWhile.js","webpack:///./node_modules/ramda/es/internal/_xdropRepeatsWith.js","webpack:///./node_modules/ramda/es/dropRepeatsWith.js","webpack:///./node_modules/ramda/es/dropRepeats.js","webpack:///./node_modules/ramda/es/internal/_xdropWhile.js","webpack:///./node_modules/ramda/es/dropWhile.js","webpack:///./node_modules/ramda/es/takeLast.js","webpack:///./node_modules/ramda/es/endsWith.js","webpack:///./node_modules/ramda/es/eqBy.js","webpack:///./node_modules/ramda/es/eqProps.js","webpack:///./node_modules/ramda/es/internal/_xfindLast.js","webpack:///./node_modules/ramda/es/findLast.js","webpack:///./node_modules/ramda/es/internal/_xfindLastIndex.js","webpack:///./node_modules/ramda/es/findLastIndex.js","webpack:///./node_modules/ramda/es/flip.js","webpack:///./node_modules/ramda/es/forEach.js","webpack:///./node_modules/ramda/es/forEachObjIndexed.js","webpack:///./node_modules/ramda/es/fromPairs.js","webpack:///./node_modules/ramda/es/groupWith.js","webpack:///./node_modules/ramda/es/gt.js","webpack:///./node_modules/ramda/es/gte.js","webpack:///./node_modules/ramda/es/has.js","webpack:///./node_modules/ramda/es/hasIn.js","webpack:///./node_modules/ramda/es/identical.js","webpack:///./node_modules/ramda/es/inc.js","webpack:///./node_modules/ramda/es/init.js","webpack:///./node_modules/ramda/es/innerJoin.js","webpack:///./node_modules/ramda/es/insert.js","webpack:///./node_modules/ramda/es/insertAll.js","webpack:///./node_modules/ramda/es/intersection.js","webpack:///./node_modules/ramda/es/intersperse.js","webpack:///./node_modules/ramda/es/objOf.js","webpack:///./node_modules/ramda/es/internal/_stepCat.js","webpack:///./node_modules/ramda/es/into.js","webpack:///./node_modules/ramda/es/invert.js","webpack:///./node_modules/ramda/es/invertObj.js","webpack:///./node_modules/ramda/es/is.js","webpack:///./node_modules/ramda/es/juxt.js","webpack:///./node_modules/ramda/es/keysIn.js","webpack:///./node_modules/ramda/es/lastIndexOf.js","webpack:///./node_modules/ramda/es/lensIndex.js","webpack:///./node_modules/ramda/es/lt.js","webpack:///./node_modules/ramda/es/lte.js","webpack:///./node_modules/ramda/es/mapAccum.js","webpack:///./node_modules/ramda/es/mapAccumRight.js","webpack:///./node_modules/ramda/es/mathMod.js","webpack:///./node_modules/ramda/es/maxBy.js","webpack:///./node_modules/ramda/es/mean.js","webpack:///./node_modules/ramda/es/median.js","webpack:///./node_modules/ramda/es/mergeAll.js","webpack:///./node_modules/ramda/es/mergeWithKey.js","webpack:///./node_modules/ramda/es/mergeDeepWithKey.js","webpack:///./node_modules/ramda/es/mergeDeepLeft.js","webpack:///./node_modules/ramda/es/mergeDeepRight.js","webpack:///./node_modules/ramda/es/mergeDeepWith.js","webpack:///./node_modules/ramda/es/mergeLeft.js","webpack:///./node_modules/ramda/es/mergeRight.js","webpack:///./node_modules/ramda/es/mergeWith.js","webpack:///./node_modules/ramda/es/minBy.js","webpack:///./node_modules/ramda/es/modulo.js","webpack:///./node_modules/ramda/es/move.js","webpack:///./node_modules/ramda/es/multiply.js","webpack:///./node_modules/ramda/es/negate.js","webpack:///./node_modules/ramda/es/none.js","webpack:///./node_modules/ramda/es/nthArg.js","webpack:///./node_modules/ramda/es/o.js","webpack:///./node_modules/ramda/es/internal/_of.js","webpack:///./node_modules/ramda/es/of.js","webpack:///./node_modules/ramda/es/omit.js","webpack:///./node_modules/ramda/es/once.js","webpack:///./node_modules/ramda/es/internal/_assertPromise.js","webpack:///./node_modules/ramda/es/otherwise.js","webpack:///./node_modules/ramda/es/pair.js","webpack:///./node_modules/ramda/es/internal/_createPartialApplicator.js","webpack:///./node_modules/ramda/es/partial.js","webpack:///./node_modules/ramda/es/partialRight.js","webpack:///./node_modules/ramda/es/partition.js","webpack:///./node_modules/ramda/es/pathSatisfies.js","webpack:///./node_modules/ramda/es/pick.js","webpack:///./node_modules/ramda/es/pickBy.js","webpack:///./node_modules/ramda/es/pipeK.js","webpack:///./node_modules/ramda/es/prepend.js","webpack:///./node_modules/ramda/es/product.js","webpack:///./node_modules/ramda/es/useWith.js","webpack:///./node_modules/ramda/es/project.js","webpack:///./node_modules/ramda/es/propIs.js","webpack:///./node_modules/ramda/es/propSatisfies.js","webpack:///./node_modules/ramda/es/props.js","webpack:///./node_modules/ramda/es/range.js","webpack:///./node_modules/ramda/es/reduceRight.js","webpack:///./node_modules/ramda/es/reduceWhile.js","webpack:///./node_modules/ramda/es/reduced.js","webpack:///./node_modules/ramda/es/times.js","webpack:///./node_modules/ramda/es/repeat.js","webpack:///./node_modules/ramda/es/scan.js","webpack:///./node_modules/ramda/es/sequence.js","webpack:///./node_modules/ramda/es/set.js","webpack:///./node_modules/ramda/es/sortWith.js","webpack:///./node_modules/ramda/es/splitEvery.js","webpack:///./node_modules/ramda/es/splitWhen.js","webpack:///./node_modules/ramda/es/subtract.js","webpack:///./node_modules/ramda/es/symmetricDifferenceWith.js","webpack:///./node_modules/ramda/es/takeLastWhile.js","webpack:///./node_modules/ramda/es/internal/_xtakeWhile.js","webpack:///./node_modules/ramda/es/takeWhile.js","webpack:///./node_modules/ramda/es/internal/_xtap.js","webpack:///./node_modules/ramda/es/tap.js","webpack:///./node_modules/ramda/es/andThen.js","webpack:///./node_modules/ramda/es/toPairsIn.js","webpack:///./node_modules/ramda/es/transduce.js","webpack:///./node_modules/ramda/es/transpose.js","webpack:///./node_modules/ramda/es/traverse.js","webpack:///./node_modules/ramda/es/trim.js","webpack:///./node_modules/ramda/es/tryCatch.js","webpack:///./node_modules/ramda/es/unapply.js","webpack:///./node_modules/ramda/es/unary.js","webpack:///./node_modules/ramda/es/uncurryN.js","webpack:///./node_modules/ramda/es/unfold.js","webpack:///./node_modules/ramda/es/union.js","webpack:///./node_modules/ramda/es/uniqWith.js","webpack:///./node_modules/ramda/es/unionWith.js","webpack:///./node_modules/ramda/es/until.js","webpack:///./node_modules/ramda/es/valuesIn.js","webpack:///./node_modules/ramda/es/view.js","webpack:///./node_modules/ramda/es/where.js","webpack:///./node_modules/ramda/es/whereEq.js","webpack:///./node_modules/ramda/es/without.js","webpack:///./node_modules/ramda/es/xor.js","webpack:///./node_modules/ramda/es/xprod.js","webpack:///./node_modules/ramda/es/zip.js","webpack:///./node_modules/ramda/es/zipWith.js","webpack:///./node_modules/ramda/es/thunkify.js","webpack:///./node_modules/ramda/es/unless.js","webpack:///./node_modules/ramda/es/internal/_includes.js","webpack:///./node_modules/ramda/es/complement.js","webpack:///./node_modules/ramda/es/defaultTo.js","webpack:///./node_modules/core-js/internals/well-known-symbol.js","webpack:///./node_modules/ramda/es/empty.js","webpack:///./node_modules/ramda/es/internal/_indexOf.js","webpack:///./node_modules/ramda/es/internal/_objectIs.js","webpack:///./node_modules/core-js/internals/to-primitive.js","webpack:///./node_modules/ramda/es/internal/_objectAssign.js","webpack:///./node_modules/ramda/es/internal/_has.js","webpack:///./node_modules/ramda/es/memoizeWith.js","webpack:///./node_modules/core-js/internals/is-pure.js","webpack:///./node_modules/ramda/es/ascend.js","webpack:///./node_modules/core-js/internals/classof-raw.js","webpack:///./node_modules/core-js/internals/shared-store.js","webpack:///./.cache/api-runner-browser.js","webpack:///./node_modules/ramda/es/both.js","webpack:///./node_modules/ramda/es/sort.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/core-js/internals/object-keys-internal.js","webpack:///./node_modules/ramda/es/allPass.js","webpack:///./node_modules/core-js/internals/document-create-element.js","webpack:///./node_modules/core-js/internals/set-global.js","webpack:///./node_modules/ramda/es/test.js","webpack:///./node_modules/ramda/es/internal/_isRegExp.js"],"names":["reverse","list","split","join","Array","prototype","slice","call","_interopRequireDefault","exports","__esModule","withPrefix","withAssetPrefix","path","getGlobalPathPrefix","navigateTo","replace","push","navigate","default","_objectWithoutPropertiesLoose2","_assertThisInitialized2","_inheritsLoose2","_extends2","_propTypes","_react","_router","_utils","_parsePath","parsePath","isAbsolutePath","startsWith","prefix","_ref","_prefix","getGlobalBasePrefix","isLocalLink","base","endsWith","rewriteLinkPath","relativeTo","current","resolve","absolutify","NavLinkPropTypes","activeClassName","string","activeStyle","object","partiallyActive","bool","GatsbyLinkLocationWrapper","props","createElement","Location","_ref2","location","GatsbyLink","_location","_React$Component","_this","this","defaultGetProps","_ref3","isPartiallyCurrent","isCurrent","className","filter","Boolean","style","IOSupported","window","IntersectionObserver","state","handleRef","bind","_proto","_prefetch","currentPath","pathname","rewrittenPath","to","newPathName","___loader","enqueue","componentDidUpdate","prevProps","prevState","componentDidMount","componentWillUnmount","io","_this$io","instance","el","unobserve","disconnect","ref","cb","_this2","innerRef","hasOwnProperty","entries","forEach","entry","target","isIntersecting","intersectionRatio","observe","render","_this3","_this$props","_this$props$getProps","getProps","_onClick","onClick","_onMouseEnter","onMouseEnter","rest","prefixedTo","Link","e","hovering","button","defaultPrevented","metaKey","altKey","ctrlKey","shiftKey","preventDefault","shouldReplace","encodeURI","___navigate","href","Component","propTypes","func","isRequired","showDeprecationWarning","functionName","altFunctionName","version","console","warn","_default","forwardRef","options","___push","___replace","pathEq","_path","val","obj","lensProp","k","IndexedObject","requireObjectCoercible","module","it","length","Object","toString","zipObj","keys","values","idx","len","Math","min","out","NATIVE_SYMBOL","Symbol","sham","iterator","SessionStorage","read","key","stateKey","getStateKey","value","sessionStorage","getItem","JSON","parse","save","storedValue","stringify","setItem","stateKeyBase","_filter","fn","result","exec","error","global","aFunction","variable","undefined","namespace","method","arguments","$propertyIsEnumerable","propertyIsEnumerable","getOwnPropertyDescriptor","NASHORN_BUG","1","f","V","descriptor","enumerable","anObject","aPossiblePrototype","setPrototypeOf","setter","CORRECT_SETTER","test","set","O","proto","__proto__","defineProperty","has","TO_STRING_TAG","wellKnownSymbol","TAG","STATIC","configurable","_curry3","f3","a","b","c","_b","_c","_a","_typeof","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","cache","get","newObj","hasPropertyDescriptor","desc","splitAt","index","array","xf","rxf","_xfBase","init","input","ret","preservingReduced","_isArrayLike","_reduce","_curry2","map","_dispatchable","monad","x","_makeFlat","recursive","flatt","jlen","j","ilen","check","globalThis","self","Function","charAt","pathCache","Map","matchPaths","trimPathname","rawPathname","decodeURIComponent","stripPrefix","__BASE_PATH__","URL","setMatchPaths","findMatchPath","trimmedPathname","cleanPath","pickPaths","matchPath","originalPath","pick","normalizePagePath","route","grabMatchParams","params","findPath","foundPath","internalObjectKeys","enumBugKeys","XWrap","Error","acc","_xwrap","useScrollRestoration","identifier","useLocation","useContext","_scrollHandler","ScrollContext","useRef","useLayoutEffect","position","scrollTo","onScroll","scrollTop","ap","applyF","applyX","curry","toObject","sharedKey","CORRECT_PROTOTYPE_GETTER","IE_PROTO","ObjectPrototype","getPrototypeOf","constructor","fails","F","toIndexedObject","addToUnscopables","Iterators","InternalStateModule","defineIterator","setInternalState","getInternalState","getterFor","iterated","kind","type","done","Arguments","redefine","src","invoker","arity","apply","TypeError","toUpper","emitter","all","create","on","handler","off","splice","indexOf","emit","evt","mitt","xs","ownKeys","getOwnPropertyDescriptorModule","definePropertyModule","source","i","ITERATOR","ArrayPrototype","reject","pred","filterable","when","whenTrueFn","add","Number","sum","anyPass","preds","ScrollContainer","ScrollHandler","_scrollContainer","_useScrollRestoration","XReduceBy","valueFn","valueAcc","keyFn","inputs","_has","_curryN","elt","_clone","_isFunction","excluded","sourceKeys","includes","groupBy","item","shared","uid","polyfill","match","rx","str","last","_extends","assign","getLocation","_source$location","search","hash","origin","protocol","host","hostname","port","canUseDOM","decodeURI","history","createHistory","listeners","transitioning","resolveTransition","_onTransitionComplete","listen","listener","popstateListener","action","addEventListener","removeEventListener","_ref$replace","go","Date","now","replaceState","pushState","transition","Promise","res","createMemorySource","initialPath","searchIndex","initialLocation","substr","stack","states","name","_","uri","_uri$split","_uri$split$","_uri$split2","_uri$split2$","newIndex","document","globalHistory","TO_STRING_TAG_SUPPORT","classofRaw","CORRECT_ARGUMENTS","tag","tryGet","callee","_isNumber","XFindIndex","found","_reduced","findIndex","that","String","propEq","XAll","DESCRIPTORS","propertyIsEnumerableModule","createPropertyDescriptor","toPrimitive","IE8_DOM_DEFINE","$getOwnPropertyDescriptor","P","propOr","p","prop","mapObjIndexed","_quote","s","pad","n","toISOString","d","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","toFixed","_toString","seen","recur","y","concat","_includes","mapPairs","_map","sort","valueOf","isNaN","NaN","Infinity","repr","IS_PURE","url","searchParams","toJSON","URLSearchParams","username","_interopRequireWildcard","React","_sessionStorage","createContext","displayName","_len","args","_key","_stateStorage","scrollListener","scrollY","windowScroll","shouldUpdateScroll","scrollToHash","node","getElementById","substring","scrollIntoView","prevRouterProps","routerProps","scrollPosition","_this$props$location","_this$props$location2","Provider","children","element","getBuiltIn","compose","Constructor","R","require","apiCallbackContext","pluginOptions","fromMapPage","toMapPage","identity","createNonEnumerableProperty","setGlobal","copyConstructorProperties","isForced","targetProperty","sourceProperty","TARGET","GLOBAL","stat","noTargetGet","forced","regex","replacement","pathAr","toInteger","max","integer","either","g","PageRenderer","pageResources","json","pageContext","__params","pathContext","replacementElement","apiRunner","loader","publicLoader","pageElement","component","page","pop","PropTypes","data","XTake","hiddenKeys","getOwnPropertyNames","_isString","onRouteUpdate","setTimeout","dataLayerName","dataLayer","eventName","routeChangeEventName","event","_arity","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","XFilter","_isObject","_identity","returnMethod","sortBy","aa","bb","EOF","$","USE_NATIVE_URL","defineProperties","anInstance","arrayFrom","codeAt","toASCII","setToStringTag","URLSearchParamsModule","NativeURL","getInternalSearchParamsState","getState","getInternalURLState","floor","pow","ALPHA","ALPHANUMERIC","DIGIT","HEX_START","OCT","DEC","HEX","FORBIDDEN_HOST_CODE_POINT","FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT","LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE","TAB_AND_NEW_LINE","parseHost","codePoints","parseIPv6","isSpecial","parseIPv4","percentEncode","C0ControlPercentEncodeSet","partsLength","numbers","part","radix","number","ipv4","parts","parseInt","numbersSeen","ipv4Piece","swaps","swap","address","pieceIndex","compress","pointer","char","serializeHost","ignore0","unshift","ipv6","maxIndex","maxLength","currStart","currLength","findLongestZeroSequence","fragmentPercentEncodeSet","pathPercentEncodeSet","userinfoPercentEncodeSet","code","encodeURIComponent","specialSchemes","ftp","file","http","https","ws","wss","scheme","includesCredentials","password","cannotHaveUsernamePasswordPort","cannotBeABaseURL","isWindowsDriveLetter","normalized","second","startsWithWindowsDriveLetter","third","shortenURLsPath","pathSize","isSingleDot","segment","toLowerCase","SCHEME_START","SCHEME","NO_SCHEME","SPECIAL_RELATIVE_OR_AUTHORITY","PATH_OR_AUTHORITY","RELATIVE","RELATIVE_SLASH","SPECIAL_AUTHORITY_SLASHES","SPECIAL_AUTHORITY_IGNORE_SLASHES","AUTHORITY","HOST","HOSTNAME","PORT","FILE","FILE_SLASH","FILE_HOST","PATH_START","PATH","CANNOT_BE_A_BASE_URL_PATH","QUERY","FRAGMENT","parseURL","stateOverride","bufferCodePoints","failure","buffer","seenAt","seenBracket","seenPasswordToken","query","fragment","codePoint","encodedCodePoints","shift","URLConstructor","baseState","urlString","searchParamsState","updateSearchParams","updateURL","serializeURL","getOrigin","getProtocol","getUsername","getPassword","getHost","getHostname","getPort","getPathname","getSearch","getSearchParams","getHash","URLPrototype","output","accessorDescriptor","getter","nativeCreateObjectURL","createObjectURL","nativeRevokeObjectURL","revokeObjectURL","blob","f2","userAgent","process","versions","v8","routes","default_","uriPathname","uriSegments","segmentize","isRootUri","ranked","rankRoutes","l","missed","routeSegments","routeSegment","uriSegment","isSplat","dynamicMatch","paramRe","reservedNames","_to$split","toPathname","toQuery","basePathname","toSegments","baseSegments","addQuery","allSegments","segments","insertParams","_path$split","pathBase","_path$split$","constructedPath","_params$location","_params$location$sear","searchSplit","validateRedirect","from","isDynamic","rankRoute","score","reduce","isRootSegment","SEGMENT_POINTS","q","shallowCompare","obj1","obj2","obj1Keys","every","plugin","_complement","ie10","navigator","appVersion","fns","doc","hack","documentElement","doScroll","loaded","readyState","definition","assocPath","nextObj","arr","objectKeys","Properties","serviceWorker","register","then","reg","installingWorker","installing","log","controller","___swUpdated","___failedResources","reload","catch","classof","components","isObject","_iterableReduce","iter","step","next","_methodReduce","methodName","symIterator","_arrayReduce","not","ReferenceError","point","liftN","lifted","pathOr","difference","first","firstLen","secondLen","toFilterOut","and","condition","format","argIndex","framesToPop","_Set","_nativeSet","Set","_items","hasOrAdd","shouldAdd","prevSize","size","bIdx","UNSCOPABLES","unnest","functor","V8_VERSION","getOwnPropertySymbols","symbol","ifElse","onTrue","onFalse","tail","_setPrototypeOf","o","_curry1","f1","isEmpty","mapValues","applySpec","spec","v","toLength","toAbsoluteIndex","createMethod","IS_INCLUDES","$this","fromIndex","callWithSafeIterationClosing","isArrayIteratorMethod","createProperty","getIteratorMethod","arrayLike","C","argumentsLength","mapfn","mapping","iteratorMethod","vals","symmetricDifference","list1","list2","argument","indexBy","elem","hasOwn","isNil","XFind","find","RouteAnnouncerProps","id","top","width","height","padding","overflow","clip","whiteSpace","border","redirectMap","redirectIgnoreCaseMap","maybeRedirect","redirect","toPath","redirects","ignoreCase","fromPath","onPreRouteUpdate","prevLocation","timeoutId","loadPage","status","PageResourceStatus","clearTimeout","webpackCompilationHash","___webpackCompilationHash","postMessage","gatsbyApi","reachNavigate","results","getSavedScrollPosition","oldPathname","RouteAnnouncer","super","announcementRef","createRef","nextProps","requestAnimationFrame","pageName","title","pageHeadings","querySelectorAll","textContent","newAnnouncement","innerText","compareLocationProps","nextLocation","RouteUpdates","shouldComponentUpdate","Fragment","shallowDiffers","_i","EnsureResources","loadPageSync","loadResources","rawPath","setState","nextState","ProdLoader","asyncRequires","setLoader","setApiRunner","___emitter","apiRunnerAsync","RouteHandler","baseuri","basepath","DataContext","GatsbyRoot","staticQueryResults","getStaticQueryResults","LocationHandler","Consumer","pagePath","browserLoc","SiteRoot","App","renderer","ReactDOM","hydrate","domReady","received","combined","argsIdx","left","combinedIdx","pluck","subClass","superClass","store","mode","copyright","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","StaticQueryContext","useStaticQuery","context","regexNonASCII","regexSeparators","OVERFLOW_ERROR","stringFromCharCode","fromCharCode","digitToBasic","digit","adapt","delta","numPoints","firstTime","baseMinusTMin","encode","currentValue","inputLength","counter","charCodeAt","extra","ucs2decode","bias","basicLength","handledCPCount","m","handledCPCountPlusOne","RangeError","t","qMinusT","baseMinusT","label","encoded","labels","bitmap","writable","_includesWith","thisObj","evolve","transformations","transformation","$assign","A","B","chr","T","S","nth","offset","curryN","toLower","_objectWithoutProperties","_classCallCheck","_possibleConstructorReturn","_inherits","createNamedContext","defaultValue","Ctx","LocationContext","LocationProvider","_temp","getContext","refs","unlisten","_props$history","componentDidCatch","info","isRedirect","_navigate","unmounted","defaultProps","ServerLocation","BaseContext","Router","baseContext","locationContext","RouterImpl","_React$PureComponent","_props","_navigate2","primary","_props$component","domProps","Children","toArray","child","createRoute","clone","cloneElement","FocusWrapper","FocusHandler","wrapperProps","PureComponent","FocusContext","requestFocus","FocusHandlerImpl","initialRender","focusHandlerCount","_React$Component2","_temp2","_this4","_len2","_key2","shouldFocus","focus","getDerivedStateFromProps","myURIChanged","navigatedUpToMe","contains","activeElement","_this5","_props2","_props2$component","Comp","outline","tabIndex","_ref4","_ref5","_ref6","_props$getProps","anchorProps","encodedHref","shouldNavigate","_location$state","restState","RedirectRequest","redirectTo","RedirectImpl","_React$Component3","_props3","_props3$replace","noThrow","resolvedTo","_props4","Redirect","_ref7","Match","_ref8","_ref9","_ref10","resolvedPath","useNavigate","useParams","useMatch","stripSlashes","elementPath","descend","CONVERT_TO_STRING","pos","hasPath","hasEnumBug","nonEnumerableProps","hasArgsEnumBug","nIdx","ks","checkArgsLength","toIndex","NATIVE_WEAK_MAP","objectHas","wmget","wmhas","wmset","metadata","facade","STATE","enforce","TYPE","inspectSource","enforceInternalState","TEMPLATE","unsafe","simple","_isArguments","pickAll","names","hashIndex","_arrayFromIterator","_uniqContentEquals","aIterator","bIterator","stackA","stackB","eq","_equals","aItem","_objectIs","typeA","equals","message","multiline","sticky","unicode","keysA","extendedStackA","extendedStackB","assoc","uniqBy","appliedItem","supportedPrefetchStrategy","feature","fakeLink","relList","supports","err","support","link","setAttribute","onload","onerror","getElementsByTagName","getElementsByName","parentNode","appendChild","req","XMLHttpRequest","open","send","preFetched","prefetch","Success","preferDefault","createPageDataUrl","doFetch","onreadystatechange","toPageResources","pageData","componentChunkName","staticQueryHashes","BaseLoader","loadComponent","pageDb","inFlightDb","staticQueryDb","pageDataDb","prefetchTriggered","prefetchCompleted","memoizedGet","inFlightPromise","inFlightNetworkRequests","response","delete","prefetchDisabled","some","fetchPageDataJson","loadObj","retries","responseText","jsonPayload","payload","notFound","loadPageDataJson","loadAppData","allData","finalResult","componentChunkPromise","createdAt","staticQueryBatchPromise","staticQueryHash","staticQueryResultsMap","shouldPrefetch","connection","effectiveType","saveData","doesConnectionSupportPrefetch","realPath","doPrefetch","pageDataUrl","prefetchHelper","crossOrigin","as","getResourceURLsForPathname","createComponentUrls","isPageNotFound","appData","___chunkMapping","chunk","__PATH_PREFIX__","chunkName","componentUrls","_loader","getResourcesForPathname","getResourcesForPathnameSync","activeXDocument","html","documentCreateElement","EmptyConstructor","scriptTag","content","LT","NullProtoObject","domain","ActiveXObject","iframeDocument","iframe","write","close","temp","parentWindow","NullProtoObjectViaActiveX","display","contentWindow","toPairs","pairs","_checkForMethod","methodname","createIteratorConstructor","IteratorsCore","IteratorPrototype","BUGGY_SAFARI_ITERATORS","returnThis","Iterable","NAME","IteratorConstructor","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","head","methodNames","transducer","uniq","propertyKey","_cloneRegExp","pattern","RegExp","lens","toFunctorFn","_reactDom","scrollKey","ScrollContainerImplementation","findDOMNode","_pipe","pipe","flatten","functionToString","lift","postfix","random","Identity","over","detection","normalize","POLYFILL","NATIVE","lensPath","merge","r","$defineProperty","Attributes","iteratorClose","ENTRIES","redefineAll","getIterator","$fetch","Headers","getInternalParamsState","getInternalIteratorState","URL_SEARCH_PARAMS","plus","sequences","percentSequence","bytes","percentDecode","sequence","deserialize","replacer","serialize","parseSearchParams","attribute","attributes","validateArgumentsLength","passed","required","URLSearchParamsIterator","URLSearchParamsConstructor","entryIterator","entryNext","URLSearchParamsPrototype","append","getAll","entriesIndex","sliceIndex","callback","boundFunction","fetch","body","headers","_concat","set1","set2","len1","len2","_isTransformer","_isPlaceholder","paths","pathsArray","refFrom","refTo","deep","copy","copiedValue","ceil","nodeType","PrototypeOfArrayIteratorPrototype","arrayIterator","NEW_ITERATOR_PROTOTYPE","cond","pair","ProdPageRenderer","InternalPageRenderer","shape","XMap","or","origFn","_idx","_list","XAny","any","_aperture","limit","XAperture","full","getCopy","composeK","chain","_pipeP","ctx","pipeP","composeP","headList","tailList","Fn","$0","$1","$2","$3","$4","$5","$6","$7","$8","$9","after","reduceBy","start","count","dissocPath","_isInteger","_isArray","XDrop","dropLast","take","XDropLast","dropLastWhile","XDropLastWhile","retained","retain","flush","XDropRepeatsWith","lastValue","seenFirstValue","sameAsLast","XDropWhile","suffix","XFindLast","XFindLastIndex","lastIdx","keyList","nextidx","ys","elts","lookupList","filteredList","separator","_stepCatArray","_stepCatString","_stepCatObject","_objectAssign","_stepCat","Ctor","lastIndexOf","tuple","mergeDeepWithKey","lObj","rObj","lVal","rVal","_l","_r","positiveFrom","positiveTo","_of","called","_assertPromise","fst","snd","_createPartialApplicator","propPath","pipeK","transformers","ps","of","traversable","XTakeWhile","XTap","outerlist","innerlist","trim","beginRx","endRx","tryer","catcher","depth","endIdx","currentDepth","seed","vs","Const","testObj","rv","fnArgs","unless","whenFalseFn","complement","defaultTo","USE_SYMBOL_AS_UID","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","empty","_indexOf","inf","PREFERRED_STRING","nextKey","memoizeWith","mFn","ascend","plugins","api","defaultReturn","argTransform","previous","both","comparator","allPass","EXISTS"],"mappings":"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","file":"app-0a188c7fce37b5f4d9b5.js","sourcesContent":["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 = /*#__PURE__*/_curry1(function reverse(list) {\n  return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();\n});\n\nexport default reverse;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.withPrefix = withPrefix;\nexports.withAssetPrefix = withAssetPrefix;\nexports.navigateTo = exports.replace = exports.push = exports.navigate = exports.default = void 0;\n\nvar _objectWithoutPropertiesLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectWithoutPropertiesLoose\"));\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _router = require(\"@reach/router\");\n\nvar _utils = require(\"@reach/router/lib/utils\");\n\nvar _parsePath = require(\"./parse-path\");\n\nexports.parsePath = _parsePath.parsePath;\n\nvar isAbsolutePath = function isAbsolutePath(path) {\n  return path === null || path === void 0 ? void 0 : path.startsWith(\"/\");\n};\n\nfunction withPrefix(path, prefix) {\n  var _ref, _prefix;\n\n  if (prefix === void 0) {\n    prefix = getGlobalBasePrefix();\n  }\n\n  if (!isLocalLink(path)) {\n    return path;\n  }\n\n  if (path.startsWith(\"./\") || path.startsWith(\"../\")) {\n    return path;\n  }\n\n  var base = (_ref = (_prefix = prefix) !== null && _prefix !== void 0 ? _prefix : getGlobalPathPrefix()) !== null && _ref !== void 0 ? _ref : \"/\";\n  return \"\" + ((base === null || base === void 0 ? void 0 : base.endsWith(\"/\")) ? base.slice(0, -1) : base) + (path.startsWith(\"/\") ? path : \"/\" + path);\n} // These global values are wrapped in typeof clauses to ensure the values exist.\n// This is especially problematic in unit testing of this component.\n\n\nvar getGlobalPathPrefix = function getGlobalPathPrefix() {\n  return process.env.NODE_ENV !== \"production\" ? typeof __PATH_PREFIX__ !== \"undefined\" ? __PATH_PREFIX__ : undefined : __PATH_PREFIX__;\n};\n\nvar getGlobalBasePrefix = function getGlobalBasePrefix() {\n  return process.env.NODE_ENV !== \"production\" ? typeof __BASE_PATH__ !== \"undefined\" ? __BASE_PATH__ : undefined : __BASE_PATH__;\n};\n\nvar isLocalLink = function isLocalLink(path) {\n  return path && !path.startsWith(\"http://\") && !path.startsWith(\"https://\") && !path.startsWith(\"//\");\n};\n\nfunction withAssetPrefix(path) {\n  return withPrefix(path, getGlobalPathPrefix());\n}\n\nfunction absolutify(path, current) {\n  // If it's already absolute, return as-is\n  if (isAbsolutePath(path)) {\n    return path;\n  }\n\n  return (0, _utils.resolve)(path, current);\n}\n\nvar rewriteLinkPath = function rewriteLinkPath(path, relativeTo) {\n  if (typeof path === \"number\") {\n    return path;\n  }\n\n  if (!isLocalLink(path)) {\n    return path;\n  }\n\n  return isAbsolutePath(path) ? withPrefix(path) : absolutify(path, relativeTo);\n};\n\nvar NavLinkPropTypes = {\n  activeClassName: _propTypes.default.string,\n  activeStyle: _propTypes.default.object,\n  partiallyActive: _propTypes.default.bool\n}; // Set up IntersectionObserver\n\nvar createIntersectionObserver = function createIntersectionObserver(el, cb) {\n  var io = new window.IntersectionObserver(function (entries) {\n    entries.forEach(function (entry) {\n      if (el === entry.target) {\n        // Check if element is within viewport, remove listener, destroy observer, and run link callback.\n        // MSEdge doesn't currently support isIntersecting, so also test for  an intersectionRatio > 0\n        if (entry.isIntersecting || entry.intersectionRatio > 0) {\n          io.unobserve(el);\n          io.disconnect();\n          cb();\n        }\n      }\n    });\n  }); // Add element to the observer\n\n  io.observe(el);\n  return {\n    instance: io,\n    el: el\n  };\n};\n\nfunction GatsbyLinkLocationWrapper(props) {\n  return /*#__PURE__*/_react.default.createElement(_router.Location, null, function (_ref2) {\n    var location = _ref2.location;\n    return /*#__PURE__*/_react.default.createElement(GatsbyLink, (0, _extends2.default)({}, props, {\n      _location: location\n    }));\n  });\n}\n\nvar GatsbyLink = /*#__PURE__*/function (_React$Component) {\n  (0, _inheritsLoose2.default)(GatsbyLink, _React$Component);\n\n  function GatsbyLink(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this; // Default to no support for IntersectionObserver\n\n    _this.defaultGetProps = function (_ref3) {\n      var isPartiallyCurrent = _ref3.isPartiallyCurrent,\n          isCurrent = _ref3.isCurrent;\n\n      if (_this.props.partiallyActive ? isPartiallyCurrent : isCurrent) {\n        return {\n          className: [_this.props.className, _this.props.activeClassName].filter(Boolean).join(\" \"),\n          style: (0, _extends2.default)({}, _this.props.style, _this.props.activeStyle)\n        };\n      }\n\n      return null;\n    };\n\n    var IOSupported = false;\n\n    if (typeof window !== \"undefined\" && window.IntersectionObserver) {\n      IOSupported = true;\n    }\n\n    _this.state = {\n      IOSupported: IOSupported\n    };\n    _this.handleRef = _this.handleRef.bind((0, _assertThisInitialized2.default)(_this));\n    return _this;\n  }\n\n  var _proto = GatsbyLink.prototype;\n\n  _proto._prefetch = function _prefetch() {\n    var currentPath = window.location.pathname; // reach router should have the correct state\n\n    if (this.props._location && this.props._location.pathname) {\n      currentPath = this.props._location.pathname;\n    }\n\n    var rewrittenPath = rewriteLinkPath(this.props.to, currentPath);\n    var newPathName = (0, _parsePath.parsePath)(rewrittenPath).pathname; // Prefech is used to speed up next navigations. When you use it on the current navigation,\n    // there could be a race-condition where Chrome uses the stale data instead of waiting for the network to complete\n\n    if (currentPath !== newPathName) {\n      ___loader.enqueue(newPathName);\n    }\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n    // Preserve non IO functionality if no support\n    if (this.props.to !== prevProps.to && !this.state.IOSupported) {\n      this._prefetch();\n    }\n  };\n\n  _proto.componentDidMount = function componentDidMount() {\n    // Preserve non IO functionality if no support\n    if (!this.state.IOSupported) {\n      this._prefetch();\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    if (!this.io) {\n      return;\n    }\n\n    var _this$io = this.io,\n        instance = _this$io.instance,\n        el = _this$io.el;\n    instance.unobserve(el);\n    instance.disconnect();\n  };\n\n  _proto.handleRef = function handleRef(ref) {\n    var _this2 = this;\n\n    if (this.props.innerRef && this.props.innerRef.hasOwnProperty(\"current\")) {\n      this.props.innerRef.current = ref;\n    } else if (this.props.innerRef) {\n      this.props.innerRef(ref);\n    }\n\n    if (this.state.IOSupported && ref) {\n      // If IO supported and element reference found, setup Observer functionality\n      this.io = createIntersectionObserver(ref, function () {\n        _this2._prefetch();\n      });\n    }\n  };\n\n  _proto.render = function render() {\n    var _this3 = this;\n\n    var _this$props = this.props,\n        to = _this$props.to,\n        _this$props$getProps = _this$props.getProps,\n        getProps = _this$props$getProps === void 0 ? this.defaultGetProps : _this$props$getProps,\n        _onClick = _this$props.onClick,\n        _onMouseEnter = _this$props.onMouseEnter,\n        $activeClassName = _this$props.activeClassName,\n        $activeStyle = _this$props.activeStyle,\n        $innerRef = _this$props.innerRef,\n        partiallyActive = _this$props.partiallyActive,\n        state = _this$props.state,\n        replace = _this$props.replace,\n        _location = _this$props._location,\n        rest = (0, _objectWithoutPropertiesLoose2.default)(_this$props, [\"to\", \"getProps\", \"onClick\", \"onMouseEnter\", \"activeClassName\", \"activeStyle\", \"innerRef\", \"partiallyActive\", \"state\", \"replace\", \"_location\"]);\n\n    if (process.env.NODE_ENV !== \"production\" && !isLocalLink(to)) {\n      console.warn(\"External link \" + to + \" was detected in a Link component. Use the Link component only for internal links. See: https://gatsby.dev/internal-links\");\n    }\n\n    var prefixedTo = rewriteLinkPath(to, _location.pathname);\n\n    if (!isLocalLink(prefixedTo)) {\n      return /*#__PURE__*/_react.default.createElement(\"a\", (0, _extends2.default)({\n        href: prefixedTo\n      }, rest));\n    }\n\n    return /*#__PURE__*/_react.default.createElement(_router.Link, (0, _extends2.default)({\n      to: prefixedTo,\n      state: state,\n      getProps: getProps,\n      innerRef: this.handleRef,\n      onMouseEnter: function onMouseEnter(e) {\n        if (_onMouseEnter) {\n          _onMouseEnter(e);\n        }\n\n        ___loader.hovering((0, _parsePath.parsePath)(prefixedTo).pathname);\n      },\n      onClick: function onClick(e) {\n        if (_onClick) {\n          _onClick(e);\n        }\n\n        if (e.button === 0 && // ignore right clicks\n        !_this3.props.target && // let browser handle \"target=_blank\"\n        !e.defaultPrevented && // onClick prevented default\n        !e.metaKey && // ignore clicks with modifier keys...\n        !e.altKey && !e.ctrlKey && !e.shiftKey) {\n          e.preventDefault();\n          var shouldReplace = replace;\n\n          var isCurrent = encodeURI(prefixedTo) === _location.pathname;\n\n          if (typeof replace !== \"boolean\" && isCurrent) {\n            shouldReplace = true;\n          } // Make sure the necessary scripts and data are\n          // loaded before continuing.\n\n\n          window.___navigate(prefixedTo, {\n            state: state,\n            replace: shouldReplace\n          });\n        }\n\n        return true;\n      }\n    }, rest));\n  };\n\n  return GatsbyLink;\n}(_react.default.Component);\n\nGatsbyLink.propTypes = (0, _extends2.default)({}, NavLinkPropTypes, {\n  onClick: _propTypes.default.func,\n  to: _propTypes.default.string.isRequired,\n  replace: _propTypes.default.bool,\n  state: _propTypes.default.object\n});\n\nvar showDeprecationWarning = function showDeprecationWarning(functionName, altFunctionName, version) {\n  return console.warn(\"The \\\"\" + functionName + \"\\\" method is now deprecated and will be removed in Gatsby v\" + version + \". Please use \\\"\" + altFunctionName + \"\\\" instead.\");\n};\n\nvar _default = /*#__PURE__*/_react.default.forwardRef(function (props, ref) {\n  return /*#__PURE__*/_react.default.createElement(GatsbyLinkLocationWrapper, (0, _extends2.default)({\n    innerRef: ref\n  }, props));\n});\n\nexports.default = _default;\n\nvar navigate = function navigate(to, options) {\n  window.___navigate(rewriteLinkPath(to, window.location.pathname), options);\n};\n\nexports.navigate = navigate;\n\nvar push = function push(to) {\n  showDeprecationWarning(\"push\", \"navigate\", 3);\n\n  window.___push(rewriteLinkPath(to, window.location.pathname));\n};\n\nexports.push = push;\n\nvar replace = function replace(to) {\n  showDeprecationWarning(\"replace\", \"navigate\", 3);\n\n  window.___replace(rewriteLinkPath(to, window.location.pathname));\n}; // TODO: Remove navigateTo for Gatsby v3\n\n\nexports.replace = replace;\n\nvar navigateTo = function navigateTo(to) {\n  showDeprecationWarning(\"navigateTo\", \"navigate\", 3);\n  return push(to);\n};\n\nexports.navigateTo = navigateTo;","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\nimport path from \"./path.js\";\n/**\n * Determines whether a nested path on an object has a specific value, in\n * [`R.equals`](#equals) terms. Most likely used to filter a list.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Relation\n * @typedefn Idx = String | Int\n * @sig [Idx] -> a -> {a} -> Boolean\n * @param {Array} path The path of the nested property to use\n * @param {*} val The value to compare the nested property with\n * @param {Object} obj The object to check the nested property in\n * @return {Boolean} `true` if the value equals the nested object property,\n *         `false` otherwise.\n * @example\n *\n *      const user1 = { address: { zipCode: 90210 } };\n *      const user2 = { address: { zipCode: 55555 } };\n *      const user3 = { name: 'Bob' };\n *      const users = [ user1, user2, user3 ];\n *      const isFamous = R.pathEq(['address', 'zipCode'], 90210);\n *      R.filter(isFamous, users); //=> [ user1 ]\n */\n\nvar pathEq = /*#__PURE__*/_curry3(function pathEq(_path, val, obj) {\n  return equals(path(_path, obj), val);\n});\n\nexport default pathEq;","import _curry1 from \"./internal/_curry1.js\";\nimport assoc from \"./assoc.js\";\nimport lens from \"./lens.js\";\nimport prop from \"./prop.js\";\n/**\n * Returns a lens whose focus is the specified property.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig String -> Lens s a\n * @param {String} k\n * @return {Lens}\n * @see R.view, R.set, R.over\n * @example\n *\n *      const xLens = R.lensProp('x');\n *\n *      R.view(xLens, {x: 1, y: 2});            //=> 1\n *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n */\n\nvar lensProp = /*#__PURE__*/_curry1(function lensProp(k) {\n  return lens(prop(k), assoc(k));\n});\n\nexport default lensProp;","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 = /*#__PURE__*/invoker(1, 'join');\nexport default join;","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\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};","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new object out of a list of keys and a list of values.\n * Key/value pairing is truncated to the length of the shorter of the two lists.\n * Note: `zipObj` is equivalent to `pipe(zip, fromPairs)`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [String] -> [*] -> {String: *}\n * @param {Array} keys The array that will be properties on the output object.\n * @param {Array} values The list of values on the output object.\n * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n * @example\n *\n *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n */\n\nvar zipObj = /*#__PURE__*/_curry2(function zipObj(keys, values) {\n  var idx = 0;\n  var len = Math.min(keys.length, values.length);\n  var out = {};\n\n  while (idx < len) {\n    out[keys[idx]] = values[idx];\n    idx += 1;\n  }\n\n  return out;\n});\n\nexport default zipObj;","/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","\"use strict\";\n\nexports.__esModule = true;\nexports.SessionStorage = void 0;\nvar STATE_KEY_PREFIX = \"@@scroll|\";\nvar GATSBY_ROUTER_SCROLL_STATE = \"___GATSBY_REACT_ROUTER_SCROLL\";\n\nvar SessionStorage = /*#__PURE__*/function () {\n  function SessionStorage() {}\n\n  var _proto = SessionStorage.prototype;\n\n  _proto.read = function read(location, key) {\n    var stateKey = this.getStateKey(location, key);\n\n    try {\n      var value = window.sessionStorage.getItem(stateKey);\n      return value ? JSON.parse(value) : 0;\n    } catch (e) {\n      if (process.env.NODE_ENV !== \"production\") {\n        console.warn(\"[gatsby-react-router-scroll] Unable to access sessionStorage; sessionStorage is not available.\");\n      }\n\n      if (window && window[GATSBY_ROUTER_SCROLL_STATE] && window[GATSBY_ROUTER_SCROLL_STATE][stateKey]) {\n        return window[GATSBY_ROUTER_SCROLL_STATE][stateKey];\n      }\n\n      return 0;\n    }\n  };\n\n  _proto.save = function save(location, key, value) {\n    var stateKey = this.getStateKey(location, key);\n    var storedValue = JSON.stringify(value);\n\n    try {\n      window.sessionStorage.setItem(stateKey, storedValue);\n    } catch (e) {\n      if (window && window[GATSBY_ROUTER_SCROLL_STATE]) {\n        window[GATSBY_ROUTER_SCROLL_STATE][stateKey] = JSON.parse(storedValue);\n      } else {\n        window[GATSBY_ROUTER_SCROLL_STATE] = {};\n        window[GATSBY_ROUTER_SCROLL_STATE][stateKey] = JSON.parse(storedValue);\n      }\n\n      if (process.env.NODE_ENV !== \"production\") {\n        console.warn(\"[gatsby-react-router-scroll] Unable to save state in sessionStorage; sessionStorage is not available.\");\n      }\n    }\n  };\n\n  _proto.getStateKey = function getStateKey(location, key) {\n    var stateKeyBase = \"\" + STATE_KEY_PREFIX + location.pathname;\n    return key === null || typeof key === \"undefined\" ? stateKeyBase : stateKeyBase + \"|\" + key;\n  };\n\n  return SessionStorage;\n}();\n\nexports.SessionStorage = SessionStorage;","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}","module.exports = {};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var path = require('../internals/path');\nvar global = require('../internals/global');\n\nvar aFunction = function (variable) {\n  return typeof variable == 'function' ? variable : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])\n    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","/* eslint-disable no-proto -- safe */\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n    setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;\n    setter.call(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter.call(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var defineProperty = require('../internals/object-define-property').f;\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\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}","var _typeof = require(\"@babel/runtime/helpers/typeof\")[\"default\"];\n\nfunction _getRequireWildcardCache(nodeInterop) {\n  if (typeof WeakMap !== \"function\") return null;\n  var cacheBabelInterop = new WeakMap();\n  var cacheNodeInterop = new WeakMap();\n  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {\n    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;\n  })(nodeInterop);\n}\n\nfunction _interopRequireWildcard(obj, nodeInterop) {\n  if (!nodeInterop && obj && obj.__esModule) {\n    return obj;\n  }\n\n  if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") {\n    return {\n      \"default\": obj\n    };\n  }\n\n  var cache = _getRequireWildcardCache(nodeInterop);\n\n  if (cache && cache.has(obj)) {\n    return cache.get(obj);\n  }\n\n  var newObj = {};\n  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;\n\n  for (var key in obj) {\n    if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) {\n      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;\n\n      if (desc && (desc.get || desc.set)) {\n        Object.defineProperty(newObj, key, desc);\n      } else {\n        newObj[key] = obj[key];\n      }\n    }\n  }\n\n  newObj[\"default\"] = obj;\n\n  if (cache) {\n    cache.set(obj, newObj);\n  }\n\n  return newObj;\n}\n\nmodule.exports = _interopRequireWildcard;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns the smaller of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.minBy, R.max\n * @example\n *\n *      R.min(789, 123); //=> 123\n *      R.min('a', 'b'); //=> 'a'\n */\n\nvar min = /*#__PURE__*/_curry2(function min(a, b) {\n  return b < a ? b : a;\n});\n\nexport default min;","import _curry2 from \"./internal/_curry2.js\";\nimport length from \"./length.js\";\nimport slice from \"./slice.js\";\n/**\n * Splits a given list or string at a given index.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig Number -> [a] -> [[a], [a]]\n * @sig Number -> String -> [String, String]\n * @param {Number} index The index where the array/string is split.\n * @param {Array|String} array The array/string to be split.\n * @return {Array}\n * @example\n *\n *      R.splitAt(1, [1, 2, 3]);          //=> [[1], [2, 3]]\n *      R.splitAt(5, 'hello world');      //=> ['hello', ' world']\n *      R.splitAt(-1, 'foobar');          //=> ['fooba', 'r']\n */\n\nvar splitAt = /*#__PURE__*/_curry2(function splitAt(index, array) {\n  return [slice(0, index, array), slice(index, length(array), array)];\n});\n\nexport default splitAt;","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}","import _curry2 from \"./_curry2.js\";\nimport _flatCat from \"./_flatCat.js\";\nimport map from \"../map.js\";\n\nvar _xchain = /*#__PURE__*/_curry2(function _xchain(f, xf) {\n  return map(f, _flatCat(xf));\n});\n\nexport default _xchain;","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 = /*#__PURE__*/_curry2( /*#__PURE__*/_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 _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}","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","export default path => {\n  if (path === undefined) {\n    return path\n  }\n  if (path === `/`) {\n    return `/`\n  }\n  if (path.charAt(path.length - 1) === `/`) {\n    return path.slice(0, -1)\n  }\n  return path\n}\n","import { pick } from \"@reach/router/lib/utils\"\nimport stripPrefix from \"./strip-prefix\"\nimport normalizePagePath from \"./normalize-page-path\"\n\nconst pathCache = new Map()\nlet matchPaths = []\n\nconst trimPathname = rawPathname => {\n  const pathname = decodeURIComponent(rawPathname)\n  // Remove the pathPrefix from the pathname.\n  const trimmedPathname = stripPrefix(pathname, __BASE_PATH__)\n    // Remove any hashfragment\n    .split(`#`)[0]\n    // Remove search query\n    .split(`?`)[0]\n\n  return trimmedPathname\n}\n\nfunction absolutify(path) {\n  // If it's already absolute, return as-is\n  if (\n    path.startsWith(`/`) ||\n    path.startsWith(`https://`) ||\n    path.startsWith(`http://`)\n  ) {\n    return path\n  }\n  // Calculate path relative to current location, adding a trailing slash to\n  // match behavior of @reach/router\n  return new URL(\n    path,\n    window.location.href + (window.location.href.endsWith(`/`) ? `` : `/`)\n  ).pathname\n}\n\n/**\n * Set list of matchPaths\n *\n * @param {Array<{path: string, matchPath: string}>} value collection of matchPaths\n */\nexport const setMatchPaths = value => {\n  matchPaths = value\n}\n\n/**\n * Return a matchpath url\n * if `match-paths.json` contains `{ \"/foo*\": \"/page1\", ...}`, then\n * `/foo?bar=far` => `/page1`\n *\n * @param {string} rawPathname A raw pathname\n * @return {string|null}\n */\nexport const findMatchPath = rawPathname => {\n  const trimmedPathname = cleanPath(rawPathname)\n\n  const pickPaths = matchPaths.map(({ path, matchPath }) => {\n    return {\n      path: matchPath,\n      originalPath: path,\n    }\n  })\n\n  const path = pick(pickPaths, trimmedPathname)\n\n  if (path) {\n    return normalizePagePath(path.route.originalPath)\n  }\n\n  return null\n}\n\n/**\n * Return a matchpath params from reach/router rules\n * if `match-paths.json` contains `{ \":bar/*foo\" }`, and the path is /baz/zaz/zoo\n * then it returns\n *  { bar: baz, foo: zaz/zoo }\n *\n * @param {string} rawPathname A raw pathname\n * @return {object}\n */\nexport const grabMatchParams = rawPathname => {\n  const trimmedPathname = cleanPath(rawPathname)\n\n  const pickPaths = matchPaths.map(({ path, matchPath }) => {\n    return {\n      path: matchPath,\n      originalPath: path,\n    }\n  })\n\n  const path = pick(pickPaths, trimmedPathname)\n\n  if (path) {\n    return path.params\n  }\n\n  return {}\n}\n\n// Given a raw URL path, returns the cleaned version of it (trim off\n// `#` and query params), or if it matches an entry in\n// `match-paths.json`, its matched path is returned\n//\n// E.g. `/foo?bar=far` => `/foo`\n//\n// Or if `match-paths.json` contains `{ \"/foo*\": \"/page1\", ...}`, then\n// `/foo?bar=far` => `/page1`\nexport const findPath = rawPathname => {\n  const trimmedPathname = trimPathname(absolutify(rawPathname))\n  if (pathCache.has(trimmedPathname)) {\n    return pathCache.get(trimmedPathname)\n  }\n\n  let foundPath = findMatchPath(trimmedPathname)\n\n  if (!foundPath) {\n    foundPath = cleanPath(rawPathname)\n  }\n\n  pathCache.set(trimmedPathname, foundPath)\n\n  return foundPath\n}\n\n/**\n * Clean a url and converts /index.html => /\n * E.g. `/foo?bar=far` => `/foo`\n *\n * @param {string} rawPathname A raw pathname\n * @return {string}\n */\nexport const cleanPath = rawPathname => {\n  const trimmedPathname = trimPathname(absolutify(rawPathname))\n\n  let foundPath = trimmedPathname\n  if (foundPath === `/index.html`) {\n    foundPath = `/`\n  }\n\n  foundPath = normalizePagePath(foundPath)\n\n  return foundPath\n}\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","var XWrap = /*#__PURE__*/function () {\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}","\"use strict\";\n\nexports.__esModule = true;\nexports.useScrollRestoration = useScrollRestoration;\n\nvar _scrollHandler = require(\"./scroll-handler\");\n\nvar _react = require(\"react\");\n\nvar _router = require(\"@reach/router\");\n\nfunction useScrollRestoration(identifier) {\n  var location = (0, _router.useLocation)();\n  var state = (0, _react.useContext)(_scrollHandler.ScrollContext);\n  var ref = (0, _react.useRef)();\n  (0, _react.useLayoutEffect)(function () {\n    if (ref.current) {\n      var position = state.read(location, identifier);\n      ref.current.scrollTo(0, position || 0);\n    }\n  }, []);\n  return {\n    ref: ref,\n    onScroll: function onScroll() {\n      if (ref.current) {\n        state.save(location, identifier, ref.current.scrollTop);\n      }\n    }\n  };\n}","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport map from \"./map.js\";\n/**\n * ap applies a list of functions to a list of values.\n *\n * Dispatches to the `ap` method of the second argument, if present. Also\n * treats curried functions as applicatives.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig [a -> b] -> [a] -> [b]\n * @sig Apply f => f (a -> b) -> f a -> f b\n * @sig (r -> a -> b) -> (r -> a) -> (r -> b)\n * @param {*} applyF\n * @param {*} applyX\n * @return {*}\n * @example\n *\n *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n *      R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> [\"tasty pizza\", \"tasty salad\", \"PIZZA\", \"SALAD\"]\n *\n *      // R.ap can also be used as S combinator\n *      // when only two functions are passed\n *      R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'\n * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]\n */\n\nvar ap = /*#__PURE__*/_curry2(function ap(applyF, applyX) {\n  return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {\n    return applyF(x)(applyX(x));\n  } : _reduce(function (acc, f) {\n    return _concat(acc, map(f, applyX));\n  }, [], applyF);\n});\n\nexport default ap;","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 = /*#__PURE__*/_curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n\nexport default curry;","var has = require('../internals/has');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectPrototype : null;\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n  for (var key in src) redefine(target, key, src[key], options);\n  return target;\n};\n","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 = /*#__PURE__*/_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 invoker from \"./invoker.js\";\n/**\n * The upper case version of a string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to upper case.\n * @return {String} The upper case version of `str`.\n * @see R.toLower\n * @example\n *\n *      R.toUpper('abc'); //=> 'ABC'\n */\n\nvar toUpper = /*#__PURE__*/invoker(0, 'toUpperCase');\nexport default toUpper;","import mitt from \"mitt\"\n\nconst emitter = mitt()\nexport default emitter\n","//      \n// An event handler can take an optional event argument\n// and should not return a value\n                                          \n                                                               \n\n// An array of all currently registered event handlers for a type\n                                            \n                                                            \n// A map of event types and their corresponding event handlers.\n                        \n                                 \n                                   \n  \n\n/** Mitt: Tiny (~200b) functional event emitter / pubsub.\n *  @name mitt\n *  @returns {Mitt}\n */\nfunction mitt(all                 ) {\n\tall = all || Object.create(null);\n\n\treturn {\n\t\t/**\n\t\t * Register an event handler for the given type.\n\t\t *\n\t\t * @param  {String} type\tType of event to listen for, or `\"*\"` for all events\n\t\t * @param  {Function} handler Function to call in response to given event\n\t\t * @memberOf mitt\n\t\t */\n\t\ton: function on(type        , handler              ) {\n\t\t\t(all[type] || (all[type] = [])).push(handler);\n\t\t},\n\n\t\t/**\n\t\t * Remove an event handler for the given type.\n\t\t *\n\t\t * @param  {String} type\tType of event to unregister `handler` from, or `\"*\"`\n\t\t * @param  {Function} handler Handler function to remove\n\t\t * @memberOf mitt\n\t\t */\n\t\toff: function off(type        , handler              ) {\n\t\t\tif (all[type]) {\n\t\t\t\tall[type].splice(all[type].indexOf(handler) >>> 0, 1);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Invoke all handlers for the given type.\n\t\t * If present, `\"*\"` handlers are invoked after type-matched handlers.\n\t\t *\n\t\t * @param {String} type  The event type to invoke\n\t\t * @param {Any} [evt]  Any value (object is recommended and powerful), passed to each handler\n\t\t * @memberOf mitt\n\t\t */\n\t\temit: function emit(type        , evt     ) {\n\t\t\t(all[type] || []).slice().map(function (handler) { handler(evt); });\n\t\t\t(all['*'] || []).slice().map(function (handler) { handler(type, evt); });\n\t\t}\n\t};\n}\n\nexport default mitt;\n//# sourceMappingURL=mitt.es.js.map\n","import _curry2 from \"./internal/_curry2.js\";\nimport _indexOf from \"./internal/_indexOf.js\";\nimport _isArray from \"./internal/_isArray.js\";\n/**\n * Returns the position of the first occurrence of an item in an array, or -1\n * if the item is not included in the array. [`R.equals`](#equals) is used to\n * determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Number\n * @param {*} target The item to find.\n * @param {Array} xs The array to search in.\n * @return {Number} the index of the target, or -1 if the target is not found.\n * @see R.lastIndexOf\n * @example\n *\n *      R.indexOf(3, [1,2,3,4]); //=> 2\n *      R.indexOf(10, [1,2,3,4]); //=> -1\n */\n\nvar indexOf = /*#__PURE__*/_curry2(function indexOf(target, xs) {\n  return typeof xs.indexOf === 'function' && !_isArray(xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n});\n\nexport default indexOf;","var has = require('../internals/has');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","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 === 1;\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 = /*#__PURE__*/_curry2(function reject(pred, filterable) {\n  return filter(_complement(pred), filterable);\n});\n\nexport default reject;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Tests the final argument by passing it to the given predicate function. If\n * the predicate is satisfied, the function will return the result of calling\n * the `whenTrueFn` function with the same argument. If the predicate is not\n * satisfied, the argument is returned as is.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred       A predicate function\n * @param {Function} whenTrueFn A function to invoke when the `condition`\n *                              evaluates to a truthy value.\n * @param {*}        x          An object to test with the `pred` function and\n *                              pass to `whenTrueFn` if necessary.\n * @return {*} Either `x` or the result of applying `x` to `whenTrueFn`.\n * @see R.ifElse, R.unless, R.cond\n * @example\n *\n *      // truncate :: String -> String\n *      const truncate = R.when(\n *        R.propSatisfies(R.gt(R.__, 10), 'length'),\n *        R.pipe(R.take(10), R.append('…'), R.join(''))\n *      );\n *      truncate('12345');         //=> '12345'\n *      truncate('0123456789ABC'); //=> '0123456789…'\n */\n\nvar when = /*#__PURE__*/_curry3(function when(pred, whenTrueFn, x) {\n  return pred(x) ? whenTrueFn(x) : x;\n});\n\nexport default when;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Adds two values.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a\n * @param {Number} b\n * @return {Number}\n * @see R.subtract\n * @example\n *\n *      R.add(2, 3);       //=>  5\n *      R.add(7)(10);      //=> 17\n */\n\nvar add = /*#__PURE__*/_curry2(function add(a, b) {\n  return Number(a) + Number(b);\n});\n\nexport default add;","import add from \"./add.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Adds together all the elements of a list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list An array of numbers\n * @return {Number} The sum of all the numbers in the list.\n * @see R.reduce\n * @example\n *\n *      R.sum([2,4,6,8,100,1]); //=> 121\n */\n\nvar sum = /*#__PURE__*/reduce(add, 0);\nexport default sum;","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Takes a list of predicates and returns a predicate that returns true for a\n * given list of arguments if at least one of the provided predicates is\n * satisfied by those arguments.\n *\n * The function returned is a curried function whose arity matches that of the\n * highest-arity predicate.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Logic\n * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n * @param {Array} predicates An array of predicates to check\n * @return {Function} The combined predicate\n * @see R.allPass\n * @example\n *\n *      const isClub = R.propEq('suit', '♣');\n *      const isSpade = R.propEq('suit', '♠');\n *      const isBlackCard = R.anyPass([isClub, isSpade]);\n *\n *      isBlackCard({rank: '10', suit: '♣'}); //=> true\n *      isBlackCard({rank: 'Q', suit: '♠'}); //=> true\n *      isBlackCard({rank: 'Q', suit: '♦'}); //=> false\n */\n\nvar anyPass = /*#__PURE__*/_curry1(function anyPass(preds) {\n  return curryN(reduce(max, 0, pluck('length', preds)), function () {\n    var idx = 0;\n    var len = preds.length;\n\n    while (idx < len) {\n      if (preds[idx].apply(this, arguments)) {\n        return true;\n      }\n\n      idx += 1;\n    }\n\n    return false;\n  });\n});\n\nexport default anyPass;","\"use strict\";\n\nexports.__esModule = true;\nexports.useScrollRestoration = exports.ScrollContainer = exports.ScrollContext = void 0;\n\nvar _scrollHandler = require(\"./scroll-handler\");\n\nexports.ScrollContext = _scrollHandler.ScrollHandler;\n\nvar _scrollContainer = require(\"./scroll-container\");\n\nexports.ScrollContainer = _scrollContainer.ScrollContainer;\n\nvar _useScrollRestoration = require(\"./use-scroll-restoration\");\n\nexports.useScrollRestoration = _useScrollRestoration.useScrollRestoration;","import _curryN from \"./_curryN.js\";\nimport _has from \"./_has.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XReduceBy = /*#__PURE__*/function () {\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 = /*#__PURE__*/_curryN(4, [], function _xreduceBy(valueFn, valueAcc, keyFn, xf) {\n  return new XReduceBy(valueFn, valueAcc, keyFn, xf);\n});\n\nexport default _xreduceBy;","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 _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 * 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\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 = /*#__PURE__*/_curryN(4, [], /*#__PURE__*/_dispatchable([], _xreduceBy, function reduceBy(valueFn, valueAcc, keyFn, list) {\n  return _reduce(function (acc, elt) {\n    var key = keyFn(elt);\n    acc[key] = valueFn(_has(key, acc) ? acc[key] : _clone(valueAcc, [], [], false), elt);\n    return acc;\n  }, {}, list);\n}));\n\nexport default reduceBy;","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}","function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nmodule.exports = _objectWithoutPropertiesLoose;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the specified value is equal, in [`R.equals`](#equals)\n * terms, to at least one element of the given list; `false` otherwise.\n * Works also with strings.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.\n * @see R.any\n * @example\n *\n *      R.includes(3, [1, 2, 3]); //=> true\n *      R.includes(4, [1, 2, 3]); //=> false\n *      R.includes({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true\n *      R.includes([42], [[42]]); //=> true\n *      R.includes('ba', 'banana'); //=>true\n */\n\nvar includes = /*#__PURE__*/_curry2(_includes);\n\nexport default includes;","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport reduceBy from \"./reduceBy.js\";\n/**\n * Splits a list into sub-lists stored in an object, based on the result of\n * calling a String-returning function on each element, and grouping the\n * results according to values returned.\n *\n * Dispatches to the `groupBy` 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 (a -> String) -> [a] -> {String: [a]}\n * @param {Function} fn Function :: a -> String\n * @param {Array} list The array to group\n * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n *         that produced that key when passed to `fn`.\n * @see R.reduceBy, R.transduce\n * @example\n *\n *      const byGrade = R.groupBy(function(student) {\n *        const score = student.score;\n *        return score < 65 ? 'F' :\n *               score < 70 ? 'D' :\n *               score < 80 ? 'C' :\n *               score < 90 ? 'B' : 'A';\n *      });\n *      const students = [{name: 'Abby', score: 84},\n *                      {name: 'Eddy', score: 58},\n *                      // ...\n *                      {name: 'Jack', score: 69}];\n *      byGrade(students);\n *      // {\n *      //   'A': [{name: 'Dianne', score: 99}],\n *      //   'B': [{name: 'Abby', score: 84}]\n *      //   // ...,\n *      //   'F': [{name: 'Eddy', score: 58}]\n *      // }\n */\n\nvar groupBy = /*#__PURE__*/_curry2( /*#__PURE__*/_checkForMethod('groupBy', /*#__PURE__*/reduceBy(function (acc, item) {\n  if (acc == null) {\n    acc = [];\n  }\n\n  acc.push(item);\n  return acc;\n}, null)));\n\nexport default groupBy;","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","exports.polyfill = Component => Component\n","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Tests a regular expression against a String. Note that this function will\n * return an empty array when there are no matches. This differs from\n * [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n * which returns `null` when there are no matches.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category String\n * @sig RegExp -> String -> [String | Undefined]\n * @param {RegExp} rx A regular expression.\n * @param {String} str The string to match against\n * @return {Array} The list of matches or empty array.\n * @see R.test\n * @example\n *\n *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n *      R.match(/a/, 'b'); //=> []\n *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n */\n\nvar match = /*#__PURE__*/_curry2(function match(rx, str) {\n  return str.match(rx) || [];\n});\n\nexport default match;","import nth from \"./nth.js\";\n/**\n * Returns the last element of the given list or string.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.init, R.head, R.tail\n * @example\n *\n *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n *      R.last([]); //=> undefined\n *\n *      R.last('abc'); //=> 'c'\n *      R.last(''); //=> ''\n */\n\nvar last = /*#__PURE__*/nth(-1);\nexport default last;","var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar getLocation = function getLocation(source) {\n  var _source$location = source.location,\n      search = _source$location.search,\n      hash = _source$location.hash,\n      href = _source$location.href,\n      origin = _source$location.origin,\n      protocol = _source$location.protocol,\n      host = _source$location.host,\n      hostname = _source$location.hostname,\n      port = _source$location.port;\n  var pathname = source.location.pathname;\n\n\n  if (!pathname && href && canUseDOM) {\n    var url = new URL(href);\n    pathname = url.pathname;\n  }\n\n  return {\n    pathname: encodeURI(decodeURI(pathname)),\n    search: search,\n    hash: hash,\n    href: href,\n    origin: origin,\n    protocol: protocol,\n    host: host,\n    hostname: hostname,\n    port: port,\n    state: source.history.state,\n    key: source.history.state && source.history.state.key || \"initial\"\n  };\n};\n\nvar createHistory = function createHistory(source, options) {\n  var listeners = [];\n  var location = getLocation(source);\n  var transitioning = false;\n  var resolveTransition = function resolveTransition() {};\n\n  return {\n    get location() {\n      return location;\n    },\n\n    get transitioning() {\n      return transitioning;\n    },\n\n    _onTransitionComplete: function _onTransitionComplete() {\n      transitioning = false;\n      resolveTransition();\n    },\n    listen: function listen(listener) {\n      listeners.push(listener);\n\n      var popstateListener = function popstateListener() {\n        location = getLocation(source);\n        listener({ location: location, action: \"POP\" });\n      };\n\n      source.addEventListener(\"popstate\", popstateListener);\n\n      return function () {\n        source.removeEventListener(\"popstate\", popstateListener);\n        listeners = listeners.filter(function (fn) {\n          return fn !== listener;\n        });\n      };\n    },\n    navigate: function navigate(to) {\n      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n          state = _ref.state,\n          _ref$replace = _ref.replace,\n          replace = _ref$replace === undefined ? false : _ref$replace;\n\n      if (typeof to === \"number\") {\n        source.history.go(to);\n      } else {\n        state = _extends({}, state, { key: Date.now() + \"\" });\n        // try...catch iOS Safari limits to 100 pushState calls\n        try {\n          if (transitioning || replace) {\n            source.history.replaceState(state, null, to);\n          } else {\n            source.history.pushState(state, null, to);\n          }\n        } catch (e) {\n          source.location[replace ? \"replace\" : \"assign\"](to);\n        }\n      }\n\n      location = getLocation(source);\n      transitioning = true;\n      var transition = new Promise(function (res) {\n        return resolveTransition = res;\n      });\n      listeners.forEach(function (listener) {\n        return listener({ location: location, action: \"PUSH\" });\n      });\n      return transition;\n    }\n  };\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Stores history entries in memory for testing or other platforms like Native\nvar createMemorySource = function createMemorySource() {\n  var initialPath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : \"/\";\n\n  var searchIndex = initialPath.indexOf(\"?\");\n  var initialLocation = {\n    pathname: searchIndex > -1 ? initialPath.substr(0, searchIndex) : initialPath,\n    search: searchIndex > -1 ? initialPath.substr(searchIndex) : \"\"\n  };\n  var index = 0;\n  var stack = [initialLocation];\n  var states = [null];\n\n  return {\n    get location() {\n      return stack[index];\n    },\n    addEventListener: function addEventListener(name, fn) {},\n    removeEventListener: function removeEventListener(name, fn) {},\n\n    history: {\n      get entries() {\n        return stack;\n      },\n      get index() {\n        return index;\n      },\n      get state() {\n        return states[index];\n      },\n      pushState: function pushState(state, _, uri) {\n        var _uri$split = uri.split(\"?\"),\n            pathname = _uri$split[0],\n            _uri$split$ = _uri$split[1],\n            search = _uri$split$ === undefined ? \"\" : _uri$split$;\n\n        index++;\n        stack.push({ pathname: pathname, search: search.length ? \"?\" + search : search });\n        states.push(state);\n      },\n      replaceState: function replaceState(state, _, uri) {\n        var _uri$split2 = uri.split(\"?\"),\n            pathname = _uri$split2[0],\n            _uri$split2$ = _uri$split2[1],\n            search = _uri$split2$ === undefined ? \"\" : _uri$split2$;\n\n        stack[index] = { pathname: pathname, search: search };\n        states[index] = state;\n      },\n      go: function go(to) {\n        var newIndex = index + to;\n\n        if (newIndex < 0 || newIndex > states.length - 1) {\n          return;\n        }\n\n        index = newIndex;\n      }\n    }\n  };\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// global history - uses window.history as the source if available, otherwise a\n// memory history\nvar canUseDOM = !!(typeof window !== \"undefined\" && window.document && window.document.createElement);\nvar getSource = function getSource() {\n  return canUseDOM ? window : createMemorySource();\n};\n\nvar globalHistory = createHistory(getSource());\nvar navigate = globalHistory.navigate;\n\n////////////////////////////////////////////////////////////////////////////////\n\nexport { globalHistory, navigate, createHistory, createMemorySource };","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n  var O, tag, result;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n    // builtinTag case\n    : CORRECT_ARGUMENTS ? classofRaw(O)\n    // ES3 arguments fallback\n    : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;\n};\n","export default function _isNumber(x) {\n  return Object.prototype.toString.call(x) === '[object Number]';\n}","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFindIndex = /*#__PURE__*/function () {\n  function XFindIndex(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.idx = -1;\n    this.found = false;\n  }\n\n  XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFindIndex.prototype['@@transducer/result'] = function (result) {\n    if (!this.found) {\n      result = this.xf['@@transducer/step'](result, -1);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n    this.idx += 1;\n\n    if (this.f(input)) {\n      this.found = true;\n      result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n    }\n\n    return result;\n  };\n\n  return XFindIndex;\n}();\n\nvar _xfindIndex = /*#__PURE__*/_curry2(function _xfindIndex(f, xf) {\n  return new XFindIndex(f, xf);\n});\n\nexport default _xfindIndex;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfindIndex from \"./internal/_xfindIndex.js\";\n/**\n * Returns the index of the first element of the list which matches the\n * predicate, or `-1` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> Number\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Number} The index of the element found, or `-1`.\n * @see R.transduce\n * @example\n *\n *      const xs = [{a: 1}, {a: 2}, {a: 3}];\n *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n */\n\nvar findIndex = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xfindIndex, function findIndex(fn, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      return idx;\n    }\n\n    idx += 1;\n  }\n\n  return -1;\n}));\n\nexport default findIndex;","var aFunction = require('../internals/a-function');\n\n// optional / simple context binding\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 0: return function () {\n      return fn.call(that);\n    };\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns `true` if the specified object property is equal, in\n * [`R.equals`](#equals) terms, to the given value; `false` otherwise.\n * You can test multiple properties with [`R.whereEq`](#whereEq).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig String -> a -> Object -> Boolean\n * @param {String} name\n * @param {*} val\n * @param {*} obj\n * @return {Boolean}\n * @see R.whereEq, R.propSatisfies, R.equals\n * @example\n *\n *      const abby = {name: 'Abby', age: 7, hair: 'blond'};\n *      const fred = {name: 'Fred', age: 12, hair: 'brown'};\n *      const rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n *      const alois = {name: 'Alois', age: 15, disposition: 'surly'};\n *      const kids = [abby, fred, rusty, alois];\n *      const hasBrownHair = R.propEq('hair', 'brown');\n *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n */\n\nvar propEq = /*#__PURE__*/_curry3(function propEq(name, val, obj) {\n  return equals(val, obj[name]);\n});\n\nexport default propEq;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XAll = /*#__PURE__*/function () {\n  function XAll(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.all = true;\n  }\n\n  XAll.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAll.prototype['@@transducer/result'] = function (result) {\n    if (this.all) {\n      result = this.xf['@@transducer/step'](result, true);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAll.prototype['@@transducer/step'] = function (result, input) {\n    if (!this.f(input)) {\n      this.all = false;\n      result = _reduced(this.xf['@@transducer/step'](result, false));\n    }\n\n    return result;\n  };\n\n  return XAll;\n}();\n\nvar _xall = /*#__PURE__*/_curry2(function _xall(f, xf) {\n  return new XAll(f, xf);\n});\n\nexport default _xall;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xall from \"./internal/_xall.js\";\n/**\n * Returns `true` if all elements of the list match the predicate, `false` if\n * there are any that don't.\n *\n * Dispatches to the `all` 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 (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n *         otherwise.\n * @see R.any, R.none, R.transduce\n * @example\n *\n *      const equals3 = R.equals(3);\n *      R.all(equals3)([3, 3, 3, 3]); //=> true\n *      R.all(equals3)([3, 3, 1, 3]); //=> false\n */\n\nvar all = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['all'], _xall, function all(fn, list) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (!fn(list[idx])) {\n      return false;\n    }\n\n    idx += 1;\n  }\n\n  return true;\n}));\n\nexport default all;","/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig * -> Boolean\n * @param {*}\n * @return {Boolean}\n * @see R.F\n * @example\n *\n *      R.T(); //=> true\n */\nvar T = function () {\n  return true;\n};\n\nexport default T;","var DESCRIPTORS = require('../internals/descriptors');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\n};\n","import _curry3 from \"./internal/_curry3.js\";\nimport pathOr from \"./pathOr.js\";\n/**\n * If the given, non-null object has an own property with the specified name,\n * returns the value of that property. Otherwise returns the provided default\n * value.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Object\n * @sig a -> String -> Object -> a\n * @param {*} val The default value.\n * @param {String} p The name of the property to return.\n * @param {Object} obj The object to query.\n * @return {*} The value of given property of the supplied object or the default value.\n * @example\n *\n *      const alice = {\n *        name: 'ALICE',\n *        age: 101\n *      };\n *      const favorite = R.prop('favoriteLibrary');\n *      const favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n *\n *      favorite(alice);  //=> undefined\n *      favoriteWithDefault(alice);  //=> 'Ramda'\n */\n\nvar propOr = /*#__PURE__*/_curry3(function propOr(val, p, obj) {\n  return pathOr(val, [p], obj);\n});\n\nexport default propOr;","import _curry2 from \"./internal/_curry2.js\";\nimport path from \"./path.js\";\n/**\n * Returns a function that when supplied an object returns the indicated\n * property of that object, if it exists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig Idx -> {s: a} -> a | Undefined\n * @param {String|Number} p The property name or array index\n * @param {Object} obj The object to query\n * @return {*} The value at `obj.p`.\n * @see R.path, R.nth\n * @example\n *\n *      R.prop('x', {x: 100}); //=> 100\n *      R.prop('x', {}); //=> undefined\n *      R.prop(0, [100]); //=> 100\n *      R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4\n */\n\nvar prop = /*#__PURE__*/_curry2(function prop(p, obj) {\n  return path([p], obj);\n});\n\nexport default prop;","import _curry2 from \"./internal/_curry2.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport keys from \"./keys.js\";\n/**\n * An Object-specific version of [`map`](#map). The function is applied to three\n * arguments: *(value, key, obj)*. If only the value is significant, use\n * [`map`](#map) instead.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig ((*, String, Object) -> *) -> Object -> Object\n * @param {Function} fn\n * @param {Object} obj\n * @return {Object}\n * @see R.map\n * @example\n *\n *      const xyz = { x: 1, y: 2, z: 3 };\n *      const prependKeyAndDouble = (num, key, obj) => key + (num * 2);\n *\n *      R.mapObjIndexed(prependKeyAndDouble, xyz); //=> { x: 'x2', y: 'y4', z: 'z6' }\n */\n\nvar mapObjIndexed = /*#__PURE__*/_curry2(function mapObjIndexed(fn, obj) {\n  return _reduce(function (acc, key) {\n    acc[key] = fn(obj[key], key, obj);\n    return acc;\n  }, {}, keys(obj));\n});\n\nexport default mapObjIndexed;","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 _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}","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","var fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = !fails(function () {\n  var url = new URL('b?a=1&b=2&c=3', 'http://a');\n  var searchParams = url.searchParams;\n  var result = '';\n  url.pathname = 'c%20d';\n  searchParams.forEach(function (value, key) {\n    searchParams['delete']('b');\n    result += key + value;\n  });\n  return (IS_PURE && !url.toJSON)\n    || !searchParams.sort\n    || url.href !== 'http://a/c%20d?a=1&c=3'\n    || searchParams.get('c') !== '3'\n    || String(new URLSearchParams('?a=1')) !== 'a=1'\n    || !searchParams[ITERATOR]\n    // throws in Edge\n    || new URL('https://a@b').username !== 'a'\n    || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'\n    // not punycoded in Edge\n    || new URL('http://тест').host !== 'xn--e1aybc'\n    // not escaped in Chrome 62-\n    || new URL('http://a#б').hash !== '#%D0%B1'\n    // fails in Chrome 66-\n    || result !== 'a1c3'\n    // throws in Safari\n    || new URL('http://x', undefined).host !== 'x';\n});\n","\"use strict\";\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.ScrollHandler = exports.ScrollContext = void 0;\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _sessionStorage = require(\"./session-storage\");\n\nvar ScrollContext = /*#__PURE__*/React.createContext(new _sessionStorage.SessionStorage());\nexports.ScrollContext = ScrollContext;\nScrollContext.displayName = \"GatsbyScrollContext\";\n\nvar ScrollHandler = /*#__PURE__*/function (_React$Component) {\n  (0, _inheritsLoose2.default)(ScrollHandler, _React$Component);\n\n  function ScrollHandler() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this._stateStorage = new _sessionStorage.SessionStorage();\n\n    _this.scrollListener = function () {\n      var key = _this.props.location.key;\n\n      if (key) {\n        _this._stateStorage.save(_this.props.location, key, window.scrollY);\n      }\n    };\n\n    _this.windowScroll = function (position, prevProps) {\n      if (_this.shouldUpdateScroll(prevProps, _this.props)) {\n        window.scrollTo(0, position);\n      }\n    };\n\n    _this.scrollToHash = function (hash, prevProps) {\n      var node = document.getElementById(hash.substring(1));\n\n      if (node && _this.shouldUpdateScroll(prevProps, _this.props)) {\n        node.scrollIntoView();\n      }\n    };\n\n    _this.shouldUpdateScroll = function (prevRouterProps, routerProps) {\n      var shouldUpdateScroll = _this.props.shouldUpdateScroll;\n\n      if (!shouldUpdateScroll) {\n        return true;\n      } // Hack to allow accessing this._stateStorage.\n\n\n      return shouldUpdateScroll.call((0, _assertThisInitialized2.default)(_this), prevRouterProps, routerProps);\n    };\n\n    return _this;\n  }\n\n  var _proto = ScrollHandler.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    window.addEventListener(\"scroll\", this.scrollListener);\n    var scrollPosition;\n    var _this$props$location = this.props.location,\n        key = _this$props$location.key,\n        hash = _this$props$location.hash;\n\n    if (key) {\n      scrollPosition = this._stateStorage.read(this.props.location, key);\n    }\n\n    if (scrollPosition) {\n      this.windowScroll(scrollPosition, undefined);\n    } else if (hash) {\n      this.scrollToHash(decodeURI(hash), undefined);\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    window.removeEventListener(\"scroll\", this.scrollListener);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var _this$props$location2 = this.props.location,\n        hash = _this$props$location2.hash,\n        key = _this$props$location2.key;\n    var scrollPosition;\n\n    if (key) {\n      scrollPosition = this._stateStorage.read(this.props.location, key);\n    }\n    /**  There are two pieces of state: the browser url and\n     * history state which keeps track of scroll position\n     * Native behaviour prescribes that we ought to restore scroll position\n     * when a user navigates back in their browser (this is the `POP` action)\n     * Currently, reach router has a bug that prevents this at https://github.com/reach/router/issues/228\n     * So we _always_ stick to the url as a source of truth — if the url\n     * contains a hash, we scroll to it\n     */\n\n\n    if (hash) {\n      this.scrollToHash(decodeURI(hash), prevProps);\n    } else {\n      this.windowScroll(scrollPosition, prevProps);\n    }\n  };\n\n  _proto.render = function render() {\n    return /*#__PURE__*/React.createElement(ScrollContext.Provider, {\n      value: this._stateStorage\n    }, this.props.children);\n  };\n\n  return ScrollHandler;\n}(React.Component);\n\nexports.ScrollHandler = ScrollHandler;\nScrollHandler.propTypes = {\n  shouldUpdateScroll: _propTypes.default.func,\n  children: _propTypes.default.element.isRequired,\n  location: _propTypes.default.object.isRequired\n};","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments, regardless of\n * their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are\n * 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)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @name __\n * @constant\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @example\n *\n *      const greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nexport default {\n  '@@functional/placeholder': true\n};","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 */\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}","module.exports = function (it, Constructor, name) {\n  if (!(it instanceof Constructor)) {\n    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');\n  } return it;\n};\n","const R = require(\"ramda\");\r\n\r\n/**\r\n * Implement Gatsby's Browser APIs in this file.\r\n *\r\n * See: https://www.gatsbyjs.org/docs/browser-apis/\r\n */\r\n\r\n// You can delete this file if you're not using it\r\n\r\nexports.shouldUpdateScroll = (apiCallbackContext, pluginOptions) => {\r\n  const fromMapPage = R.compose(\r\n    R.test(/\\/map/),\r\n    R.path([\"prevRouterProps\", \"location\", \"pathname\"]),\r\n  )(apiCallbackContext);\r\n\r\n  const toMapPage = R.compose(\r\n    R.test(/\\/map/),\r\n    R.path([\"routerProps\", \"location\", \"pathname\"]),\r\n  )(apiCallbackContext);\r\n\r\n  // Prevent gatsby from scrolling to the top of the page when navigating on the\r\n  // /map page\r\n  if (fromMapPage && toMapPage) {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n};\r\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 = /*#__PURE__*/_curry1(_identity);\n\nexport default identity;","module.exports = function (it) {\n  if (typeof it != 'function') {\n    throw TypeError(String(it) + ' is not a function');\n  } return it;\n};\n","// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty === typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Replace a substring or regex match in a string with a replacement.\n *\n * The first two parameters correspond to the parameters of the\n * `String.prototype.replace()` function, so the second parameter can also be a\n * function.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category String\n * @sig RegExp|String -> String -> String -> String\n * @param {RegExp|String} pattern A regular expression or a substring to match.\n * @param {String} replacement The string to replace the matches with.\n * @param {String} str The String to do the search and replacement in.\n * @return {String} The result.\n * @example\n *\n *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n *\n *      // Use the \"g\" (global) flag to replace all occurrences:\n *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n */\n\nvar replace = /*#__PURE__*/_curry3(function replace(regex, replacement, str) {\n  return str.replace(regex, replacement);\n});\n\nexport default replace;","import _curry2 from \"./internal/_curry2.js\";\nimport paths from \"./paths.js\";\n/**\n * Retrieve the value at a given path.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {a} -> a | Undefined\n * @param {Array} path The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path`.\n * @see R.prop, R.nth\n * @example\n *\n *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n *      R.path(['a', 'b', 0], {a: {b: [1, 2, 3]}}); //=> 1\n *      R.path(['a', 'b', -2], {a: {b: [1, 2, 3]}}); //=> 2\n */\n\nvar path = /*#__PURE__*/_curry2(function path(pathAr, obj) {\n  return paths([pathAr], obj)[0];\n});\n\nexport default path;","var toInteger = require('../internals/to-integer');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toInteger(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","import _curry2 from \"./internal/_curry2.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport lift from \"./lift.js\";\nimport or from \"./or.js\";\n/**\n * A function wrapping calls to the two functions in an `||` operation,\n * returning the result of the first function if it is truth-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * truth-y value.\n *\n * In addition to functions, `R.either` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f a predicate\n * @param {Function} g another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n * @see R.or\n * @example\n *\n *      const gt10 = x => x > 10;\n *      const even = x => x % 2 === 0;\n *      const f = R.either(gt10, even);\n *      f(101); //=> true\n *      f(8); //=> true\n *\n *      R.either(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(55)\n *      R.either([false, false, 'a'], [11]) // => [11, 11, \"a\"]\n */\n\nvar either = /*#__PURE__*/_curry2(function either(f, g) {\n  return _isFunction(f) ? function _either() {\n    return f.apply(this, arguments) || g.apply(this, arguments);\n  } : lift(or)(f, g);\n});\n\nexport default either;","import React, { createElement } from \"react\"\nimport PropTypes from \"prop-types\"\nimport { publicLoader } from \"./loader\"\nimport { apiRunner } from \"./api-runner-browser\"\nimport { grabMatchParams } from \"./find-path\"\n\n// Renders page\nclass PageRenderer extends React.Component {\n  render() {\n    const props = {\n      ...this.props,\n      params: {\n        ...grabMatchParams(this.props.location.pathname),\n        ...this.props.pageResources.json.pageContext.__params,\n      },\n      pathContext: this.props.pageContext,\n    }\n\n    const [replacementElement] = apiRunner(`replaceComponentRenderer`, {\n      props: this.props,\n      loader: publicLoader,\n    })\n\n    const pageElement =\n      replacementElement ||\n      createElement(this.props.pageResources.component, {\n        ...props,\n        key: this.props.path || this.props.pageResources.page.path,\n      })\n\n    const wrappedPage = apiRunner(\n      `wrapPageElement`,\n      { element: pageElement, props },\n      pageElement,\n      ({ result }) => {\n        return { element: result, props }\n      }\n    ).pop()\n\n    return wrappedPage\n  }\n}\n\nPageRenderer.propTypes = {\n  location: PropTypes.object.isRequired,\n  pageResources: PropTypes.object.isRequired,\n  data: PropTypes.object,\n  pageContext: PropTypes.object.isRequired,\n}\n\nexport default PageRenderer\n","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XTake = /*#__PURE__*/function () {\n  function XTake(n, xf) {\n    this.xf = xf;\n    this.n = n;\n    this.i = 0;\n  }\n\n  XTake.prototype['@@transducer/init'] = _xfBase.init;\n  XTake.prototype['@@transducer/result'] = _xfBase.result;\n\n  XTake.prototype['@@transducer/step'] = function (result, input) {\n    this.i += 1;\n    var ret = this.n === 0 ? result : this.xf['@@transducer/step'](result, input);\n    return this.n >= 0 && this.i >= this.n ? _reduced(ret) : ret;\n  };\n\n  return XTake;\n}();\n\nvar _xtake = /*#__PURE__*/_curry2(function _xtake(n, xf) {\n  return new XTake(n, xf);\n});\n\nexport default _xtake;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xtake from \"./internal/_xtake.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns the first `n` elements of the given list, string, or\n * transducer/transformer (or object with a `take` method).\n *\n * Dispatches to the `take` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n\n * @param {*} list\n * @return {*}\n * @see R.drop\n * @example\n *\n *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.take(3, 'ramda');               //=> 'ram'\n *\n *      const personnel = [\n *        'Dave Brubeck',\n *        'Paul Desmond',\n *        'Eugene Wright',\n *        'Joe Morello',\n *        'Gerry Mulligan',\n *        'Bob Bates',\n *        'Joe Dodge',\n *        'Ron Crotty'\n *      ];\n *\n *      const takeFive = R.take(5);\n *      takeFive(personnel);\n *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n * @symb R.take(-1, [a, b]) = [a, b]\n * @symb R.take(0, [a, b]) = []\n * @symb R.take(1, [a, b]) = [a]\n * @symb R.take(2, [a, b]) = [a, b]\n */\n\nvar take = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['take'], _xtake, function take(n, xs) {\n  return slice(0, n < 0 ? Infinity : n, xs);\n}));\n\nexport default take;","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","export default function _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n}","\"use strict\";\n\nexports.onRouteUpdate = function (_, pluginOptions) {\n  if (process.env.NODE_ENV === \"production\" || pluginOptions.includeInDevelopment) {\n    // wrap inside a timeout to ensure the title has properly been changed\n    setTimeout(function () {\n      var data = pluginOptions.dataLayerName ? window[pluginOptions.dataLayerName] : window.dataLayer;\n      var eventName = pluginOptions.routeChangeEventName ? pluginOptions.routeChangeEventName : \"gatsby-route-change\";\n      data.push({\n        event: eventName\n      });\n    }, 50);\n  }\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 _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFilter = /*#__PURE__*/function () {\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 = /*#__PURE__*/_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 = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['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 _identity(x) {\n  return x;\n}","var anObject = require('../internals/an-object');\n\nmodule.exports = function (iterator) {\n  var returnMethod = iterator['return'];\n  if (returnMethod !== undefined) {\n    return anObject(returnMethod.call(iterator)).value;\n  }\n};\n","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Sorts the list according to the supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord b => (a -> b) -> [a] -> [a]\n * @param {Function} fn\n * @param {Array} list The list to sort.\n * @return {Array} A new list sorted by the keys generated by `fn`.\n * @example\n *\n *      const sortByFirstItem = R.sortBy(R.prop(0));\n *      const pairs = [[-1, 1], [-2, 2], [-3, 3]];\n *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n *\n *      const sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n *      const alice = {\n *        name: 'ALICE',\n *        age: 101\n *      };\n *      const bob = {\n *        name: 'Bob',\n *        age: -10\n *      };\n *      const clara = {\n *        name: 'clara',\n *        age: 314.159\n *      };\n *      const people = [clara, bob, alice];\n *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n */\n\nvar sortBy = /*#__PURE__*/_curry2(function sortBy(fn, list) {\n  return Array.prototype.slice.call(list, 0).sort(function (a, b) {\n    var aa = fn(a);\n    var bb = fn(b);\n    return aa < bb ? -1 : aa > bb ? 1 : 0;\n  });\n});\n\nexport default sortBy;","'use strict';\n// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`\nrequire('../modules/es.string.iterator');\nvar $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar USE_NATIVE_URL = require('../internals/native-url');\nvar global = require('../internals/global');\nvar defineProperties = require('../internals/object-define-properties');\nvar redefine = require('../internals/redefine');\nvar anInstance = require('../internals/an-instance');\nvar has = require('../internals/has');\nvar assign = require('../internals/object-assign');\nvar arrayFrom = require('../internals/array-from');\nvar codeAt = require('../internals/string-multibyte').codeAt;\nvar toASCII = require('../internals/string-punycode-to-ascii');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar URLSearchParamsModule = require('../modules/web.url-search-params');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar NativeURL = global.URL;\nvar URLSearchParams = URLSearchParamsModule.URLSearchParams;\nvar getInternalSearchParamsState = URLSearchParamsModule.getState;\nvar setInternalState = InternalStateModule.set;\nvar getInternalURLState = InternalStateModule.getterFor('URL');\nvar floor = Math.floor;\nvar pow = Math.pow;\n\nvar INVALID_AUTHORITY = 'Invalid authority';\nvar INVALID_SCHEME = 'Invalid scheme';\nvar INVALID_HOST = 'Invalid host';\nvar INVALID_PORT = 'Invalid port';\n\nvar ALPHA = /[A-Za-z]/;\n// eslint-disable-next-line regexp/no-obscure-range -- safe\nvar ALPHANUMERIC = /[\\d+-.A-Za-z]/;\nvar DIGIT = /\\d/;\nvar HEX_START = /^0x/i;\nvar OCT = /^[0-7]+$/;\nvar DEC = /^\\d+$/;\nvar HEX = /^[\\dA-Fa-f]+$/;\n/* eslint-disable no-control-regex -- safe */\nvar FORBIDDEN_HOST_CODE_POINT = /[\\0\\t\\n\\r #%/:<>?@[\\\\\\]^|]/;\nvar FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\\0\\t\\n\\r #/:<>?@[\\\\\\]^|]/;\nvar LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\\u0000-\\u001F ]+|[\\u0000-\\u001F ]+$/g;\nvar TAB_AND_NEW_LINE = /[\\t\\n\\r]/g;\n/* eslint-enable no-control-regex -- safe */\nvar EOF;\n\nvar parseHost = function (url, input) {\n  var result, codePoints, index;\n  if (input.charAt(0) == '[') {\n    if (input.charAt(input.length - 1) != ']') return INVALID_HOST;\n    result = parseIPv6(input.slice(1, -1));\n    if (!result) return INVALID_HOST;\n    url.host = result;\n  // opaque host\n  } else if (!isSpecial(url)) {\n    if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST;\n    result = '';\n    codePoints = arrayFrom(input);\n    for (index = 0; index < codePoints.length; index++) {\n      result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);\n    }\n    url.host = result;\n  } else {\n    input = toASCII(input);\n    if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST;\n    result = parseIPv4(input);\n    if (result === null) return INVALID_HOST;\n    url.host = result;\n  }\n};\n\nvar parseIPv4 = function (input) {\n  var parts = input.split('.');\n  var partsLength, numbers, index, part, radix, number, ipv4;\n  if (parts.length && parts[parts.length - 1] == '') {\n    parts.pop();\n  }\n  partsLength = parts.length;\n  if (partsLength > 4) return input;\n  numbers = [];\n  for (index = 0; index < partsLength; index++) {\n    part = parts[index];\n    if (part == '') return input;\n    radix = 10;\n    if (part.length > 1 && part.charAt(0) == '0') {\n      radix = HEX_START.test(part) ? 16 : 8;\n      part = part.slice(radix == 8 ? 1 : 2);\n    }\n    if (part === '') {\n      number = 0;\n    } else {\n      if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input;\n      number = parseInt(part, radix);\n    }\n    numbers.push(number);\n  }\n  for (index = 0; index < partsLength; index++) {\n    number = numbers[index];\n    if (index == partsLength - 1) {\n      if (number >= pow(256, 5 - partsLength)) return null;\n    } else if (number > 255) return null;\n  }\n  ipv4 = numbers.pop();\n  for (index = 0; index < numbers.length; index++) {\n    ipv4 += numbers[index] * pow(256, 3 - index);\n  }\n  return ipv4;\n};\n\n// eslint-disable-next-line max-statements -- TODO\nvar parseIPv6 = function (input) {\n  var address = [0, 0, 0, 0, 0, 0, 0, 0];\n  var pieceIndex = 0;\n  var compress = null;\n  var pointer = 0;\n  var value, length, numbersSeen, ipv4Piece, number, swaps, swap;\n\n  var char = function () {\n    return input.charAt(pointer);\n  };\n\n  if (char() == ':') {\n    if (input.charAt(1) != ':') return;\n    pointer += 2;\n    pieceIndex++;\n    compress = pieceIndex;\n  }\n  while (char()) {\n    if (pieceIndex == 8) return;\n    if (char() == ':') {\n      if (compress !== null) return;\n      pointer++;\n      pieceIndex++;\n      compress = pieceIndex;\n      continue;\n    }\n    value = length = 0;\n    while (length < 4 && HEX.test(char())) {\n      value = value * 16 + parseInt(char(), 16);\n      pointer++;\n      length++;\n    }\n    if (char() == '.') {\n      if (length == 0) return;\n      pointer -= length;\n      if (pieceIndex > 6) return;\n      numbersSeen = 0;\n      while (char()) {\n        ipv4Piece = null;\n        if (numbersSeen > 0) {\n          if (char() == '.' && numbersSeen < 4) pointer++;\n          else return;\n        }\n        if (!DIGIT.test(char())) return;\n        while (DIGIT.test(char())) {\n          number = parseInt(char(), 10);\n          if (ipv4Piece === null) ipv4Piece = number;\n          else if (ipv4Piece == 0) return;\n          else ipv4Piece = ipv4Piece * 10 + number;\n          if (ipv4Piece > 255) return;\n          pointer++;\n        }\n        address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;\n        numbersSeen++;\n        if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++;\n      }\n      if (numbersSeen != 4) return;\n      break;\n    } else if (char() == ':') {\n      pointer++;\n      if (!char()) return;\n    } else if (char()) return;\n    address[pieceIndex++] = value;\n  }\n  if (compress !== null) {\n    swaps = pieceIndex - compress;\n    pieceIndex = 7;\n    while (pieceIndex != 0 && swaps > 0) {\n      swap = address[pieceIndex];\n      address[pieceIndex--] = address[compress + swaps - 1];\n      address[compress + --swaps] = swap;\n    }\n  } else if (pieceIndex != 8) return;\n  return address;\n};\n\nvar findLongestZeroSequence = function (ipv6) {\n  var maxIndex = null;\n  var maxLength = 1;\n  var currStart = null;\n  var currLength = 0;\n  var index = 0;\n  for (; index < 8; index++) {\n    if (ipv6[index] !== 0) {\n      if (currLength > maxLength) {\n        maxIndex = currStart;\n        maxLength = currLength;\n      }\n      currStart = null;\n      currLength = 0;\n    } else {\n      if (currStart === null) currStart = index;\n      ++currLength;\n    }\n  }\n  if (currLength > maxLength) {\n    maxIndex = currStart;\n    maxLength = currLength;\n  }\n  return maxIndex;\n};\n\nvar serializeHost = function (host) {\n  var result, index, compress, ignore0;\n  // ipv4\n  if (typeof host == 'number') {\n    result = [];\n    for (index = 0; index < 4; index++) {\n      result.unshift(host % 256);\n      host = floor(host / 256);\n    } return result.join('.');\n  // ipv6\n  } else if (typeof host == 'object') {\n    result = '';\n    compress = findLongestZeroSequence(host);\n    for (index = 0; index < 8; index++) {\n      if (ignore0 && host[index] === 0) continue;\n      if (ignore0) ignore0 = false;\n      if (compress === index) {\n        result += index ? ':' : '::';\n        ignore0 = true;\n      } else {\n        result += host[index].toString(16);\n        if (index < 7) result += ':';\n      }\n    }\n    return '[' + result + ']';\n  } return host;\n};\n\nvar C0ControlPercentEncodeSet = {};\nvar fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {\n  ' ': 1, '\"': 1, '<': 1, '>': 1, '`': 1\n});\nvar pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {\n  '#': 1, '?': 1, '{': 1, '}': 1\n});\nvar userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {\n  '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\\\': 1, ']': 1, '^': 1, '|': 1\n});\n\nvar percentEncode = function (char, set) {\n  var code = codeAt(char, 0);\n  return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);\n};\n\nvar specialSchemes = {\n  ftp: 21,\n  file: null,\n  http: 80,\n  https: 443,\n  ws: 80,\n  wss: 443\n};\n\nvar isSpecial = function (url) {\n  return has(specialSchemes, url.scheme);\n};\n\nvar includesCredentials = function (url) {\n  return url.username != '' || url.password != '';\n};\n\nvar cannotHaveUsernamePasswordPort = function (url) {\n  return !url.host || url.cannotBeABaseURL || url.scheme == 'file';\n};\n\nvar isWindowsDriveLetter = function (string, normalized) {\n  var second;\n  return string.length == 2 && ALPHA.test(string.charAt(0))\n    && ((second = string.charAt(1)) == ':' || (!normalized && second == '|'));\n};\n\nvar startsWithWindowsDriveLetter = function (string) {\n  var third;\n  return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (\n    string.length == 2 ||\n    ((third = string.charAt(2)) === '/' || third === '\\\\' || third === '?' || third === '#')\n  );\n};\n\nvar shortenURLsPath = function (url) {\n  var path = url.path;\n  var pathSize = path.length;\n  if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {\n    path.pop();\n  }\n};\n\nvar isSingleDot = function (segment) {\n  return segment === '.' || segment.toLowerCase() === '%2e';\n};\n\nvar isDoubleDot = function (segment) {\n  segment = segment.toLowerCase();\n  return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';\n};\n\n// States:\nvar SCHEME_START = {};\nvar SCHEME = {};\nvar NO_SCHEME = {};\nvar SPECIAL_RELATIVE_OR_AUTHORITY = {};\nvar PATH_OR_AUTHORITY = {};\nvar RELATIVE = {};\nvar RELATIVE_SLASH = {};\nvar SPECIAL_AUTHORITY_SLASHES = {};\nvar SPECIAL_AUTHORITY_IGNORE_SLASHES = {};\nvar AUTHORITY = {};\nvar HOST = {};\nvar HOSTNAME = {};\nvar PORT = {};\nvar FILE = {};\nvar FILE_SLASH = {};\nvar FILE_HOST = {};\nvar PATH_START = {};\nvar PATH = {};\nvar CANNOT_BE_A_BASE_URL_PATH = {};\nvar QUERY = {};\nvar FRAGMENT = {};\n\n// eslint-disable-next-line max-statements -- TODO\nvar parseURL = function (url, input, stateOverride, base) {\n  var state = stateOverride || SCHEME_START;\n  var pointer = 0;\n  var buffer = '';\n  var seenAt = false;\n  var seenBracket = false;\n  var seenPasswordToken = false;\n  var codePoints, char, bufferCodePoints, failure;\n\n  if (!stateOverride) {\n    url.scheme = '';\n    url.username = '';\n    url.password = '';\n    url.host = null;\n    url.port = null;\n    url.path = [];\n    url.query = null;\n    url.fragment = null;\n    url.cannotBeABaseURL = false;\n    input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');\n  }\n\n  input = input.replace(TAB_AND_NEW_LINE, '');\n\n  codePoints = arrayFrom(input);\n\n  while (pointer <= codePoints.length) {\n    char = codePoints[pointer];\n    switch (state) {\n      case SCHEME_START:\n        if (char && ALPHA.test(char)) {\n          buffer += char.toLowerCase();\n          state = SCHEME;\n        } else if (!stateOverride) {\n          state = NO_SCHEME;\n          continue;\n        } else return INVALID_SCHEME;\n        break;\n\n      case SCHEME:\n        if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) {\n          buffer += char.toLowerCase();\n        } else if (char == ':') {\n          if (stateOverride && (\n            (isSpecial(url) != has(specialSchemes, buffer)) ||\n            (buffer == 'file' && (includesCredentials(url) || url.port !== null)) ||\n            (url.scheme == 'file' && !url.host)\n          )) return;\n          url.scheme = buffer;\n          if (stateOverride) {\n            if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null;\n            return;\n          }\n          buffer = '';\n          if (url.scheme == 'file') {\n            state = FILE;\n          } else if (isSpecial(url) && base && base.scheme == url.scheme) {\n            state = SPECIAL_RELATIVE_OR_AUTHORITY;\n          } else if (isSpecial(url)) {\n            state = SPECIAL_AUTHORITY_SLASHES;\n          } else if (codePoints[pointer + 1] == '/') {\n            state = PATH_OR_AUTHORITY;\n            pointer++;\n          } else {\n            url.cannotBeABaseURL = true;\n            url.path.push('');\n            state = CANNOT_BE_A_BASE_URL_PATH;\n          }\n        } else if (!stateOverride) {\n          buffer = '';\n          state = NO_SCHEME;\n          pointer = 0;\n          continue;\n        } else return INVALID_SCHEME;\n        break;\n\n      case NO_SCHEME:\n        if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME;\n        if (base.cannotBeABaseURL && char == '#') {\n          url.scheme = base.scheme;\n          url.path = base.path.slice();\n          url.query = base.query;\n          url.fragment = '';\n          url.cannotBeABaseURL = true;\n          state = FRAGMENT;\n          break;\n        }\n        state = base.scheme == 'file' ? FILE : RELATIVE;\n        continue;\n\n      case SPECIAL_RELATIVE_OR_AUTHORITY:\n        if (char == '/' && codePoints[pointer + 1] == '/') {\n          state = SPECIAL_AUTHORITY_IGNORE_SLASHES;\n          pointer++;\n        } else {\n          state = RELATIVE;\n          continue;\n        } break;\n\n      case PATH_OR_AUTHORITY:\n        if (char == '/') {\n          state = AUTHORITY;\n          break;\n        } else {\n          state = PATH;\n          continue;\n        }\n\n      case RELATIVE:\n        url.scheme = base.scheme;\n        if (char == EOF) {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.query = base.query;\n        } else if (char == '/' || (char == '\\\\' && isSpecial(url))) {\n          state = RELATIVE_SLASH;\n        } else if (char == '?') {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.query = '';\n          state = QUERY;\n        } else if (char == '#') {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.query = base.query;\n          url.fragment = '';\n          state = FRAGMENT;\n        } else {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.path.pop();\n          state = PATH;\n          continue;\n        } break;\n\n      case RELATIVE_SLASH:\n        if (isSpecial(url) && (char == '/' || char == '\\\\')) {\n          state = SPECIAL_AUTHORITY_IGNORE_SLASHES;\n        } else if (char == '/') {\n          state = AUTHORITY;\n        } else {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          state = PATH;\n          continue;\n        } break;\n\n      case SPECIAL_AUTHORITY_SLASHES:\n        state = SPECIAL_AUTHORITY_IGNORE_SLASHES;\n        if (char != '/' || buffer.charAt(pointer + 1) != '/') continue;\n        pointer++;\n        break;\n\n      case SPECIAL_AUTHORITY_IGNORE_SLASHES:\n        if (char != '/' && char != '\\\\') {\n          state = AUTHORITY;\n          continue;\n        } break;\n\n      case AUTHORITY:\n        if (char == '@') {\n          if (seenAt) buffer = '%40' + buffer;\n          seenAt = true;\n          bufferCodePoints = arrayFrom(buffer);\n          for (var i = 0; i < bufferCodePoints.length; i++) {\n            var codePoint = bufferCodePoints[i];\n            if (codePoint == ':' && !seenPasswordToken) {\n              seenPasswordToken = true;\n              continue;\n            }\n            var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);\n            if (seenPasswordToken) url.password += encodedCodePoints;\n            else url.username += encodedCodePoints;\n          }\n          buffer = '';\n        } else if (\n          char == EOF || char == '/' || char == '?' || char == '#' ||\n          (char == '\\\\' && isSpecial(url))\n        ) {\n          if (seenAt && buffer == '') return INVALID_AUTHORITY;\n          pointer -= arrayFrom(buffer).length + 1;\n          buffer = '';\n          state = HOST;\n        } else buffer += char;\n        break;\n\n      case HOST:\n      case HOSTNAME:\n        if (stateOverride && url.scheme == 'file') {\n          state = FILE_HOST;\n          continue;\n        } else if (char == ':' && !seenBracket) {\n          if (buffer == '') return INVALID_HOST;\n          failure = parseHost(url, buffer);\n          if (failure) return failure;\n          buffer = '';\n          state = PORT;\n          if (stateOverride == HOSTNAME) return;\n        } else if (\n          char == EOF || char == '/' || char == '?' || char == '#' ||\n          (char == '\\\\' && isSpecial(url))\n        ) {\n          if (isSpecial(url) && buffer == '') return INVALID_HOST;\n          if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return;\n          failure = parseHost(url, buffer);\n          if (failure) return failure;\n          buffer = '';\n          state = PATH_START;\n          if (stateOverride) return;\n          continue;\n        } else {\n          if (char == '[') seenBracket = true;\n          else if (char == ']') seenBracket = false;\n          buffer += char;\n        } break;\n\n      case PORT:\n        if (DIGIT.test(char)) {\n          buffer += char;\n        } else if (\n          char == EOF || char == '/' || char == '?' || char == '#' ||\n          (char == '\\\\' && isSpecial(url)) ||\n          stateOverride\n        ) {\n          if (buffer != '') {\n            var port = parseInt(buffer, 10);\n            if (port > 0xFFFF) return INVALID_PORT;\n            url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port;\n            buffer = '';\n          }\n          if (stateOverride) return;\n          state = PATH_START;\n          continue;\n        } else return INVALID_PORT;\n        break;\n\n      case FILE:\n        url.scheme = 'file';\n        if (char == '/' || char == '\\\\') state = FILE_SLASH;\n        else if (base && base.scheme == 'file') {\n          if (char == EOF) {\n            url.host = base.host;\n            url.path = base.path.slice();\n            url.query = base.query;\n          } else if (char == '?') {\n            url.host = base.host;\n            url.path = base.path.slice();\n            url.query = '';\n            state = QUERY;\n          } else if (char == '#') {\n            url.host = base.host;\n            url.path = base.path.slice();\n            url.query = base.query;\n            url.fragment = '';\n            state = FRAGMENT;\n          } else {\n            if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {\n              url.host = base.host;\n              url.path = base.path.slice();\n              shortenURLsPath(url);\n            }\n            state = PATH;\n            continue;\n          }\n        } else {\n          state = PATH;\n          continue;\n        } break;\n\n      case FILE_SLASH:\n        if (char == '/' || char == '\\\\') {\n          state = FILE_HOST;\n          break;\n        }\n        if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {\n          if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]);\n          else url.host = base.host;\n        }\n        state = PATH;\n        continue;\n\n      case FILE_HOST:\n        if (char == EOF || char == '/' || char == '\\\\' || char == '?' || char == '#') {\n          if (!stateOverride && isWindowsDriveLetter(buffer)) {\n            state = PATH;\n          } else if (buffer == '') {\n            url.host = '';\n            if (stateOverride) return;\n            state = PATH_START;\n          } else {\n            failure = parseHost(url, buffer);\n            if (failure) return failure;\n            if (url.host == 'localhost') url.host = '';\n            if (stateOverride) return;\n            buffer = '';\n            state = PATH_START;\n          } continue;\n        } else buffer += char;\n        break;\n\n      case PATH_START:\n        if (isSpecial(url)) {\n          state = PATH;\n          if (char != '/' && char != '\\\\') continue;\n        } else if (!stateOverride && char == '?') {\n          url.query = '';\n          state = QUERY;\n        } else if (!stateOverride && char == '#') {\n          url.fragment = '';\n          state = FRAGMENT;\n        } else if (char != EOF) {\n          state = PATH;\n          if (char != '/') continue;\n        } break;\n\n      case PATH:\n        if (\n          char == EOF || char == '/' ||\n          (char == '\\\\' && isSpecial(url)) ||\n          (!stateOverride && (char == '?' || char == '#'))\n        ) {\n          if (isDoubleDot(buffer)) {\n            shortenURLsPath(url);\n            if (char != '/' && !(char == '\\\\' && isSpecial(url))) {\n              url.path.push('');\n            }\n          } else if (isSingleDot(buffer)) {\n            if (char != '/' && !(char == '\\\\' && isSpecial(url))) {\n              url.path.push('');\n            }\n          } else {\n            if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {\n              if (url.host) url.host = '';\n              buffer = buffer.charAt(0) + ':'; // normalize windows drive letter\n            }\n            url.path.push(buffer);\n          }\n          buffer = '';\n          if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) {\n            while (url.path.length > 1 && url.path[0] === '') {\n              url.path.shift();\n            }\n          }\n          if (char == '?') {\n            url.query = '';\n            state = QUERY;\n          } else if (char == '#') {\n            url.fragment = '';\n            state = FRAGMENT;\n          }\n        } else {\n          buffer += percentEncode(char, pathPercentEncodeSet);\n        } break;\n\n      case CANNOT_BE_A_BASE_URL_PATH:\n        if (char == '?') {\n          url.query = '';\n          state = QUERY;\n        } else if (char == '#') {\n          url.fragment = '';\n          state = FRAGMENT;\n        } else if (char != EOF) {\n          url.path[0] += percentEncode(char, C0ControlPercentEncodeSet);\n        } break;\n\n      case QUERY:\n        if (!stateOverride && char == '#') {\n          url.fragment = '';\n          state = FRAGMENT;\n        } else if (char != EOF) {\n          if (char == \"'\" && isSpecial(url)) url.query += '%27';\n          else if (char == '#') url.query += '%23';\n          else url.query += percentEncode(char, C0ControlPercentEncodeSet);\n        } break;\n\n      case FRAGMENT:\n        if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet);\n        break;\n    }\n\n    pointer++;\n  }\n};\n\n// `URL` constructor\n// https://url.spec.whatwg.org/#url-class\nvar URLConstructor = function URL(url /* , base */) {\n  var that = anInstance(this, URLConstructor, 'URL');\n  var base = arguments.length > 1 ? arguments[1] : undefined;\n  var urlString = String(url);\n  var state = setInternalState(that, { type: 'URL' });\n  var baseState, failure;\n  if (base !== undefined) {\n    if (base instanceof URLConstructor) baseState = getInternalURLState(base);\n    else {\n      failure = parseURL(baseState = {}, String(base));\n      if (failure) throw TypeError(failure);\n    }\n  }\n  failure = parseURL(state, urlString, null, baseState);\n  if (failure) throw TypeError(failure);\n  var searchParams = state.searchParams = new URLSearchParams();\n  var searchParamsState = getInternalSearchParamsState(searchParams);\n  searchParamsState.updateSearchParams(state.query);\n  searchParamsState.updateURL = function () {\n    state.query = String(searchParams) || null;\n  };\n  if (!DESCRIPTORS) {\n    that.href = serializeURL.call(that);\n    that.origin = getOrigin.call(that);\n    that.protocol = getProtocol.call(that);\n    that.username = getUsername.call(that);\n    that.password = getPassword.call(that);\n    that.host = getHost.call(that);\n    that.hostname = getHostname.call(that);\n    that.port = getPort.call(that);\n    that.pathname = getPathname.call(that);\n    that.search = getSearch.call(that);\n    that.searchParams = getSearchParams.call(that);\n    that.hash = getHash.call(that);\n  }\n};\n\nvar URLPrototype = URLConstructor.prototype;\n\nvar serializeURL = function () {\n  var url = getInternalURLState(this);\n  var scheme = url.scheme;\n  var username = url.username;\n  var password = url.password;\n  var host = url.host;\n  var port = url.port;\n  var path = url.path;\n  var query = url.query;\n  var fragment = url.fragment;\n  var output = scheme + ':';\n  if (host !== null) {\n    output += '//';\n    if (includesCredentials(url)) {\n      output += username + (password ? ':' + password : '') + '@';\n    }\n    output += serializeHost(host);\n    if (port !== null) output += ':' + port;\n  } else if (scheme == 'file') output += '//';\n  output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';\n  if (query !== null) output += '?' + query;\n  if (fragment !== null) output += '#' + fragment;\n  return output;\n};\n\nvar getOrigin = function () {\n  var url = getInternalURLState(this);\n  var scheme = url.scheme;\n  var port = url.port;\n  if (scheme == 'blob') try {\n    return new URLConstructor(scheme.path[0]).origin;\n  } catch (error) {\n    return 'null';\n  }\n  if (scheme == 'file' || !isSpecial(url)) return 'null';\n  return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : '');\n};\n\nvar getProtocol = function () {\n  return getInternalURLState(this).scheme + ':';\n};\n\nvar getUsername = function () {\n  return getInternalURLState(this).username;\n};\n\nvar getPassword = function () {\n  return getInternalURLState(this).password;\n};\n\nvar getHost = function () {\n  var url = getInternalURLState(this);\n  var host = url.host;\n  var port = url.port;\n  return host === null ? ''\n    : port === null ? serializeHost(host)\n    : serializeHost(host) + ':' + port;\n};\n\nvar getHostname = function () {\n  var host = getInternalURLState(this).host;\n  return host === null ? '' : serializeHost(host);\n};\n\nvar getPort = function () {\n  var port = getInternalURLState(this).port;\n  return port === null ? '' : String(port);\n};\n\nvar getPathname = function () {\n  var url = getInternalURLState(this);\n  var path = url.path;\n  return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';\n};\n\nvar getSearch = function () {\n  var query = getInternalURLState(this).query;\n  return query ? '?' + query : '';\n};\n\nvar getSearchParams = function () {\n  return getInternalURLState(this).searchParams;\n};\n\nvar getHash = function () {\n  var fragment = getInternalURLState(this).fragment;\n  return fragment ? '#' + fragment : '';\n};\n\nvar accessorDescriptor = function (getter, setter) {\n  return { get: getter, set: setter, configurable: true, enumerable: true };\n};\n\nif (DESCRIPTORS) {\n  defineProperties(URLPrototype, {\n    // `URL.prototype.href` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-href\n    href: accessorDescriptor(serializeURL, function (href) {\n      var url = getInternalURLState(this);\n      var urlString = String(href);\n      var failure = parseURL(url, urlString);\n      if (failure) throw TypeError(failure);\n      getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);\n    }),\n    // `URL.prototype.origin` getter\n    // https://url.spec.whatwg.org/#dom-url-origin\n    origin: accessorDescriptor(getOrigin),\n    // `URL.prototype.protocol` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-protocol\n    protocol: accessorDescriptor(getProtocol, function (protocol) {\n      var url = getInternalURLState(this);\n      parseURL(url, String(protocol) + ':', SCHEME_START);\n    }),\n    // `URL.prototype.username` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-username\n    username: accessorDescriptor(getUsername, function (username) {\n      var url = getInternalURLState(this);\n      var codePoints = arrayFrom(String(username));\n      if (cannotHaveUsernamePasswordPort(url)) return;\n      url.username = '';\n      for (var i = 0; i < codePoints.length; i++) {\n        url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);\n      }\n    }),\n    // `URL.prototype.password` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-password\n    password: accessorDescriptor(getPassword, function (password) {\n      var url = getInternalURLState(this);\n      var codePoints = arrayFrom(String(password));\n      if (cannotHaveUsernamePasswordPort(url)) return;\n      url.password = '';\n      for (var i = 0; i < codePoints.length; i++) {\n        url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);\n      }\n    }),\n    // `URL.prototype.host` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-host\n    host: accessorDescriptor(getHost, function (host) {\n      var url = getInternalURLState(this);\n      if (url.cannotBeABaseURL) return;\n      parseURL(url, String(host), HOST);\n    }),\n    // `URL.prototype.hostname` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-hostname\n    hostname: accessorDescriptor(getHostname, function (hostname) {\n      var url = getInternalURLState(this);\n      if (url.cannotBeABaseURL) return;\n      parseURL(url, String(hostname), HOSTNAME);\n    }),\n    // `URL.prototype.port` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-port\n    port: accessorDescriptor(getPort, function (port) {\n      var url = getInternalURLState(this);\n      if (cannotHaveUsernamePasswordPort(url)) return;\n      port = String(port);\n      if (port == '') url.port = null;\n      else parseURL(url, port, PORT);\n    }),\n    // `URL.prototype.pathname` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-pathname\n    pathname: accessorDescriptor(getPathname, function (pathname) {\n      var url = getInternalURLState(this);\n      if (url.cannotBeABaseURL) return;\n      url.path = [];\n      parseURL(url, pathname + '', PATH_START);\n    }),\n    // `URL.prototype.search` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-search\n    search: accessorDescriptor(getSearch, function (search) {\n      var url = getInternalURLState(this);\n      search = String(search);\n      if (search == '') {\n        url.query = null;\n      } else {\n        if ('?' == search.charAt(0)) search = search.slice(1);\n        url.query = '';\n        parseURL(url, search, QUERY);\n      }\n      getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);\n    }),\n    // `URL.prototype.searchParams` getter\n    // https://url.spec.whatwg.org/#dom-url-searchparams\n    searchParams: accessorDescriptor(getSearchParams),\n    // `URL.prototype.hash` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-hash\n    hash: accessorDescriptor(getHash, function (hash) {\n      var url = getInternalURLState(this);\n      hash = String(hash);\n      if (hash == '') {\n        url.fragment = null;\n        return;\n      }\n      if ('#' == hash.charAt(0)) hash = hash.slice(1);\n      url.fragment = '';\n      parseURL(url, hash, FRAGMENT);\n    })\n  });\n}\n\n// `URL.prototype.toJSON` method\n// https://url.spec.whatwg.org/#dom-url-tojson\nredefine(URLPrototype, 'toJSON', function toJSON() {\n  return serializeURL.call(this);\n}, { enumerable: true });\n\n// `URL.prototype.toString` method\n// https://url.spec.whatwg.org/#URL-stringification-behavior\nredefine(URLPrototype, 'toString', function toString() {\n  return serializeURL.call(this);\n}, { enumerable: true });\n\nif (NativeURL) {\n  var nativeCreateObjectURL = NativeURL.createObjectURL;\n  var nativeRevokeObjectURL = NativeURL.revokeObjectURL;\n  // `URL.createObjectURL` method\n  // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) {\n    return nativeCreateObjectURL.apply(NativeURL, arguments);\n  });\n  // `URL.revokeObjectURL` method\n  // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) {\n    return nativeRevokeObjectURL.apply(NativeURL, arguments);\n  });\n}\n\nsetToStringTag(URLConstructor, 'URL');\n\n$({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, {\n  URL: URLConstructor\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}","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar versions = process && process.versions;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  version = match[0] < 4 ? 1 : match[0] + match[1];\n} else if (userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = match[1];\n  }\n}\n\nmodule.exports = version && +version;\n","import invariant from \"invariant\";\n\n////////////////////////////////////////////////////////////////////////////////\n// startsWith(string, search) - Check if `string` starts with `search`\nvar startsWith = function startsWith(string, search) {\n  return string.substr(0, search.length) === search;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// pick(routes, uri)\n//\n// Ranks and picks the best route to match. Each segment gets the highest\n// amount of points, then the type of segment gets an additional amount of\n// points where\n//\n//     static > dynamic > splat > root\n//\n// This way we don't have to worry about the order of our routes, let the\n// computers do it.\n//\n// A route looks like this\n//\n//     { path, default, value }\n//\n// And a returned match looks like:\n//\n//     { route, params, uri }\n//\n// I know, I should use TypeScript not comments for these types.\nvar pick = function pick(routes, uri) {\n  var match = void 0;\n  var default_ = void 0;\n\n  var _uri$split = uri.split(\"?\"),\n      uriPathname = _uri$split[0];\n\n  var uriSegments = segmentize(uriPathname);\n  var isRootUri = uriSegments[0] === \"\";\n  var ranked = rankRoutes(routes);\n\n  for (var i = 0, l = ranked.length; i < l; i++) {\n    var missed = false;\n    var route = ranked[i].route;\n\n    if (route.default) {\n      default_ = {\n        route: route,\n        params: {},\n        uri: uri\n      };\n      continue;\n    }\n\n    var routeSegments = segmentize(route.path);\n    var params = {};\n    var max = Math.max(uriSegments.length, routeSegments.length);\n    var index = 0;\n\n    for (; index < max; index++) {\n      var routeSegment = routeSegments[index];\n      var uriSegment = uriSegments[index];\n\n      if (isSplat(routeSegment)) {\n        // Hit a splat, just grab the rest, and return a match\n        // uri:   /files/documents/work\n        // route: /files/*\n        var param = routeSegment.slice(1) || \"*\";\n        params[param] = uriSegments.slice(index).map(decodeURIComponent).join(\"/\");\n        break;\n      }\n\n      if (uriSegment === undefined) {\n        // URI is shorter than the route, no match\n        // uri:   /users\n        // route: /users/:userId\n        missed = true;\n        break;\n      }\n\n      var dynamicMatch = paramRe.exec(routeSegment);\n\n      if (dynamicMatch && !isRootUri) {\n        var matchIsNotReserved = reservedNames.indexOf(dynamicMatch[1]) === -1;\n        !matchIsNotReserved ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Router> dynamic segment \\\"\" + dynamicMatch[1] + \"\\\" is a reserved name. Please use a different name in path \\\"\" + route.path + \"\\\".\") : invariant(false) : void 0;\n        var value = decodeURIComponent(uriSegment);\n        params[dynamicMatch[1]] = value;\n      } else if (routeSegment !== uriSegment) {\n        // Current segments don't match, not dynamic, not splat, so no match\n        // uri:   /users/123/settings\n        // route: /users/:id/profile\n        missed = true;\n        break;\n      }\n    }\n\n    if (!missed) {\n      match = {\n        route: route,\n        params: params,\n        uri: \"/\" + uriSegments.slice(0, index).join(\"/\")\n      };\n      break;\n    }\n  }\n\n  return match || default_ || null;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// match(path, uri) - Matches just one path to a uri, also lol\nvar match = function match(path, uri) {\n  return pick([{ path: path }], uri);\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// resolve(to, basepath)\n//\n// Resolves URIs as though every path is a directory, no files.  Relative URIs\n// in the browser can feel awkward because not only can you be \"in a directory\"\n// you can be \"at a file\", too. For example\n//\n//     browserSpecResolve('foo', '/bar/') => /bar/foo\n//     browserSpecResolve('foo', '/bar') => /foo\n//\n// But on the command line of a file system, it's not as complicated, you can't\n// `cd` from a file, only directories.  This way, links have to know less about\n// their current path. To go deeper you can do this:\n//\n//     <Link to=\"deeper\"/>\n//     // instead of\n//     <Link to=`{${props.uri}/deeper}`/>\n//\n// Just like `cd`, if you want to go deeper from the command line, you do this:\n//\n//     cd deeper\n//     # not\n//     cd $(pwd)/deeper\n//\n// By treating every path as a directory, linking to relative paths should\n// require less contextual information and (fingers crossed) be more intuitive.\nvar resolve = function resolve(to, base) {\n  // /foo/bar, /baz/qux => /foo/bar\n  if (startsWith(to, \"/\")) {\n    return to;\n  }\n\n  var _to$split = to.split(\"?\"),\n      toPathname = _to$split[0],\n      toQuery = _to$split[1];\n\n  var _base$split = base.split(\"?\"),\n      basePathname = _base$split[0];\n\n  var toSegments = segmentize(toPathname);\n  var baseSegments = segmentize(basePathname);\n\n  // ?a=b, /users?b=c => /users?a=b\n  if (toSegments[0] === \"\") {\n    return addQuery(basePathname, toQuery);\n  }\n\n  // profile, /users/789 => /users/789/profile\n  if (!startsWith(toSegments[0], \".\")) {\n    var pathname = baseSegments.concat(toSegments).join(\"/\");\n    return addQuery((basePathname === \"/\" ? \"\" : \"/\") + pathname, toQuery);\n  }\n\n  // ./         /users/123  =>  /users/123\n  // ../        /users/123  =>  /users\n  // ../..      /users/123  =>  /\n  // ../../one  /a/b/c/d    =>  /a/b/one\n  // .././one   /a/b/c/d    =>  /a/b/c/one\n  var allSegments = baseSegments.concat(toSegments);\n  var segments = [];\n  for (var i = 0, l = allSegments.length; i < l; i++) {\n    var segment = allSegments[i];\n    if (segment === \"..\") segments.pop();else if (segment !== \".\") segments.push(segment);\n  }\n\n  return addQuery(\"/\" + segments.join(\"/\"), toQuery);\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// insertParams(path, params)\n\nvar insertParams = function insertParams(path, params) {\n  var _path$split = path.split(\"?\"),\n      pathBase = _path$split[0],\n      _path$split$ = _path$split[1],\n      query = _path$split$ === undefined ? \"\" : _path$split$;\n\n  var segments = segmentize(pathBase);\n  var constructedPath = \"/\" + segments.map(function (segment) {\n    var match = paramRe.exec(segment);\n    return match ? params[match[1]] : segment;\n  }).join(\"/\");\n  var _params$location = params.location;\n  _params$location = _params$location === undefined ? {} : _params$location;\n  var _params$location$sear = _params$location.search,\n      search = _params$location$sear === undefined ? \"\" : _params$location$sear;\n\n  var searchSplit = search.split(\"?\")[1] || \"\";\n  constructedPath = addQuery(constructedPath, query, searchSplit);\n  return constructedPath;\n};\n\nvar validateRedirect = function validateRedirect(from, to) {\n  var filter = function filter(segment) {\n    return isDynamic(segment);\n  };\n  var fromString = segmentize(from).filter(filter).sort().join(\"/\");\n  var toString = segmentize(to).filter(filter).sort().join(\"/\");\n  return fromString === toString;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Junk\nvar paramRe = /^:(.+)/;\n\nvar SEGMENT_POINTS = 4;\nvar STATIC_POINTS = 3;\nvar DYNAMIC_POINTS = 2;\nvar SPLAT_PENALTY = 1;\nvar ROOT_POINTS = 1;\n\nvar isRootSegment = function isRootSegment(segment) {\n  return segment === \"\";\n};\nvar isDynamic = function isDynamic(segment) {\n  return paramRe.test(segment);\n};\nvar isSplat = function isSplat(segment) {\n  return segment && segment[0] === \"*\";\n};\n\nvar rankRoute = function rankRoute(route, index) {\n  var score = route.default ? 0 : segmentize(route.path).reduce(function (score, segment) {\n    score += SEGMENT_POINTS;\n    if (isRootSegment(segment)) score += ROOT_POINTS;else if (isDynamic(segment)) score += DYNAMIC_POINTS;else if (isSplat(segment)) score -= SEGMENT_POINTS + SPLAT_PENALTY;else score += STATIC_POINTS;\n    return score;\n  }, 0);\n  return { route: route, score: score, index: index };\n};\n\nvar rankRoutes = function rankRoutes(routes) {\n  return routes.map(rankRoute).sort(function (a, b) {\n    return a.score < b.score ? 1 : a.score > b.score ? -1 : a.index - b.index;\n  });\n};\n\nvar segmentize = function segmentize(uri) {\n  return uri\n  // strip starting/ending slashes\n  .replace(/(^\\/+|\\/+$)/g, \"\").split(\"/\");\n};\n\nvar addQuery = function addQuery(pathname) {\n  for (var _len = arguments.length, query = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    query[_key - 1] = arguments[_key];\n  }\n\n  query = query.filter(function (q) {\n    return q && q.length > 0;\n  });\n  return pathname + (query && query.length > 0 ? \"?\" + query.join(\"&\") : \"\");\n};\n\nvar reservedNames = [\"uri\", \"path\"];\n\n/**\n * Shallow compares two objects.\n * @param {Object} obj1 The first object to compare.\n * @param {Object} obj2 The second object to compare.\n */\nvar shallowCompare = function shallowCompare(obj1, obj2) {\n  var obj1Keys = Object.keys(obj1);\n  return obj1Keys.length === Object.keys(obj2).length && obj1Keys.every(function (key) {\n    return obj2.hasOwnProperty(key) && obj1[key] === obj2[key];\n  });\n};\n\n////////////////////////////////////////////////////////////////////////////////\nexport { startsWith, pick, match, resolve, insertParams, validateRedirect, shallowCompare };","module.exports = [{\n      plugin: require('../node_modules/gatsby-plugin-google-tagmanager/gatsby-browser.js'),\n      options: {\"plugins\":[],\"id\":\"GTM-KL8N6WZ\",\"includeInDevelopment\":false,\"defaultDataLayer\":null,\"routeChangeEventName\":\"gatsby-route-change\"},\n    },{\n      plugin: require('../gatsby-browser.js'),\n      options: {\"plugins\":[]},\n    }]\n","export default function _complement(f) {\n  return function () {\n    return !f.apply(this, arguments);\n  };\n}","/*!\n * domready (c) Dustin Diaz 2014 - License MIT\n * ie10 fix - Mikael Kristiansson 2019\n */\n!(function(name, definition) {\n  if (typeof module != \"undefined\") module.exports = definition();\n  else if (typeof define == \"function\" && typeof define.amd == \"object\")\n    define(definition);\n  else this[name] = definition();\n})(\"domready\", function() {\n  var ie10 = false;\n  if (navigator.appVersion.indexOf(\"MSIE 10\") !== -1) {\n    ie10 = true;\n  }\n\n  var fns = [],\n    listener,\n    doc = typeof document === \"object\" && document,\n    hack = ie10\n      ? doc.documentElement.doScroll(\"left\")\n      : doc.documentElement.doScroll,\n    domContentLoaded = \"DOMContentLoaded\",\n    loaded =\n      doc && (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState);\n\n  if (!loaded && doc)\n    doc.addEventListener(\n      domContentLoaded,\n      (listener = function() {\n        doc.removeEventListener(domContentLoaded, listener);\n        loaded = 1;\n        while ((listener = fns.shift())) listener();\n      })\n    );\n\n  return function(fn) {\n    loaded ? setTimeout(fn, 0) : fns.push(fn);\n  };\n});\n","import _curry3 from \"./internal/_curry3.js\";\nimport _has from \"./internal/_has.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\nimport assoc from \"./assoc.js\";\nimport isNil from \"./isNil.js\";\n/**\n * Makes a shallow clone of an object, setting or overriding the nodes required\n * to create the given path, and placing the specific value at the tail end of\n * that path. Note that this copies and flattens prototype properties onto the\n * new object as well. All non-primitive properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> a -> {a} -> {a}\n * @param {Array} path the path to set\n * @param {*} val The new value\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original except along the specified path.\n * @see R.dissocPath\n * @example\n *\n *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n *\n *      // Any missing or non-object keys in path will be overridden\n *      R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}\n */\n\nvar assocPath = /*#__PURE__*/_curry3(function assocPath(path, val, obj) {\n  if (path.length === 0) {\n    return val;\n  }\n\n  var idx = path[0];\n\n  if (path.length > 1) {\n    var nextObj = !isNil(obj) && _has(idx, obj) ? obj[idx] : _isInteger(path[1]) ? [] : {};\n    val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);\n  }\n\n  if (_isInteger(idx) && _isArray(obj)) {\n    var arr = [].concat(obj);\n    arr[idx] = val;\n    return arr;\n  } else {\n    return assoc(idx, val, obj);\n  }\n});\n\nexport default assocPath;","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);\n  return O;\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","import { apiRunner } from \"./api-runner-browser\"\n\nif (\n  window.location.protocol !== `https:` &&\n  window.location.hostname !== `localhost`\n) {\n  console.error(\n    `Service workers can only be used over HTTPS, or on localhost for development`\n  )\n} else if (`serviceWorker` in navigator) {\n  navigator.serviceWorker\n    .register(`${__BASE_PATH__}/sw.js`)\n    .then(function (reg) {\n      reg.addEventListener(`updatefound`, () => {\n        apiRunner(`onServiceWorkerUpdateFound`, { serviceWorker: reg })\n        // The updatefound event implies that reg.installing is set; see\n        // https://w3c.github.io/ServiceWorker/#service-worker-registration-updatefound-event\n        const installingWorker = reg.installing\n        console.log(`installingWorker`, installingWorker)\n        installingWorker.addEventListener(`statechange`, () => {\n          switch (installingWorker.state) {\n            case `installed`:\n              if (navigator.serviceWorker.controller) {\n                // At this point, the old content will have been purged and the fresh content will\n                // have been added to the cache.\n\n                // We set a flag so Gatsby Link knows to refresh the page on next navigation attempt\n                window.___swUpdated = true\n                // We call the onServiceWorkerUpdateReady API so users can show update prompts.\n                apiRunner(`onServiceWorkerUpdateReady`, { serviceWorker: reg })\n\n                // If resources failed for the current page, reload.\n                if (window.___failedResources) {\n                  console.log(`resources failed, SW updated - reloading`)\n                  window.location.reload()\n                }\n              } else {\n                // At this point, everything has been precached.\n                // It's the perfect time to display a \"Content is cached for offline use.\" message.\n                console.log(`Content is now available offline!`)\n\n                // Post to service worker that install is complete.\n                // Delay to allow time for the event listener to be added --\n                // otherwise fetch is called too soon and resources aren't cached.\n                apiRunner(`onServiceWorkerInstalled`, { serviceWorker: reg })\n              }\n              break\n\n            case `redundant`:\n              console.error(`The installing service worker became redundant.`)\n              apiRunner(`onServiceWorkerRedundant`, { serviceWorker: reg })\n              break\n\n            case `activated`:\n              apiRunner(`onServiceWorkerActive`, { serviceWorker: reg })\n              break\n          }\n        })\n      })\n    })\n    .catch(function (e) {\n      console.error(`Error during service worker registration:`, e)\n    })\n}\n","var classof = require('../internals/classof');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n  if (it != undefined) return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n","// prefer default export if available\nconst preferDefault = m => (m && m.default) || m\n\nexports.components = {\n  \"component---src-pages-404-jsx\": () => import(\"./../../../src/pages/404.jsx\" /* webpackChunkName: \"component---src-pages-404-jsx\" */),\n  \"component---src-pages-data-explorer-jsx\": () => import(\"./../../../src/pages/data-explorer.jsx\" /* webpackChunkName: \"component---src-pages-data-explorer-jsx\" */),\n  \"component---src-pages-department-[url]-jsx\": () => import(\"./../../../src/pages/department/[url].jsx\" /* webpackChunkName: \"component---src-pages-department-[url]-jsx\" */),\n  \"component---src-pages-department-contentful-department-page-url-jsx\": () => import(\"./../../../src/pages/department/{contentfulDepartmentPage.url}.jsx\" /* webpackChunkName: \"component---src-pages-department-contentful-department-page-url-jsx\" */),\n  \"component---src-pages-help-jsx\": () => import(\"./../../../src/pages/help.jsx\" /* webpackChunkName: \"component---src-pages-help-jsx\" */),\n  \"component---src-pages-index-jsx\": () => import(\"./../../../src/pages/index.jsx\" /* webpackChunkName: \"component---src-pages-index-jsx\" */),\n  \"component---src-pages-map-jsx\": () => import(\"./../../../src/pages/map.jsx\" /* webpackChunkName: \"component---src-pages-map-jsx\" */),\n  \"component---src-pages-our-story-jsx\": () => import(\"./../../../src/pages/our-story.jsx\" /* webpackChunkName: \"component---src-pages-our-story-jsx\" */),\n  \"component---src-pages-resources-jsx\": () => import(\"./../../../src/pages/resources.jsx\" /* webpackChunkName: \"component---src-pages-resources-jsx\" */)\n}\n\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it) && it !== null) {\n    throw TypeError(\"Can't set \" + String(it) + ' as a prototype');\n  } return it;\n};\n","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}","import _curry1 from \"./internal/_curry1.js\";\n/**\n * A function that returns the `!` of its argument. It will return `true` when\n * passed false-y value, and `false` when passed a truth-y one.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig * -> Boolean\n * @param {*} a any value\n * @return {Boolean} the logical inverse of passed argument.\n * @see R.complement\n * @example\n *\n *      R.not(true); //=> false\n *      R.not(false); //=> true\n *      R.not(0); //=> true\n *      R.not(1); //=> false\n */\n\nvar not = /*#__PURE__*/_curry1(function not(a) {\n  return !a;\n});\n\nexport default not;","module.exports = {};\n","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: String(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n  var state = getInternalState(this);\n  var string = state.string;\n  var index = state.index;\n  var point;\n  if (index >= string.length) return { value: undefined, done: true };\n  point = charAt(string, index);\n  state.index += point.length;\n  return { value: point, done: false };\n});\n","import _curry2 from \"./internal/_curry2.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport ap from \"./ap.js\";\nimport curryN from \"./curryN.js\";\nimport map from \"./map.js\";\n/**\n * \"lifts\" a function to be the specified arity, so that it may \"map over\" that\n * many lists, Functions or other objects that satisfy the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig Number -> (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.lift, R.ap\n * @example\n *\n *      const madd3 = R.liftN(3, (...args) => R.sum(args));\n *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n */\n\nvar liftN = /*#__PURE__*/_curry2(function liftN(arity, fn) {\n  var lifted = curryN(arity, fn);\n  return curryN(arity, function () {\n    return _reduce(ap, map(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));\n  });\n});\n\nexport default liftN;","import _curry3 from \"./internal/_curry3.js\";\nimport defaultTo from \"./defaultTo.js\";\nimport path from \"./path.js\";\n/**\n * If the given, non-null object has a value at the given path, returns the\n * value at that path. Otherwise returns the provided default value.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig a -> [Idx] -> {a} -> a\n * @param {*} d The default value.\n * @param {Array} p The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path` of the supplied object or the default value.\n * @example\n *\n *      R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2\n *      R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> \"N/A\"\n */\n\nvar pathOr = /*#__PURE__*/_curry3(function pathOr(d, p, obj) {\n  return defaultTo(d, path(p, obj));\n});\n\nexport default pathOr;","import _curry2 from \"./internal/_curry2.js\";\nimport _Set from \"./internal/_Set.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements in the first list not\n * contained in the second list. Objects and Arrays are compared in terms of\n * value equality, not reference equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` that are not in `list2`.\n * @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith, R.without\n * @example\n *\n *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n *      R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]\n */\n\nvar difference = /*#__PURE__*/_curry2(function difference(first, second) {\n  var out = [];\n  var idx = 0;\n  var firstLen = first.length;\n  var secondLen = second.length;\n  var toFilterOut = new _Set();\n\n  for (var i = 0; i < secondLen; i += 1) {\n    toFilterOut.add(second[i]);\n  }\n\n  while (idx < firstLen) {\n    if (toFilterOut.add(first[idx])) {\n      out[out.length] = first[idx];\n    }\n\n    idx += 1;\n  }\n\n  return out;\n});\n\nexport default difference;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if both arguments are `true`; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {Any} a\n * @param {Any} b\n * @return {Any} the first argument if it is falsy, otherwise the second argument.\n * @see R.both, R.xor\n * @example\n *\n *      R.and(true, true); //=> true\n *      R.and(true, false); //=> false\n *      R.and(false, true); //=> false\n *      R.and(false, false); //=> false\n */\n\nvar and = /*#__PURE__*/_curry2(function and(a, b) {\n  return a && b;\n});\n\nexport default and;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  }\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error(\n        'Minified exception occurred; use the non-minified dev environment ' +\n        'for the full error message and additional helpful warnings.'\n      );\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(\n        format.replace(/%s/g, function() { return args[argIndex++]; })\n      );\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n};\n\nmodule.exports = invariant;\n","import _includes from \"./_includes.js\";\n\nvar _Set = /*#__PURE__*/function () {\n  function _Set() {\n    /* globals Set */\n    this._nativeSet = typeof Set === 'function' ? new Set() : null;\n    this._items = {};\n  } // until we figure out why jsdoc chokes on this\n  // @param item The item to add to the Set\n  // @returns {boolean} true if the item did not exist prior, otherwise false\n  //\n\n\n  _Set.prototype.add = function (item) {\n    return !hasOrAdd(item, true, this);\n  }; //\n  // @param item The item to check for existence in the Set\n  // @returns {boolean} true if the item exists in the Set, otherwise false\n  //\n\n\n  _Set.prototype.has = function (item) {\n    return hasOrAdd(item, false, this);\n  }; //\n  // Combines the logic for checking whether an item is a member of the set and\n  // for adding a new item to the set.\n  //\n  // @param item       The item to check or add to the Set instance.\n  // @param shouldAdd  If true, the item will be added to the set if it doesn't\n  //                   already exist.\n  // @param set        The set instance to check or add to.\n  // @return {boolean} true if the item already existed, otherwise false.\n  //\n\n\n  return _Set;\n}();\n\nfunction hasOrAdd(item, shouldAdd, set) {\n  var type = typeof item;\n  var prevSize, newSize;\n\n  switch (type) {\n    case 'string':\n    case 'number':\n      // distinguish between +0 and -0\n      if (item === 0 && 1 / item === -Infinity) {\n        if (set._items['-0']) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items['-0'] = true;\n          }\n\n          return false;\n        }\n      } // these types can all utilise the native Set\n\n\n      if (set._nativeSet !== null) {\n        if (shouldAdd) {\n          prevSize = set._nativeSet.size;\n\n          set._nativeSet.add(item);\n\n          newSize = set._nativeSet.size;\n          return newSize === prevSize;\n        } else {\n          return set._nativeSet.has(item);\n        }\n      } else {\n        if (!(type in set._items)) {\n          if (shouldAdd) {\n            set._items[type] = {};\n            set._items[type][item] = true;\n          }\n\n          return false;\n        } else if (item in set._items[type]) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items[type][item] = true;\n          }\n\n          return false;\n        }\n      }\n\n    case 'boolean':\n      // set._items['boolean'] holds a two element array\n      // representing [ falseExists, trueExists ]\n      if (type in set._items) {\n        var bIdx = item ? 1 : 0;\n\n        if (set._items[type][bIdx]) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items[type][bIdx] = true;\n          }\n\n          return false;\n        }\n      } else {\n        if (shouldAdd) {\n          set._items[type] = item ? [false, true] : [true, false];\n        }\n\n        return false;\n      }\n\n    case 'function':\n      // compare functions for reference equality\n      if (set._nativeSet !== null) {\n        if (shouldAdd) {\n          prevSize = set._nativeSet.size;\n\n          set._nativeSet.add(item);\n\n          newSize = set._nativeSet.size;\n          return newSize === prevSize;\n        } else {\n          return set._nativeSet.has(item);\n        }\n      } else {\n        if (!(type in set._items)) {\n          if (shouldAdd) {\n            set._items[type] = [item];\n          }\n\n          return false;\n        }\n\n        if (!_includes(item, set._items[type])) {\n          if (shouldAdd) {\n            set._items[type].push(item);\n          }\n\n          return false;\n        }\n\n        return true;\n      }\n\n    case 'undefined':\n      if (set._items[type]) {\n        return true;\n      } else {\n        if (shouldAdd) {\n          set._items[type] = true;\n        }\n\n        return false;\n      }\n\n    case 'object':\n      if (item === null) {\n        if (!set._items['null']) {\n          if (shouldAdd) {\n            set._items['null'] = true;\n          }\n\n          return false;\n        }\n\n        return true;\n      }\n\n    /* falls through */\n\n    default:\n      // reduce the search size of heterogeneous sets by creating buckets\n      // for each type.\n      type = Object.prototype.toString.call(item);\n\n      if (!(type in set._items)) {\n        if (shouldAdd) {\n          set._items[type] = [item];\n        }\n\n        return false;\n      } // scan through all previously applied items\n\n\n      if (!_includes(item, set._items[type])) {\n        if (shouldAdd) {\n          set._items[type].push(item);\n        }\n\n        return false;\n      }\n\n      return true;\n  }\n} // A simple Set type that honours R.equals semantics\n\n\nexport default _Set;","var global = require('../internals/global');\n\nmodule.exports = global;\n","var fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","import _identity from \"./internal/_identity.js\";\nimport chain from \"./chain.js\";\n/**\n * Shorthand for `R.chain(R.identity)`, which removes one level of nesting from\n * any [Chain](https://github.com/fantasyland/fantasy-land#chain).\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig Chain c => c (c a) -> c a\n * @param {*} list\n * @return {*}\n * @see R.flatten, R.chain\n * @example\n *\n *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n */\n\nvar unnest = /*#__PURE__*/chain(_identity);\nexport default unnest;","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}","/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol();\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","import _curry3 from \"./internal/_curry3.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Creates a function that will process either the `onTrue` or the `onFalse`\n * function depending upon the result of the `condition` predicate.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n * @param {Function} condition A predicate function\n * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n * @return {Function} A new function that will process either the `onTrue` or the `onFalse`\n *                    function depending upon the result of the `condition` predicate.\n * @see R.unless, R.when, R.cond\n * @example\n *\n *      const incCount = R.ifElse(\n *        R.has('count'),\n *        R.over(R.lensProp('count'), R.inc),\n *        R.assoc('count', 1)\n *      );\n *      incCount({});           //=> { count: 1 }\n *      incCount({ count: 1 }); //=> { count: 2 }\n */\n\nvar ifElse = /*#__PURE__*/_curry3(function ifElse(condition, onTrue, onFalse) {\n  return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n    return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n  });\n});\n\nexport default ifElse;","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 = /*#__PURE__*/_curry1( /*#__PURE__*/_checkForMethod('tail', /*#__PURE__*/slice(1, Infinity)));\n\nexport default tail;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  return _setPrototypeOf(o, p);\n}\n\nmodule.exports = _setPrototypeOf;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","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 \"./internal/_curry1.js\";\nimport empty from \"./empty.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns `true` if the given value is its type's empty value; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> Boolean\n * @param {*} x\n * @return {Boolean}\n * @see R.empty\n * @example\n *\n *      R.isEmpty([1, 2, 3]);   //=> false\n *      R.isEmpty([]);          //=> true\n *      R.isEmpty('');          //=> true\n *      R.isEmpty(null);        //=> false\n *      R.isEmpty({});          //=> true\n *      R.isEmpty({length: 0}); //=> false\n */\n\nvar isEmpty = /*#__PURE__*/_curry1(function isEmpty(x) {\n  return x != null && equals(x, empty(x));\n});\n\nexport default isEmpty;","import _curry1 from \"./internal/_curry1.js\";\nimport apply from \"./apply.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\nimport keys from \"./keys.js\";\nimport values from \"./values.js\"; // Use custom mapValues function to avoid issues with specs that include a \"map\" key and R.map\n// delegating calls to .map\n\nfunction mapValues(fn, obj) {\n  return keys(obj).reduce(function (acc, key) {\n    acc[key] = fn(obj[key]);\n    return acc;\n  }, {});\n}\n/**\n * Given a spec object recursively mapping properties to functions, creates a\n * function producing an object of the same structure, by mapping each property\n * to the result of calling its associated function with the supplied arguments.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Function\n * @sig {k: ((a, b, ..., m) -> v)} -> ((a, b, ..., m) -> {k: v})\n * @param {Object} spec an object recursively mapping properties to functions for\n *        producing the values for these properties.\n * @return {Function} A function that returns an object of the same structure\n * as `spec', with each property set to the value returned by calling its\n * associated function with the supplied arguments.\n * @see R.converge, R.juxt\n * @example\n *\n *      const getMetrics = R.applySpec({\n *        sum: R.add,\n *        nested: { mul: R.multiply }\n *      });\n *      getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } }\n * @symb R.applySpec({ x: f, y: { z: g } })(a, b) = { x: f(a, b), y: { z: g(a, b) } }\n */\n\n\nvar applySpec = /*#__PURE__*/_curry1(function applySpec(spec) {\n  spec = mapValues(function (v) {\n    return typeof v == 'function' ? v : applySpec(v);\n  }, spec);\n  return curryN(reduce(max, 0, pluck('length', values(spec))), function () {\n    var args = arguments;\n    return mapValues(function (f) {\n      return apply(f, args);\n    }, spec);\n  });\n});\n\nexport default applySpec;","import invoker from \"./invoker.js\";\n/**\n * Splits a string into an array of strings based on the given\n * separator.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category String\n * @sig (String | RegExp) -> String -> [String]\n * @param {String|RegExp} sep The pattern.\n * @param {String} str The string to separate into an array.\n * @return {Array} The array of strings from `str` separated by `sep`.\n * @see R.join\n * @example\n *\n *      const pathComponents = R.split('/');\n *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n *\n *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n */\n\nvar split = /*#__PURE__*/invoker(1, 'split');\nexport default split;","var toIndexedObject = require('../internals/to-indexed-object');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar toLength = require('../internals/to-length');\nvar createProperty = require('../internals/create-property');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n  var O = toObject(arrayLike);\n  var C = typeof this == 'function' ? this : Array;\n  var argumentsLength = arguments.length;\n  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n  var mapping = mapfn !== undefined;\n  var iteratorMethod = getIteratorMethod(O);\n  var index = 0;\n  var length, result, step, iterator, next, value;\n  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);\n  // if the target is not iterable or it's an array with the default iterator - use a simple case\n  if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {\n    iterator = iteratorMethod.call(O);\n    next = iterator.next;\n    result = new C();\n    for (;!(step = next.call(iterator)).done; index++) {\n      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n      createProperty(result, index, value);\n    }\n  } else {\n    length = toLength(O.length);\n    result = new C(length);\n    for (;length > index; index++) {\n      value = mapping ? mapfn(O[index], index) : O[index];\n      createProperty(result, index, value);\n    }\n  }\n  result.length = index;\n  return result;\n};\n","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","import _curry1 from \"./internal/_curry1.js\";\nimport keys from \"./keys.js\";\n/**\n * Returns a list of all the enumerable own properties of the supplied object.\n * Note that the order of the output array is not guaranteed across different\n * JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [v]\n * @param {Object} obj The object to extract values from\n * @return {Array} An array of the values of the object's own properties.\n * @see R.valuesIn, R.keys\n * @example\n *\n *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n */\n\nvar values = /*#__PURE__*/_curry1(function values(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var vals = [];\n  var idx = 0;\n\n  while (idx < len) {\n    vals[idx] = obj[props[idx]];\n    idx += 1;\n  }\n\n  return vals;\n});\n\nexport default values;","import _curry2 from \"./internal/_curry2.js\";\nimport concat from \"./concat.js\";\nimport difference from \"./difference.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements contained in the first or\n * second list, but not both.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` or `list2`, but not both.\n * @see R.symmetricDifferenceWith, R.difference, R.differenceWith\n * @example\n *\n *      R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5]\n *      R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2]\n */\n\nvar symmetricDifference = /*#__PURE__*/_curry2(function symmetricDifference(list1, list2) {\n  return concat(difference(list1, list2), difference(list2, list1));\n});\n\nexport default symmetricDifference;","var toInteger = require('../internals/to-integer');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","import reduceBy from \"./reduceBy.js\";\n/**\n * Given a function that generates a key, turns a list of objects into an\n * object indexing the objects by the given key. Note that if multiple\n * objects generate the same value for the indexing key only the last value\n * will be included in the generated object.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (a -> String) -> [{k: v}] -> {k: {k: v}}\n * @param {Function} fn Function :: a -> String\n * @param {Array} array The array of objects to index\n * @return {Object} An object indexing each array element by the given property.\n * @example\n *\n *      const list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];\n *      R.indexBy(R.prop('id'), list);\n *      //=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}\n */\n\nvar indexBy = /*#__PURE__*/reduceBy(function (acc, elem) {\n  return elem;\n}, null);\nexport default indexBy;","var toObject = require('../internals/to-object');\n\nvar hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty.call(toObject(it), key);\n};\n","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Checks if the input value is `null` or `undefined`.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Type\n * @sig * -> Boolean\n * @param {*} x The value to test.\n * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n * @example\n *\n *      R.isNil(null); //=> true\n *      R.isNil(undefined); //=> true\n *      R.isNil(0); //=> false\n *      R.isNil([]); //=> false\n */\n\nvar isNil = /*#__PURE__*/_curry1(function isNil(x) {\n  return x == null;\n});\n\nexport default isNil;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFind = /*#__PURE__*/function () {\n  function XFind(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.found = false;\n  }\n\n  XFind.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFind.prototype['@@transducer/result'] = function (result) {\n    if (!this.found) {\n      result = this.xf['@@transducer/step'](result, void 0);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XFind.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f(input)) {\n      this.found = true;\n      result = _reduced(this.xf['@@transducer/step'](result, input));\n    }\n\n    return result;\n  };\n\n  return XFind;\n}();\n\nvar _xfind = /*#__PURE__*/_curry2(function _xfind(f, xf) {\n  return new XFind(f, xf);\n});\n\nexport default _xfind;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfind from \"./internal/_xfind.js\";\n/**\n * Returns the first element of the list which matches the predicate, or\n * `undefined` if no element matches.\n *\n * Dispatches to the `find` 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 (a -> Boolean) -> [a] -> a | undefined\n * @param {Function} fn The predicate function used to determine if the element is the\n *        desired one.\n * @param {Array} list The array to consider.\n * @return {Object} The element found, or `undefined`.\n * @see R.transduce\n * @example\n *\n *      const xs = [{a: 1}, {a: 2}, {a: 3}];\n *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n *      R.find(R.propEq('a', 4))(xs); //=> undefined\n */\n\nvar find = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['find'], _xfind, function find(fn, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      return list[idx];\n    }\n\n    idx += 1;\n  }\n}));\n\nexport default find;","// This is extracted to separate module because it's shared\n// between browser and SSR code\nexport const RouteAnnouncerProps = {\n  id: `gatsby-announcer`,\n  style: {\n    position: `absolute`,\n    top: 0,\n    width: 1,\n    height: 1,\n    padding: 0,\n    overflow: `hidden`,\n    clip: `rect(0, 0, 0, 0)`,\n    whiteSpace: `nowrap`,\n    border: 0,\n  },\n  \"aria-live\": `assertive`,\n  \"aria-atomic\": `true`,\n}\n","import React from \"react\"\nimport PropTypes from \"prop-types\"\nimport loader, { PageResourceStatus } from \"./loader\"\nimport redirects from \"./redirects.json\"\nimport { apiRunner } from \"./api-runner-browser\"\nimport emitter from \"./emitter\"\nimport { RouteAnnouncerProps } from \"./route-announcer-props\"\nimport { navigate as reachNavigate } from \"@reach/router\"\nimport { globalHistory } from \"@reach/router/lib/history\"\nimport { parsePath } from \"gatsby-link\"\n\n// Convert to a map for faster lookup in maybeRedirect()\n\nconst redirectMap = new Map()\nconst redirectIgnoreCaseMap = new Map()\n\nredirects.forEach(redirect => {\n  if (redirect.ignoreCase) {\n    redirectIgnoreCaseMap.set(redirect.fromPath, redirect)\n  } else {\n    redirectMap.set(redirect.fromPath, redirect)\n  }\n})\n\nfunction maybeRedirect(pathname) {\n  let redirect = redirectMap.get(pathname)\n  if (!redirect) {\n    redirect = redirectIgnoreCaseMap.get(pathname.toLowerCase())\n  }\n\n  if (redirect != null) {\n    if (process.env.NODE_ENV !== `production`) {\n      if (!loader.isPageNotFound(pathname)) {\n        console.error(\n          `The route \"${pathname}\" matches both a page and a redirect; this is probably not intentional.`\n        )\n      }\n    }\n\n    window.___replace(redirect.toPath)\n    return true\n  } else {\n    return false\n  }\n}\n\nconst onPreRouteUpdate = (location, prevLocation) => {\n  if (!maybeRedirect(location.pathname)) {\n    apiRunner(`onPreRouteUpdate`, { location, prevLocation })\n  }\n}\n\nconst onRouteUpdate = (location, prevLocation) => {\n  if (!maybeRedirect(location.pathname)) {\n    apiRunner(`onRouteUpdate`, { location, prevLocation })\n    if (\n      process.env.GATSBY_EXPERIMENTAL_QUERY_ON_DEMAND &&\n      process.env.GATSBY_QUERY_ON_DEMAND_LOADING_INDICATOR === `true`\n    ) {\n      emitter.emit(`onRouteUpdate`, { location, prevLocation })\n    }\n  }\n}\n\nconst navigate = (to, options = {}) => {\n  // Support forward/backward navigation with numbers\n  // navigate(-2) (jumps back 2 history steps)\n  // navigate(2)  (jumps forward 2 history steps)\n  if (typeof to === `number`) {\n    globalHistory.navigate(to)\n    return\n  }\n\n  let { pathname } = parsePath(to)\n  let redirect = redirectMap.get(pathname)\n  if (!redirect) {\n    redirect = redirectIgnoreCaseMap.get(pathname.toLowerCase())\n  }\n\n  // If we're redirecting, just replace the passed in pathname\n  // to the one we want to redirect to.\n  if (redirect) {\n    to = redirect.toPath\n    pathname = parsePath(to).pathname\n  }\n\n  // If we had a service worker update, no matter the path, reload window and\n  // reset the pathname whitelist\n  if (window.___swUpdated) {\n    window.location = pathname\n    return\n  }\n\n  // Start a timer to wait for a second before transitioning and showing a\n  // loader in case resources aren't around yet.\n  const timeoutId = setTimeout(() => {\n    emitter.emit(`onDelayedLoadPageResources`, { pathname })\n    apiRunner(`onRouteUpdateDelayed`, {\n      location: window.location,\n    })\n  }, 1000)\n\n  loader.loadPage(pathname).then(pageResources => {\n    // If no page resources, then refresh the page\n    // Do this, rather than simply `window.location.reload()`, so that\n    // pressing the back/forward buttons work - otherwise when pressing\n    // back, the browser will just change the URL and expect JS to handle\n    // the change, which won't always work since it might not be a Gatsby\n    // page.\n    if (!pageResources || pageResources.status === PageResourceStatus.Error) {\n      window.history.replaceState({}, ``, location.href)\n      window.location = pathname\n      clearTimeout(timeoutId)\n      return\n    }\n\n    // If the loaded page has a different compilation hash to the\n    // window, then a rebuild has occurred on the server. Reload.\n    if (process.env.NODE_ENV === `production` && pageResources) {\n      if (\n        pageResources.page.webpackCompilationHash !==\n        window.___webpackCompilationHash\n      ) {\n        // Purge plugin-offline cache\n        if (\n          `serviceWorker` in navigator &&\n          navigator.serviceWorker.controller !== null &&\n          navigator.serviceWorker.controller.state === `activated`\n        ) {\n          navigator.serviceWorker.controller.postMessage({\n            gatsbyApi: `clearPathResources`,\n          })\n        }\n\n        window.location = pathname\n      }\n    }\n    reachNavigate(to, options)\n    clearTimeout(timeoutId)\n  })\n}\n\nfunction shouldUpdateScroll(prevRouterProps, { location }) {\n  const { pathname, hash } = location\n  const results = apiRunner(`shouldUpdateScroll`, {\n    prevRouterProps,\n    // `pathname` for backwards compatibility\n    pathname,\n    routerProps: { location },\n    getSavedScrollPosition: args => [\n      0,\n      this._stateStorage.read(args, args.key),\n    ],\n  })\n  if (results.length > 0) {\n    // Use the latest registered shouldUpdateScroll result, this allows users to override plugin's configuration\n    // @see https://github.com/gatsbyjs/gatsby/issues/12038\n    return results[results.length - 1]\n  }\n\n  if (prevRouterProps) {\n    const {\n      location: { pathname: oldPathname },\n    } = prevRouterProps\n    if (oldPathname === pathname) {\n      // Scroll to element if it exists, if it doesn't, or no hash is provided,\n      // scroll to top.\n      return hash ? decodeURI(hash.slice(1)) : [0, 0]\n    }\n  }\n  return true\n}\n\nfunction init() {\n  // The \"scroll-behavior\" package expects the \"action\" to be on the location\n  // object so let's copy it over.\n  globalHistory.listen(args => {\n    args.location.action = args.action\n  })\n\n  window.___push = to => navigate(to, { replace: false })\n  window.___replace = to => navigate(to, { replace: true })\n  window.___navigate = (to, options) => navigate(to, options)\n\n  // Check for initial page-load redirect\n  maybeRedirect(window.location.pathname)\n}\n\nclass RouteAnnouncer extends React.Component {\n  constructor(props) {\n    super(props)\n    this.announcementRef = React.createRef()\n  }\n\n  componentDidUpdate(prevProps, nextProps) {\n    requestAnimationFrame(() => {\n      let pageName = `new page at ${this.props.location.pathname}`\n      if (document.title) {\n        pageName = document.title\n      }\n      const pageHeadings = document.querySelectorAll(`#gatsby-focus-wrapper h1`)\n      if (pageHeadings && pageHeadings.length) {\n        pageName = pageHeadings[0].textContent\n      }\n      const newAnnouncement = `Navigated to ${pageName}`\n      if (this.announcementRef.current) {\n        const oldAnnouncement = this.announcementRef.current.innerText\n        if (oldAnnouncement !== newAnnouncement) {\n          this.announcementRef.current.innerText = newAnnouncement\n        }\n      }\n    })\n  }\n\n  render() {\n    return <div {...RouteAnnouncerProps} ref={this.announcementRef}></div>\n  }\n}\n\nconst compareLocationProps = (prevLocation, nextLocation) => {\n  if (prevLocation.href !== nextLocation.href) {\n    return true\n  }\n\n  if (prevLocation?.state?.key !== nextLocation?.state?.key) {\n    return true\n  }\n\n  return false\n}\n\n// Fire on(Pre)RouteUpdate APIs\nclass RouteUpdates extends React.Component {\n  constructor(props) {\n    super(props)\n    onPreRouteUpdate(props.location, null)\n  }\n\n  componentDidMount() {\n    onRouteUpdate(this.props.location, null)\n  }\n\n  shouldComponentUpdate(prevProps) {\n    if (compareLocationProps(prevProps.location, this.props.location)) {\n      onPreRouteUpdate(this.props.location, prevProps.location)\n      return true\n    }\n    return false\n  }\n\n  componentDidUpdate(prevProps) {\n    if (compareLocationProps(prevProps.location, this.props.location)) {\n      onRouteUpdate(this.props.location, prevProps.location)\n    }\n  }\n\n  render() {\n    return (\n      <React.Fragment>\n        {this.props.children}\n        <RouteAnnouncer location={location} />\n      </React.Fragment>\n    )\n  }\n}\n\nRouteUpdates.propTypes = {\n  location: PropTypes.object.isRequired,\n}\n\nexport { init, shouldUpdateScroll, RouteUpdates }\n","// Pulled from react-compat\n// https://github.com/developit/preact-compat/blob/7c5de00e7c85e2ffd011bf3af02899b63f699d3a/src/index.js#L349\nfunction shallowDiffers(a, b) {\n  for (var i in a) {\n    if (!(i in b)) return true;\n  }for (var _i in b) {\n    if (a[_i] !== b[_i]) return true;\n  }return false;\n}\n\nexport default (function (instance, nextProps, nextState) {\n  return shallowDiffers(instance.props, nextProps) || shallowDiffers(instance.state, nextState);\n});","import React from \"react\"\nimport loader, { PageResourceStatus } from \"./loader\"\nimport shallowCompare from \"shallow-compare\"\n\nclass EnsureResources extends React.Component {\n  constructor(props) {\n    super()\n    const { location, pageResources } = props\n    this.state = {\n      location: { ...location },\n      pageResources: pageResources || loader.loadPageSync(location.pathname),\n    }\n  }\n\n  static getDerivedStateFromProps({ location }, prevState) {\n    if (prevState.location.href !== location.href) {\n      const pageResources = loader.loadPageSync(location.pathname)\n      return {\n        pageResources,\n        location: { ...location },\n      }\n    }\n\n    return {\n      location: { ...location },\n    }\n  }\n\n  loadResources(rawPath) {\n    loader.loadPage(rawPath).then(pageResources => {\n      if (pageResources && pageResources.status !== PageResourceStatus.Error) {\n        this.setState({\n          location: { ...window.location },\n          pageResources,\n        })\n      } else {\n        window.history.replaceState({}, ``, location.href)\n        window.location = rawPath\n      }\n    })\n  }\n\n  shouldComponentUpdate(nextProps, nextState) {\n    // Always return false if we're missing resources.\n    if (!nextState.pageResources) {\n      this.loadResources(nextProps.location.pathname)\n      return false\n    }\n\n    if (\n      process.env.BUILD_STAGE === `develop` &&\n      nextState.pageResources.stale\n    ) {\n      this.loadResources(nextProps.location.pathname)\n      return false\n    }\n\n    // Check if the component or json have changed.\n    if (this.state.pageResources !== nextState.pageResources) {\n      return true\n    }\n    if (\n      this.state.pageResources.component !== nextState.pageResources.component\n    ) {\n      return true\n    }\n\n    if (this.state.pageResources.json !== nextState.pageResources.json) {\n      return true\n    }\n    // Check if location has changed on a page using internal routing\n    // via matchPath configuration.\n    if (\n      this.state.location.key !== nextState.location.key &&\n      nextState.pageResources.page &&\n      (nextState.pageResources.page.matchPath ||\n        nextState.pageResources.page.path)\n    ) {\n      return true\n    }\n    return shallowCompare(this, nextProps, nextState)\n  }\n\n  render() {\n    if (process.env.NODE_ENV !== `production` && !this.state.pageResources) {\n      throw new Error(\n        `EnsureResources was not able to find resources for path: \"${this.props.location.pathname}\"\nThis typically means that an issue occurred building components for that path.\nRun \\`gatsby clean\\` to remove any cached elements.`\n      )\n    }\n\n    return this.props.children(this.state)\n  }\n}\n\nexport default EnsureResources\n","import { apiRunner, apiRunnerAsync } from \"./api-runner-browser\"\nimport React from \"react\"\nimport ReactDOM from \"react-dom\"\nimport { Router, navigate, Location, BaseContext } from \"@reach/router\"\nimport { ScrollContext } from \"gatsby-react-router-scroll\"\nimport domReady from \"@mikaelkristiansson/domready\"\nimport { StaticQueryContext } from \"gatsby\"\nimport {\n  shouldUpdateScroll,\n  init as navigationInit,\n  RouteUpdates,\n} from \"./navigation\"\nimport emitter from \"./emitter\"\nimport PageRenderer from \"./page-renderer\"\nimport asyncRequires from \"$virtual/async-requires\"\nimport {\n  setLoader,\n  ProdLoader,\n  publicLoader,\n  PageResourceStatus,\n  getStaticQueryResults,\n} from \"./loader\"\nimport EnsureResources from \"./ensure-resources\"\nimport stripPrefix from \"./strip-prefix\"\n\n// Generated during bootstrap\nimport matchPaths from \"$virtual/match-paths.json\"\n\nconst loader = new ProdLoader(asyncRequires, matchPaths)\nsetLoader(loader)\nloader.setApiRunner(apiRunner)\n\nwindow.asyncRequires = asyncRequires\nwindow.___emitter = emitter\nwindow.___loader = publicLoader\n\nnavigationInit()\n\napiRunnerAsync(`onClientEntry`).then(() => {\n  // Let plugins register a service worker. The plugin just needs\n  // to return true.\n  if (apiRunner(`registerServiceWorker`).length > 0) {\n    require(`./register-service-worker`)\n  }\n\n  // In gatsby v2 if Router is used in page using matchPaths\n  // paths need to contain full path.\n  // For example:\n  //   - page have `/app/*` matchPath\n  //   - inside template user needs to use `/app/xyz` as path\n  // Resetting `basepath`/`baseuri` keeps current behaviour\n  // to not introduce breaking change.\n  // Remove this in v3\n  const RouteHandler = props => (\n    <BaseContext.Provider\n      value={{\n        baseuri: `/`,\n        basepath: `/`,\n      }}\n    >\n      <PageRenderer {...props} />\n    </BaseContext.Provider>\n  )\n\n  const DataContext = React.createContext({})\n\n  class GatsbyRoot extends React.Component {\n    render() {\n      const { children } = this.props\n      return (\n        <Location>\n          {({ location }) => (\n            <EnsureResources location={location}>\n              {({ pageResources, location }) => {\n                const staticQueryResults = getStaticQueryResults()\n                return (\n                  <StaticQueryContext.Provider value={staticQueryResults}>\n                    <DataContext.Provider value={{ pageResources, location }}>\n                      {children}\n                    </DataContext.Provider>\n                  </StaticQueryContext.Provider>\n                )\n              }}\n            </EnsureResources>\n          )}\n        </Location>\n      )\n    }\n  }\n\n  class LocationHandler extends React.Component {\n    render() {\n      return (\n        <DataContext.Consumer>\n          {({ pageResources, location }) => (\n            <RouteUpdates location={location}>\n              <ScrollContext\n                location={location}\n                shouldUpdateScroll={shouldUpdateScroll}\n              >\n                <Router\n                  basepath={__BASE_PATH__}\n                  location={location}\n                  id=\"gatsby-focus-wrapper\"\n                >\n                  <RouteHandler\n                    path={\n                      pageResources.page.path === `/404.html`\n                        ? stripPrefix(location.pathname, __BASE_PATH__)\n                        : encodeURI(\n                            pageResources.page.matchPath ||\n                              pageResources.page.path\n                          )\n                    }\n                    {...this.props}\n                    location={location}\n                    pageResources={pageResources}\n                    {...pageResources.json}\n                  />\n                </Router>\n              </ScrollContext>\n            </RouteUpdates>\n          )}\n        </DataContext.Consumer>\n      )\n    }\n  }\n\n  const { pagePath, location: browserLoc } = window\n\n  // Explicitly call navigate if the canonical path (window.pagePath)\n  // is different to the browser path (window.location.pathname). But\n  // only if NONE of the following conditions hold:\n  //\n  // - The url matches a client side route (page.matchPath)\n  // - it's a 404 page\n  // - it's the offline plugin shell (/offline-plugin-app-shell-fallback/)\n  if (\n    pagePath &&\n    __BASE_PATH__ + pagePath !== browserLoc.pathname &&\n    !(\n      loader.findMatchPath(stripPrefix(browserLoc.pathname, __BASE_PATH__)) ||\n      pagePath === `/404.html` ||\n      pagePath.match(/^\\/404\\/?$/) ||\n      pagePath.match(/^\\/offline-plugin-app-shell-fallback\\/?$/)\n    )\n  ) {\n    navigate(__BASE_PATH__ + pagePath + browserLoc.search + browserLoc.hash, {\n      replace: true,\n    })\n  }\n\n  publicLoader.loadPage(browserLoc.pathname).then(page => {\n    if (!page || page.status === PageResourceStatus.Error) {\n      throw new Error(\n        `page resources for ${browserLoc.pathname} not found. Not rendering React`\n      )\n    }\n\n    window.___webpackCompilationHash = page.page.webpackCompilationHash\n\n    const SiteRoot = apiRunner(\n      `wrapRootElement`,\n      { element: <LocationHandler /> },\n      <LocationHandler />,\n      ({ result }) => {\n        return { element: result }\n      }\n    ).pop()\n\n    const App = () => <GatsbyRoot>{SiteRoot}</GatsbyRoot>\n\n    const renderer = apiRunner(\n      `replaceHydrateFunction`,\n      undefined,\n      ReactDOM.hydrate\n    )[0]\n\n    domReady(() => {\n      renderer(\n        <App />,\n        typeof window !== `undefined`\n          ? document.getElementById(`___gatsby`)\n          : void 0,\n        () => {\n          apiRunner(`onInitialClientRender`)\n        }\n      )\n    })\n  })\n})\n","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Applies function `fn` to the argument list `args`. This is useful for\n * creating a fixed-arity function from a variadic function. `fn` should be a\n * bound function if context is significant.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig (*... -> a) -> [*] -> a\n * @param {Function} fn The function which will be called with `args`\n * @param {Array} args The arguments to call `fn` with\n * @return {*} result The result, equivalent to `fn(...args)`\n * @see R.call, R.unapply\n * @example\n *\n *      const nums = [1, 2, 3, -99, 42, 6, 7];\n *      R.apply(Math.max, nums); //=> 42\n * @symb R.apply(f, [a, b, c]) = f(a, b, c)\n */\n\nvar apply = /*#__PURE__*/_curry2(function apply(fn, args) {\n  return fn.apply(this, args);\n});\n\nexport default apply;","/**\n * Determine if the passed argument is an integer.\n *\n * @private\n * @param {*} n\n * @category Type\n * @return {Boolean}\n */\nexport default Number.isInteger || function _isInteger(n) {\n  return n << 0 === n;\n};","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 _curry2 from \"./internal/_curry2.js\";\nimport map from \"./map.js\";\nimport prop from \"./prop.js\";\n/**\n * Returns a new list by plucking the same named property off all objects in\n * the list supplied.\n *\n * `pluck` will work on\n * any [functor](https://github.com/fantasyland/fantasy-land#functor) in\n * addition to arrays, as it is equivalent to `R.map(R.prop(k), f)`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => k -> f {k: v} -> f v\n * @param {Number|String} key The key name to pluck off of each object.\n * @param {Array} f The array or functor to consider.\n * @return {Array} The list of values for the given key.\n * @see R.props\n * @example\n *\n *      var getAges = R.pluck('age');\n *      getAges([{name: 'fred', age: 29}, {name: 'wilma', age: 27}]); //=> [29, 27]\n *\n *      R.pluck(0, [[1, 2], [3, 4]]);               //=> [1, 3]\n *      R.pluck('val', {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5}\n * @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5]\n * @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5]\n */\n\nvar pluck = /*#__PURE__*/_curry2(function pluck(p, list) {\n  return map(prop(p), list);\n});\n\nexport default pluck;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}\n\nmodule.exports = _inheritsLoose;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.15.2',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var getBuiltIn = require('../internals/get-built-in');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\n","import React from \"react\"\nimport PropTypes from \"prop-types\"\nimport Link, {\n  withPrefix,\n  withAssetPrefix,\n  navigate,\n  push,\n  replace,\n  navigateTo,\n  parsePath,\n} from \"gatsby-link\"\nimport { useScrollRestoration } from \"gatsby-react-router-scroll\"\nimport PageRenderer from \"./public-page-renderer\"\nimport loader from \"./loader\"\n\nconst prefetchPathname = loader.enqueue\n\nconst StaticQueryContext = React.createContext({})\n\nfunction StaticQueryDataRenderer({ staticQueryData, data, query, render }) {\n  const finalData = data\n    ? data.data\n    : staticQueryData[query] && staticQueryData[query].data\n\n  return (\n    <React.Fragment>\n      {finalData && render(finalData)}\n      {!finalData && <div>Loading (StaticQuery)</div>}\n    </React.Fragment>\n  )\n}\n\nconst StaticQuery = props => {\n  const { data, query, render, children } = props\n\n  return (\n    <StaticQueryContext.Consumer>\n      {staticQueryData => (\n        <StaticQueryDataRenderer\n          data={data}\n          query={query}\n          render={render || children}\n          staticQueryData={staticQueryData}\n        />\n      )}\n    </StaticQueryContext.Consumer>\n  )\n}\n\nconst useStaticQuery = query => {\n  if (\n    typeof React.useContext !== `function` &&\n    process.env.NODE_ENV === `development`\n  ) {\n    throw new Error(\n      `You're likely using a version of React that doesn't support Hooks\\n` +\n        `Please update React and ReactDOM to 16.8.0 or later to use the useStaticQuery hook.`\n    )\n  }\n  const context = React.useContext(StaticQueryContext)\n\n  // query is a stringified number like `3303882` when wrapped with graphql, If a user forgets\n  // to wrap the query in a grqphql, then casting it to a Number results in `NaN` allowing us to\n  // catch the misuse of the API and give proper direction\n  if (isNaN(Number(query))) {\n    throw new Error(`useStaticQuery was called with a string but expects to be called using \\`graphql\\`. Try this:\n\nimport { useStaticQuery, graphql } from 'gatsby';\n\nuseStaticQuery(graphql\\`${query}\\`);\n`)\n  }\n\n  if (context[query]?.data) {\n    return context[query].data\n  } else {\n    throw new Error(\n      `The result of this StaticQuery could not be fetched.\\n\\n` +\n        `This is likely a bug in Gatsby and if refreshing the page does not fix it, ` +\n        `please open an issue in https://github.com/gatsbyjs/gatsby/issues`\n    )\n  }\n}\n\nStaticQuery.propTypes = {\n  data: PropTypes.object,\n  query: PropTypes.string.isRequired,\n  render: PropTypes.func,\n  children: PropTypes.func,\n}\n\nfunction graphql() {\n  throw new Error(\n    `It appears like Gatsby is misconfigured. Gatsby related \\`graphql\\` calls ` +\n      `are supposed to only be evaluated at compile time, and then compiled away. ` +\n      `Unfortunately, something went wrong and the query was left in the compiled code.\\n\\n` +\n      `Unless your site has a complex or custom babel/Gatsby configuration this is likely a bug in Gatsby.`\n  )\n}\n\nexport {\n  Link,\n  withAssetPrefix,\n  withPrefix,\n  graphql,\n  parsePath,\n  navigate,\n  push, // TODO replace for v3\n  replace, // TODO remove replace for v3\n  navigateTo, // TODO: remove navigateTo for v3\n  useScrollRestoration,\n  StaticQueryContext,\n  StaticQuery,\n  PageRenderer,\n  useStaticQuery,\n  prefetchPathname,\n}\n","'use strict';\n// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js\nvar maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\nvar base = 36;\nvar tMin = 1;\nvar tMax = 26;\nvar skew = 38;\nvar damp = 700;\nvar initialBias = 72;\nvar initialN = 128; // 0x80\nvar delimiter = '-'; // '\\x2D'\nvar regexNonASCII = /[^\\0-\\u007E]/; // non-ASCII chars\nvar regexSeparators = /[.\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\nvar OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';\nvar baseMinusTMin = base - tMin;\nvar floor = Math.floor;\nvar stringFromCharCode = String.fromCharCode;\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n */\nvar ucs2decode = function (string) {\n  var output = [];\n  var counter = 0;\n  var length = string.length;\n  while (counter < length) {\n    var value = string.charCodeAt(counter++);\n    if (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n      // It's a high surrogate, and there is a next character.\n      var extra = string.charCodeAt(counter++);\n      if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n        output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n      } else {\n        // It's an unmatched surrogate; only append this code unit, in case the\n        // next code unit is the high surrogate of a surrogate pair.\n        output.push(value);\n        counter--;\n      }\n    } else {\n      output.push(value);\n    }\n  }\n  return output;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n */\nvar digitToBasic = function (digit) {\n  //  0..25 map to ASCII a..z or A..Z\n  // 26..35 map to ASCII 0..9\n  return digit + 22 + 75 * (digit < 26);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n */\nvar adapt = function (delta, numPoints, firstTime) {\n  var k = 0;\n  delta = firstTime ? floor(delta / damp) : delta >> 1;\n  delta += floor(delta / numPoints);\n  for (; delta > baseMinusTMin * tMax >> 1; k += base) {\n    delta = floor(delta / baseMinusTMin);\n  }\n  return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n */\n// eslint-disable-next-line max-statements -- TODO\nvar encode = function (input) {\n  var output = [];\n\n  // Convert the input in UCS-2 to an array of Unicode code points.\n  input = ucs2decode(input);\n\n  // Cache the length.\n  var inputLength = input.length;\n\n  // Initialize the state.\n  var n = initialN;\n  var delta = 0;\n  var bias = initialBias;\n  var i, currentValue;\n\n  // Handle the basic code points.\n  for (i = 0; i < input.length; i++) {\n    currentValue = input[i];\n    if (currentValue < 0x80) {\n      output.push(stringFromCharCode(currentValue));\n    }\n  }\n\n  var basicLength = output.length; // number of basic code points.\n  var handledCPCount = basicLength; // number of code points that have been handled;\n\n  // Finish the basic string with a delimiter unless it's empty.\n  if (basicLength) {\n    output.push(delimiter);\n  }\n\n  // Main encoding loop:\n  while (handledCPCount < inputLength) {\n    // All non-basic code points < n have been handled already. Find the next larger one:\n    var m = maxInt;\n    for (i = 0; i < input.length; i++) {\n      currentValue = input[i];\n      if (currentValue >= n && currentValue < m) {\n        m = currentValue;\n      }\n    }\n\n    // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.\n    var handledCPCountPlusOne = handledCPCount + 1;\n    if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n      throw RangeError(OVERFLOW_ERROR);\n    }\n\n    delta += (m - n) * handledCPCountPlusOne;\n    n = m;\n\n    for (i = 0; i < input.length; i++) {\n      currentValue = input[i];\n      if (currentValue < n && ++delta > maxInt) {\n        throw RangeError(OVERFLOW_ERROR);\n      }\n      if (currentValue == n) {\n        // Represent delta as a generalized variable-length integer.\n        var q = delta;\n        for (var k = base; /* no condition */; k += base) {\n          var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n          if (q < t) break;\n          var qMinusT = q - t;\n          var baseMinusT = base - t;\n          output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT)));\n          q = floor(qMinusT / baseMinusT);\n        }\n\n        output.push(stringFromCharCode(digitToBasic(q)));\n        bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n        delta = 0;\n        ++handledCPCount;\n      }\n    }\n\n    ++delta;\n    ++n;\n  }\n  return output.join('');\n};\n\nmodule.exports = function (input) {\n  var encoded = [];\n  var labels = input.toLowerCase().replace(regexSeparators, '\\u002E').split('.');\n  var i, label;\n  for (i = 0; i < labels.length; i++) {\n    label = labels[i];\n    encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label);\n  }\n  return encoded.join('.');\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\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}","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 = /*#__PURE__*/_curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function () {\n    return fn.apply(thisObj, arguments);\n  });\n});\n\nexport default bind;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`,\n * according to the `transformation` functions. All non-primitive properties\n * are copied by reference.\n *\n * A `transformation` function will not be invoked if its corresponding key\n * does not exist in the evolved object.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      const tomato = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      const transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\n\nvar evolve = /*#__PURE__*/_curry2(function evolve(transformations, object) {\n  var result = object instanceof Array ? [] : {};\n  var transformation, key, type;\n\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key]) : transformation && type === 'object' ? evolve(transformation, object[key]) : object[key];\n  }\n\n  return result;\n});\n\nexport default evolve;","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n  // should have correct order of operations (Edge bug)\n  if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n    enumerable: true,\n    get: function () {\n      defineProperty(this, 'b', {\n        value: 3,\n        enumerable: false\n      });\n    }\n  }), { b: 2 })).b !== 1) return true;\n  // should work with symbols and should have deterministic property order (V8 bug)\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line es/no-symbol -- safe\n  var symbol = Symbol();\n  var alphabet = 'abcdefghijklmnopqrst';\n  A[symbol] = 7;\n  alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n  return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n  var T = toObject(target);\n  var argumentsLength = arguments.length;\n  var index = 1;\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  var propertyIsEnumerable = propertyIsEnumerableModule.f;\n  while (argumentsLength > index) {\n    var S = IndexedObject(arguments[index++]);\n    var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) {\n      key = keys[j++];\n      if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key];\n    }\n  } return T;\n} : $assign;\n","import _curry2 from \"./internal/_curry2.js\";\nimport _isString from \"./internal/_isString.js\";\n/**\n * Returns the nth element of the given list or string. If n is negative the\n * element at index length + n is returned.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> a | Undefined\n * @sig Number -> String -> String\n * @param {Number} offset\n * @param {*} list\n * @return {*}\n * @example\n *\n *      const list = ['foo', 'bar', 'baz', 'quux'];\n *      R.nth(1, list); //=> 'bar'\n *      R.nth(-1, list); //=> 'quux'\n *      R.nth(-99, list); //=> undefined\n *\n *      R.nth(2, 'abc'); //=> 'c'\n *      R.nth(3, 'abc'); //=> ''\n * @symb R.nth(-1, [a, b, c]) = c\n * @symb R.nth(0, [a, b, c]) = a\n * @symb R.nth(1, [a, b, c]) = b\n */\n\nvar nth = /*#__PURE__*/_curry2(function nth(offset, list) {\n  var idx = offset < 0 ? list.length + offset : offset;\n  return _isString(list) ? list.charAt(idx) : list[idx];\n});\n\nexport default nth;","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 = /*#__PURE__*/_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;","\"use strict\";\n\nmodule.exports = Object.assign;","import invoker from \"./invoker.js\";\n/**\n * The lower case version of a string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to lower case.\n * @return {String} The lower case version of `str`.\n * @see R.toUpper\n * @example\n *\n *      R.toLower('XYZ'); //=> 'xyz'\n */\n\nvar toLower = /*#__PURE__*/invoker(0, 'toLowerCase');\nexport default toLower;","var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }\n\n/* eslint-disable jsx-a11y/anchor-has-content */\nimport React, { useContext } from \"react\";\nimport PropTypes from \"prop-types\";\nimport invariant from \"invariant\";\nimport createContext from \"create-react-context\";\nimport { polyfill } from \"react-lifecycles-compat\";\nimport { startsWith, pick, resolve, match, insertParams, validateRedirect, shallowCompare } from \"./lib/utils\";\nimport { globalHistory, navigate, createHistory, createMemorySource } from \"./lib/history\";\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar createNamedContext = function createNamedContext(name, defaultValue) {\n  var Ctx = createContext(defaultValue);\n  Ctx.displayName = name;\n  return Ctx;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Location Context/Provider\nvar LocationContext = createNamedContext(\"Location\");\n\n// sets up a listener if there isn't one already so apps don't need to be\n// wrapped in some top level provider\nvar Location = function Location(_ref) {\n  var children = _ref.children;\n  return React.createElement(\n    LocationContext.Consumer,\n    null,\n    function (context) {\n      return context ? children(context) : React.createElement(\n        LocationProvider,\n        null,\n        children\n      );\n    }\n  );\n};\n\nvar LocationProvider = function (_React$Component) {\n  _inherits(LocationProvider, _React$Component);\n\n  function LocationProvider() {\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, LocationProvider);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n      context: _this.getContext(),\n      refs: { unlisten: null }\n    }, _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  LocationProvider.prototype.getContext = function getContext() {\n    var _props$history = this.props.history,\n        navigate = _props$history.navigate,\n        location = _props$history.location;\n\n    return { navigate: navigate, location: location };\n  };\n\n  LocationProvider.prototype.componentDidCatch = function componentDidCatch(error, info) {\n    if (isRedirect(error)) {\n      var _navigate = this.props.history.navigate;\n\n      _navigate(error.uri, { replace: true });\n    } else {\n      throw error;\n    }\n  };\n\n  LocationProvider.prototype.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n    if (prevState.context.location !== this.state.context.location) {\n      this.props.history._onTransitionComplete();\n    }\n  };\n\n  LocationProvider.prototype.componentDidMount = function componentDidMount() {\n    var _this2 = this;\n\n    var refs = this.state.refs,\n        history = this.props.history;\n\n    history._onTransitionComplete();\n    refs.unlisten = history.listen(function () {\n      Promise.resolve().then(function () {\n        // TODO: replace rAF with react deferred update API when it's ready https://github.com/facebook/react/issues/13306\n        requestAnimationFrame(function () {\n          if (!_this2.unmounted) {\n            _this2.setState(function () {\n              return { context: _this2.getContext() };\n            });\n          }\n        });\n      });\n    });\n  };\n\n  LocationProvider.prototype.componentWillUnmount = function componentWillUnmount() {\n    var refs = this.state.refs;\n\n    this.unmounted = true;\n    refs.unlisten();\n  };\n\n  LocationProvider.prototype.render = function render() {\n    var context = this.state.context,\n        children = this.props.children;\n\n    return React.createElement(\n      LocationContext.Provider,\n      { value: context },\n      typeof children === \"function\" ? children(context) : children || null\n    );\n  };\n\n  return LocationProvider;\n}(React.Component);\n\n////////////////////////////////////////////////////////////////////////////////\n\n\nLocationProvider.defaultProps = {\n  history: globalHistory\n};\nprocess.env.NODE_ENV !== \"production\" ? LocationProvider.propTypes = {\n  history: PropTypes.object.isRequired\n} : void 0;\nvar ServerLocation = function ServerLocation(_ref2) {\n  var url = _ref2.url,\n      children = _ref2.children;\n\n  var searchIndex = url.indexOf(\"?\");\n  var searchExists = searchIndex > -1;\n  var pathname = void 0;\n  var search = \"\";\n  var hash = \"\";\n\n  if (searchExists) {\n    pathname = url.substring(0, searchIndex);\n    search = url.substring(searchIndex);\n  } else {\n    pathname = url;\n  }\n\n  return React.createElement(\n    LocationContext.Provider,\n    {\n      value: {\n        location: {\n          pathname: pathname,\n          search: search,\n          hash: hash\n        },\n        navigate: function navigate() {\n          throw new Error(\"You can't call navigate on the server.\");\n        }\n      }\n    },\n    children\n  );\n};\n////////////////////////////////////////////////////////////////////////////////\n// Sets baseuri and basepath for nested routers and links\nvar BaseContext = createNamedContext(\"Base\", { baseuri: \"/\", basepath: \"/\" });\n\n////////////////////////////////////////////////////////////////////////////////\n// The main event, welcome to the show everybody.\nvar Router = function Router(props) {\n  return React.createElement(\n    BaseContext.Consumer,\n    null,\n    function (baseContext) {\n      return React.createElement(\n        Location,\n        null,\n        function (locationContext) {\n          return React.createElement(RouterImpl, _extends({}, baseContext, locationContext, props));\n        }\n      );\n    }\n  );\n};\n\nvar RouterImpl = function (_React$PureComponent) {\n  _inherits(RouterImpl, _React$PureComponent);\n\n  function RouterImpl() {\n    _classCallCheck(this, RouterImpl);\n\n    return _possibleConstructorReturn(this, _React$PureComponent.apply(this, arguments));\n  }\n\n  RouterImpl.prototype.render = function render() {\n    var _props = this.props,\n        location = _props.location,\n        _navigate2 = _props.navigate,\n        basepath = _props.basepath,\n        primary = _props.primary,\n        children = _props.children,\n        baseuri = _props.baseuri,\n        _props$component = _props.component,\n        component = _props$component === undefined ? \"div\" : _props$component,\n        domProps = _objectWithoutProperties(_props, [\"location\", \"navigate\", \"basepath\", \"primary\", \"children\", \"baseuri\", \"component\"]);\n\n    var routes = React.Children.toArray(children).reduce(function (array, child) {\n      var routes = createRoute(basepath)(child);\n      return array.concat(routes);\n    }, []);\n    var pathname = location.pathname;\n\n\n    var match = pick(routes, pathname);\n\n    if (match) {\n      var params = match.params,\n          uri = match.uri,\n          route = match.route,\n          element = match.route.value;\n\n      // remove the /* from the end for child routes relative paths\n\n      basepath = route.default ? basepath : route.path.replace(/\\*$/, \"\");\n\n      var props = _extends({}, params, {\n        uri: uri,\n        location: location,\n        navigate: function navigate(to, options) {\n          return _navigate2(resolve(to, uri), options);\n        }\n      });\n\n      var clone = React.cloneElement(element, props, element.props.children ? React.createElement(\n        Router,\n        { location: location, primary: primary },\n        element.props.children\n      ) : undefined);\n\n      // using 'div' for < 16.3 support\n      var FocusWrapper = primary ? FocusHandler : component;\n      // don't pass any props to 'div'\n      var wrapperProps = primary ? _extends({ uri: uri, location: location, component: component }, domProps) : domProps;\n\n      return React.createElement(\n        BaseContext.Provider,\n        { value: { baseuri: uri, basepath: basepath } },\n        React.createElement(\n          FocusWrapper,\n          wrapperProps,\n          clone\n        )\n      );\n    } else {\n      // Not sure if we want this, would require index routes at every level\n      // warning(\n      //   false,\n      //   `<Router basepath=\"${basepath}\">\\n\\nNothing matched:\\n\\t${\n      //     location.pathname\n      //   }\\n\\nPaths checked: \\n\\t${routes\n      //     .map(route => route.path)\n      //     .join(\n      //       \"\\n\\t\"\n      //     )}\\n\\nTo get rid of this warning, add a default NotFound component as child of Router:\n      //   \\n\\tlet NotFound = () => <div>Not Found!</div>\n      //   \\n\\t<Router>\\n\\t  <NotFound default/>\\n\\t  {/* ... */}\\n\\t</Router>`\n      // );\n      return null;\n    }\n  };\n\n  return RouterImpl;\n}(React.PureComponent);\n\nRouterImpl.defaultProps = {\n  primary: true\n};\n\n\nvar FocusContext = createNamedContext(\"Focus\");\n\nvar FocusHandler = function FocusHandler(_ref3) {\n  var uri = _ref3.uri,\n      location = _ref3.location,\n      component = _ref3.component,\n      domProps = _objectWithoutProperties(_ref3, [\"uri\", \"location\", \"component\"]);\n\n  return React.createElement(\n    FocusContext.Consumer,\n    null,\n    function (requestFocus) {\n      return React.createElement(FocusHandlerImpl, _extends({}, domProps, {\n        component: component,\n        requestFocus: requestFocus,\n        uri: uri,\n        location: location\n      }));\n    }\n  );\n};\n\n// don't focus on initial render\nvar initialRender = true;\nvar focusHandlerCount = 0;\n\nvar FocusHandlerImpl = function (_React$Component2) {\n  _inherits(FocusHandlerImpl, _React$Component2);\n\n  function FocusHandlerImpl() {\n    var _temp2, _this4, _ret2;\n\n    _classCallCheck(this, FocusHandlerImpl);\n\n    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    return _ret2 = (_temp2 = (_this4 = _possibleConstructorReturn(this, _React$Component2.call.apply(_React$Component2, [this].concat(args))), _this4), _this4.state = {}, _this4.requestFocus = function (node) {\n      if (!_this4.state.shouldFocus && node) {\n        node.focus();\n      }\n    }, _temp2), _possibleConstructorReturn(_this4, _ret2);\n  }\n\n  FocusHandlerImpl.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n    var initial = prevState.uri == null;\n    if (initial) {\n      return _extends({\n        shouldFocus: true\n      }, nextProps);\n    } else {\n      var myURIChanged = nextProps.uri !== prevState.uri;\n      var navigatedUpToMe = prevState.location.pathname !== nextProps.location.pathname && nextProps.location.pathname === nextProps.uri;\n      return _extends({\n        shouldFocus: myURIChanged || navigatedUpToMe\n      }, nextProps);\n    }\n  };\n\n  FocusHandlerImpl.prototype.componentDidMount = function componentDidMount() {\n    focusHandlerCount++;\n    this.focus();\n  };\n\n  FocusHandlerImpl.prototype.componentWillUnmount = function componentWillUnmount() {\n    focusHandlerCount--;\n    if (focusHandlerCount === 0) {\n      initialRender = true;\n    }\n  };\n\n  FocusHandlerImpl.prototype.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n    if (prevProps.location !== this.props.location && this.state.shouldFocus) {\n      this.focus();\n    }\n  };\n\n  FocusHandlerImpl.prototype.focus = function focus() {\n    if (process.env.NODE_ENV === \"test\") {\n      // getting cannot read property focus of null in the tests\n      // and that bit of global `initialRender` state causes problems\n      // should probably figure it out!\n      return;\n    }\n\n    var requestFocus = this.props.requestFocus;\n\n\n    if (requestFocus) {\n      requestFocus(this.node);\n    } else {\n      if (initialRender) {\n        initialRender = false;\n      } else if (this.node) {\n        // React polyfills [autofocus] and it fires earlier than cDM,\n        // so we were stealing focus away, this line prevents that.\n        if (!this.node.contains(document.activeElement)) {\n          this.node.focus();\n        }\n      }\n    }\n  };\n\n  FocusHandlerImpl.prototype.render = function render() {\n    var _this5 = this;\n\n    var _props2 = this.props,\n        children = _props2.children,\n        style = _props2.style,\n        requestFocus = _props2.requestFocus,\n        _props2$component = _props2.component,\n        Comp = _props2$component === undefined ? \"div\" : _props2$component,\n        uri = _props2.uri,\n        location = _props2.location,\n        domProps = _objectWithoutProperties(_props2, [\"children\", \"style\", \"requestFocus\", \"component\", \"uri\", \"location\"]);\n\n    return React.createElement(\n      Comp,\n      _extends({\n        style: _extends({ outline: \"none\" }, style),\n        tabIndex: \"-1\",\n        ref: function ref(n) {\n          return _this5.node = n;\n        }\n      }, domProps),\n      React.createElement(\n        FocusContext.Provider,\n        { value: this.requestFocus },\n        this.props.children\n      )\n    );\n  };\n\n  return FocusHandlerImpl;\n}(React.Component);\n\npolyfill(FocusHandlerImpl);\n\nvar k = function k() {};\n\n////////////////////////////////////////////////////////////////////////////////\nvar forwardRef = React.forwardRef;\n\nif (typeof forwardRef === \"undefined\") {\n  forwardRef = function forwardRef(C) {\n    return C;\n  };\n}\n\nvar Link = forwardRef(function (_ref4, ref) {\n  var innerRef = _ref4.innerRef,\n      props = _objectWithoutProperties(_ref4, [\"innerRef\"]);\n\n  return React.createElement(\n    BaseContext.Consumer,\n    null,\n    function (_ref5) {\n      var basepath = _ref5.basepath,\n          baseuri = _ref5.baseuri;\n      return React.createElement(\n        Location,\n        null,\n        function (_ref6) {\n          var location = _ref6.location,\n              navigate = _ref6.navigate;\n\n          var to = props.to,\n              state = props.state,\n              replace = props.replace,\n              _props$getProps = props.getProps,\n              getProps = _props$getProps === undefined ? k : _props$getProps,\n              anchorProps = _objectWithoutProperties(props, [\"to\", \"state\", \"replace\", \"getProps\"]);\n\n          var href = resolve(to, baseuri);\n          var encodedHref = encodeURI(href);\n          var isCurrent = location.pathname === encodedHref;\n          var isPartiallyCurrent = startsWith(location.pathname, encodedHref);\n\n          return React.createElement(\"a\", _extends({\n            ref: ref || innerRef,\n            \"aria-current\": isCurrent ? \"page\" : undefined\n          }, anchorProps, getProps({ isCurrent: isCurrent, isPartiallyCurrent: isPartiallyCurrent, href: href, location: location }), {\n            href: href,\n            onClick: function onClick(event) {\n              if (anchorProps.onClick) anchorProps.onClick(event);\n              if (shouldNavigate(event)) {\n                event.preventDefault();\n                var shouldReplace = replace;\n                if (typeof replace !== \"boolean\" && isCurrent) {\n                  var _location$state = _extends({}, location.state),\n                      key = _location$state.key,\n                      restState = _objectWithoutProperties(_location$state, [\"key\"]);\n\n                  shouldReplace = shallowCompare(_extends({}, state), restState);\n                }\n                navigate(href, {\n                  state: state,\n                  replace: shouldReplace\n                });\n              }\n            }\n          }));\n        }\n      );\n    }\n  );\n});\n\nLink.displayName = \"Link\";\n\nprocess.env.NODE_ENV !== \"production\" ? Link.propTypes = {\n  to: PropTypes.string.isRequired\n} : void 0;\n\n////////////////////////////////////////////////////////////////////////////////\nfunction RedirectRequest(uri) {\n  this.uri = uri;\n}\n\nvar isRedirect = function isRedirect(o) {\n  return o instanceof RedirectRequest;\n};\n\nvar redirectTo = function redirectTo(to) {\n  throw new RedirectRequest(to);\n};\n\nvar RedirectImpl = function (_React$Component3) {\n  _inherits(RedirectImpl, _React$Component3);\n\n  function RedirectImpl() {\n    _classCallCheck(this, RedirectImpl);\n\n    return _possibleConstructorReturn(this, _React$Component3.apply(this, arguments));\n  }\n\n  // Support React < 16 with this hook\n  RedirectImpl.prototype.componentDidMount = function componentDidMount() {\n    var _props3 = this.props,\n        navigate = _props3.navigate,\n        to = _props3.to,\n        from = _props3.from,\n        _props3$replace = _props3.replace,\n        replace = _props3$replace === undefined ? true : _props3$replace,\n        state = _props3.state,\n        noThrow = _props3.noThrow,\n        baseuri = _props3.baseuri,\n        props = _objectWithoutProperties(_props3, [\"navigate\", \"to\", \"from\", \"replace\", \"state\", \"noThrow\", \"baseuri\"]);\n\n    Promise.resolve().then(function () {\n      var resolvedTo = resolve(to, baseuri);\n      navigate(insertParams(resolvedTo, props), { replace: replace, state: state });\n    });\n  };\n\n  RedirectImpl.prototype.render = function render() {\n    var _props4 = this.props,\n        navigate = _props4.navigate,\n        to = _props4.to,\n        from = _props4.from,\n        replace = _props4.replace,\n        state = _props4.state,\n        noThrow = _props4.noThrow,\n        baseuri = _props4.baseuri,\n        props = _objectWithoutProperties(_props4, [\"navigate\", \"to\", \"from\", \"replace\", \"state\", \"noThrow\", \"baseuri\"]);\n\n    var resolvedTo = resolve(to, baseuri);\n    if (!noThrow) redirectTo(insertParams(resolvedTo, props));\n    return null;\n  };\n\n  return RedirectImpl;\n}(React.Component);\n\nvar Redirect = function Redirect(props) {\n  return React.createElement(\n    BaseContext.Consumer,\n    null,\n    function (_ref7) {\n      var baseuri = _ref7.baseuri;\n      return React.createElement(\n        Location,\n        null,\n        function (locationContext) {\n          return React.createElement(RedirectImpl, _extends({}, locationContext, { baseuri: baseuri }, props));\n        }\n      );\n    }\n  );\n};\n\nprocess.env.NODE_ENV !== \"production\" ? Redirect.propTypes = {\n  from: PropTypes.string,\n  to: PropTypes.string.isRequired\n} : void 0;\n\n////////////////////////////////////////////////////////////////////////////////\nvar Match = function Match(_ref8) {\n  var path = _ref8.path,\n      children = _ref8.children;\n  return React.createElement(\n    BaseContext.Consumer,\n    null,\n    function (_ref9) {\n      var baseuri = _ref9.baseuri;\n      return React.createElement(\n        Location,\n        null,\n        function (_ref10) {\n          var navigate = _ref10.navigate,\n              location = _ref10.location;\n\n          var resolvedPath = resolve(path, baseuri);\n          var result = match(resolvedPath, location.pathname);\n          return children({\n            navigate: navigate,\n            location: location,\n            match: result ? _extends({}, result.params, {\n              uri: result.uri,\n              path: path\n            }) : null\n          });\n        }\n      );\n    }\n  );\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Hooks\n\nvar useLocation = function useLocation() {\n  var context = useContext(LocationContext);\n\n  if (!context) {\n    throw new Error(\"useLocation hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n  }\n\n  return context.location;\n};\n\nvar useNavigate = function useNavigate() {\n  var context = useContext(LocationContext);\n\n  if (!context) {\n    throw new Error(\"useNavigate hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n  }\n\n  return context.navigate;\n};\n\nvar useParams = function useParams() {\n  var context = useContext(BaseContext);\n\n  if (!context) {\n    throw new Error(\"useParams hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n  }\n\n  var location = useLocation();\n\n  var results = match(context.basepath, location.pathname);\n\n  return results ? results.params : null;\n};\n\nvar useMatch = function useMatch(path) {\n  if (!path) {\n    throw new Error(\"useMatch(path: string) requires an argument of a string to match against\");\n  }\n  var context = useContext(BaseContext);\n\n  if (!context) {\n    throw new Error(\"useMatch hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n  }\n\n  var location = useLocation();\n\n  var resolvedPath = resolve(path, context.baseuri);\n  var result = match(resolvedPath, location.pathname);\n  return result ? _extends({}, result.params, {\n    uri: result.uri,\n    path: path\n  }) : null;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Junk\nvar stripSlashes = function stripSlashes(str) {\n  return str.replace(/(^\\/+|\\/+$)/g, \"\");\n};\n\nvar createRoute = function createRoute(basepath) {\n  return function (element) {\n    if (!element) {\n      return null;\n    }\n\n    if (element.type === React.Fragment && element.props.children) {\n      return React.Children.map(element.props.children, createRoute(basepath));\n    }\n    !(element.props.path || element.props.default || element.type === Redirect) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Router>: Children of <Router> must have a `path` or `default` prop, or be a `<Redirect>`. None found on element type `\" + element.type + \"`\") : invariant(false) : void 0;\n\n    !!(element.type === Redirect && (!element.props.from || !element.props.to)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Redirect from=\\\"\" + element.props.from + \"\\\" to=\\\"\" + element.props.to + \"\\\"/> requires both \\\"from\\\" and \\\"to\\\" props when inside a <Router>.\") : invariant(false) : void 0;\n\n    !!(element.type === Redirect && !validateRedirect(element.props.from, element.props.to)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Redirect from=\\\"\" + element.props.from + \" to=\\\"\" + element.props.to + \"\\\"/> has mismatched dynamic segments, ensure both paths have the exact same dynamic segments.\") : invariant(false) : void 0;\n\n    if (element.props.default) {\n      return { value: element, default: true };\n    }\n\n    var elementPath = element.type === Redirect ? element.props.from : element.props.path;\n\n    var path = elementPath === \"/\" ? basepath : stripSlashes(basepath) + \"/\" + stripSlashes(elementPath);\n\n    return {\n      value: element,\n      default: element.props.default,\n      path: element.props.children ? stripSlashes(path) + \"/*\" : path\n    };\n  };\n};\n\nvar shouldNavigate = function shouldNavigate(event) {\n  return !event.defaultPrevented && event.button === 0 && !(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n};\n\n////////////////////////////////////////////////////////////////////////\nexport {  Link, Location, LocationProvider, Match, Redirect, Router, ServerLocation, createHistory, createMemorySource, isRedirect, navigate, redirectTo, globalHistory, match as matchPath, useLocation, useNavigate, useParams, useMatch , BaseContext };","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 = /*#__PURE__*/_curry3(_reduce);\n\nexport default reduce;","import _curry1 from \"./internal/_curry1.js\";\nimport _isNumber from \"./internal/_isNumber.js\";\n/**\n * Returns the number of elements in the array by returning `list.length`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [a] -> Number\n * @param {Array} list The array to inspect.\n * @return {Number} The length of the array.\n * @example\n *\n *      R.length([]); //=> 0\n *      R.length([1, 2, 3]); //=> 3\n */\n\nvar length = /*#__PURE__*/_curry1(function length(list) {\n  return list != null && _isNumber(list.length) ? list.length : NaN;\n});\n\nexport default length;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Makes a descending comparator function out of a function that returns a value\n * that can be compared with `<` and `>`.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Function\n * @sig Ord b => (a -> b) -> a -> a -> Number\n * @param {Function} fn A function of arity one that returns a value that can be compared\n * @param {*} a The first item to be compared.\n * @param {*} b The second item to be compared.\n * @return {Number} `-1` if fn(a) > fn(b), `1` if fn(b) > fn(a), otherwise `0`\n * @see R.ascend\n * @example\n *\n *      const byAge = R.descend(R.prop('age'));\n *      const people = [\n *        { name: 'Emma', age: 70 },\n *        { name: 'Peter', age: 78 },\n *        { name: 'Mikhail', age: 62 },\n *      ];\n *      const peopleByOldestFirst = R.sort(byAge, people);\n *        //=> [{ name: 'Peter', age: 78 }, { name: 'Emma', age: 70 }, { name: 'Mikhail', age: 62 }]\n */\n\nvar descend = /*#__PURE__*/_curry3(function descend(fn, a, b) {\n  var aa = fn(a);\n  var bb = fn(b);\n  return aa > bb ? -1 : aa < bb ? 1 : 0;\n});\n\nexport default descend;","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};","var toInteger = require('../internals/to-integer');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `String.prototype.{ codePointAt, at }` methods implementation\nvar createMethod = function (CONVERT_TO_STRING) {\n  return function ($this, pos) {\n    var S = String(requireObjectCoercible($this));\n    var position = toInteger(pos);\n    var size = S.length;\n    var first, second;\n    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n    first = S.charCodeAt(position);\n    return first < 0xD800 || first > 0xDBFF || position + 1 === size\n      || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF\n        ? CONVERT_TO_STRING ? S.charAt(position) : first\n        : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.codePointAt` method\n  // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n  codeAt: createMethod(false),\n  // `String.prototype.at` method\n  // https://github.com/mathiasbynens/String.prototype.at\n  charAt: createMethod(true)\n};\n","import _curry2 from \"./internal/_curry2.js\";\nimport _has from \"./internal/_has.js\";\nimport isNil from \"./isNil.js\";\n/**\n * Returns whether or not a path exists in an object. Only the object's\n * own properties are checked.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {a} -> Boolean\n * @param {Array} path The path to use.\n * @param {Object} obj The object to check the path in.\n * @return {Boolean} Whether the path exists.\n * @see R.has\n * @example\n *\n *      R.hasPath(['a', 'b'], {a: {b: 2}});         // => true\n *      R.hasPath(['a', 'b'], {a: {b: undefined}}); // => true\n *      R.hasPath(['a', 'b'], {a: {c: 2}});         // => false\n *      R.hasPath(['a', 'b'], {});                  // => false\n */\n\nvar hasPath = /*#__PURE__*/_curry2(function hasPath(_path, obj) {\n  if (_path.length === 0 || isNil(obj)) {\n    return false;\n  }\n\n  var val = obj;\n  var idx = 0;\n\n  while (idx < _path.length) {\n    if (!isNil(val) && _has(_path[idx], val)) {\n      val = val[_path[idx]];\n      idx += 1;\n    } else {\n      return false;\n    }\n  }\n\n  return true;\n});\n\nexport default hasPath;","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 = ! /*#__PURE__*/{\n  toString: null\n}.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; // Safari bug\n\nvar hasArgsEnumBug = /*#__PURE__*/function () {\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\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 ? /*#__PURE__*/_curry1(function keys(obj) {\n  return Object(obj) !== obj ? [] : Object.keys(obj);\n}) : /*#__PURE__*/_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 _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 = /*#__PURE__*/_curry3( /*#__PURE__*/_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n\nexport default slice;","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar objectHas = require('../internals/has');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = store.get;\n  var wmhas = store.has;\n  var wmset = store.set;\n  set = function (it, metadata) {\n    if (wmhas.call(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    wmset.call(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget.call(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas.call(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    if (objectHas(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return objectHas(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return objectHas(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","export default function _isObject(x) {\n  return Object.prototype.toString.call(x) === '[object Object]';\n}","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  var state;\n  if (typeof value == 'function') {\n    if (typeof key == 'string' && !has(value, 'name')) {\n      createNonEnumerableProperty(value, 'name', key);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof key == 'string' ? key : '');\n    }\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n});\n","import _has from \"./_has.js\";\nvar toString = Object.prototype.toString;\n\nvar _isArguments = /*#__PURE__*/function () {\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;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    module.exports = _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  } else {\n    module.exports = _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n\n    module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  }\n\n  return _typeof(obj);\n}\n\nmodule.exports = _typeof;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Similar to `pick` except that this one includes a `key: undefined` pair for\n * properties that don't exist.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> {k: v}\n * @param {Array} names an array of String property names to copy onto a new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties from `names` on it.\n * @see R.pick\n * @example\n *\n *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n */\n\nvar pickAll = /*#__PURE__*/_curry2(function pickAll(names, obj) {\n  var result = {};\n  var idx = 0;\n  var len = names.length;\n\n  while (idx < len) {\n    var name = names[idx];\n    result[name] = obj[name];\n    idx += 1;\n  }\n\n  return result;\n});\n\nexport default pickAll;","/**\n * Remove a prefix from a string. Return the input string if the given prefix\n * isn't found.\n */\n\nexport default function stripPrefix(str, prefix = ``) {\n  if (!prefix) {\n    return str\n  }\n\n  if (str === prefix) {\n    return `/`\n  }\n\n  if (str.startsWith(`${prefix}/`)) {\n    return str.slice(prefix.length)\n  }\n\n  return str\n}\n","\"use strict\";\n\nexports.__esModule = true;\nexports.parsePath = parsePath;\n\nfunction parsePath(path) {\n  var pathname = path || \"/\";\n  var search = \"\";\n  var hash = \"\";\n  var hashIndex = pathname.indexOf(\"#\");\n\n  if (hashIndex !== -1) {\n    hash = pathname.substr(hashIndex);\n    pathname = pathname.substr(0, hashIndex);\n  }\n\n  var searchIndex = pathname.indexOf(\"?\");\n\n  if (searchIndex !== -1) {\n    search = pathname.substr(searchIndex);\n    pathname = pathname.substr(0, searchIndex);\n  }\n\n  return {\n    pathname: pathname,\n    search: search === \"?\" ? \"\" : search,\n    hash: hash === \"#\" ? \"\" : hash\n  };\n}","// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","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 \"./internal/_curry2.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport _isString from \"./internal/_isString.js\";\nimport toString from \"./toString.js\";\n/**\n * Returns the result of concatenating the given lists or strings.\n *\n * Note: `R.concat` expects both arguments to be of the same type,\n * unlike the native `Array.prototype.concat` method. It will throw\n * an error if you `concat` an Array with a non-Array value.\n *\n * Dispatches to the `concat` method of the first argument, if present.\n * Can also concatenate two members of a [fantasy-land\n * compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a] -> [a]\n * @sig String -> String -> String\n * @param {Array|String} firstList The first list\n * @param {Array|String} secondList The second list\n * @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of\n * `secondList`.\n *\n * @example\n *\n *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n *      R.concat([], []); //=> []\n */\n\nvar concat = /*#__PURE__*/_curry2(function concat(a, b) {\n  if (_isArray(a)) {\n    if (_isArray(b)) {\n      return a.concat(b);\n    }\n\n    throw new TypeError(toString(b) + ' is not an array');\n  }\n\n  if (_isString(a)) {\n    if (_isString(b)) {\n      return a + b;\n    }\n\n    throw new TypeError(toString(b) + ' is not a string');\n  }\n\n  if (a != null && _isFunction(a['fantasy-land/concat'])) {\n    return a['fantasy-land/concat'](b);\n  }\n\n  if (a != null && _isFunction(a.concat)) {\n    return a.concat(b);\n  }\n\n  throw new TypeError(toString(a) + ' does not have a method named \"concat\" or \"fantasy-land/concat\"');\n});\n\nexport default concat;","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}","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 comparision 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 (a == null || b == null) {\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 = /*#__PURE__*/_curry2(function equals(a, b) {\n  return _equals(a, b, [], []);\n});\n\nexport default equals;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value. Note that this copies and flattens prototype\n * properties onto the new object as well. All non-primitive properties are\n * copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @sig String -> a -> {k: v} -> {k: v}\n * @param {String} prop The property name to set\n * @param {*} val The new value\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original except for the changed property.\n * @see R.dissoc, R.pick\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\n\nvar assoc = /*#__PURE__*/_curry3(function assoc(prop, val, obj) {\n  var result = {};\n\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n\n  result[prop] = val;\n  return result;\n});\n\nexport default assoc;","import _Set from \"./internal/_Set.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list containing only one copy of each element in the original\n * list, based upon the value returned by applying the supplied function to\n * each list element. Prefers the first item if the supplied function produces\n * the same value on two items. [`R.equals`](#equals) is used for comparison.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> b) -> [a] -> [a]\n * @param {Function} fn A function used to produce a value to use during comparisons.\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n */\n\nvar uniqBy = /*#__PURE__*/_curry2(function uniqBy(fn, list) {\n  var set = new _Set();\n  var result = [];\n  var idx = 0;\n  var appliedItem, item;\n\n  while (idx < list.length) {\n    item = list[idx];\n    appliedItem = fn(item);\n\n    if (set.add(appliedItem)) {\n      result.push(item);\n    }\n\n    idx += 1;\n  }\n\n  return result;\n});\n\nexport default uniqBy;","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","const support = function (feature) {\n  if (typeof document === `undefined`) {\n    return false\n  }\n  const fakeLink = document.createElement(`link`)\n  try {\n    if (fakeLink.relList && typeof fakeLink.relList.supports === `function`) {\n      return fakeLink.relList.supports(feature)\n    }\n  } catch (err) {\n    return false\n  }\n  return false\n}\n\nconst linkPrefetchStrategy = function (url, options) {\n  return new Promise((resolve, reject) => {\n    if (typeof document === `undefined`) {\n      reject()\n      return\n    }\n\n    const link = document.createElement(`link`)\n    link.setAttribute(`rel`, `prefetch`)\n    link.setAttribute(`href`, url)\n\n    Object.keys(options).forEach(key => {\n      link.setAttribute(key, options[key])\n    })\n\n    link.onload = resolve\n    link.onerror = reject\n\n    const parentElement =\n      document.getElementsByTagName(`head`)[0] ||\n      document.getElementsByName(`script`)[0].parentNode\n    parentElement.appendChild(link)\n  })\n}\n\nconst xhrPrefetchStrategy = function (url) {\n  return new Promise((resolve, reject) => {\n    const req = new XMLHttpRequest()\n    req.open(`GET`, url, true)\n\n    req.onload = () => {\n      if (req.status === 200) {\n        resolve()\n      } else {\n        reject()\n      }\n    }\n\n    req.send(null)\n  })\n}\n\nconst supportedPrefetchStrategy = support(`prefetch`)\n  ? linkPrefetchStrategy\n  : xhrPrefetchStrategy\n\nconst preFetched = {}\n\nconst prefetch = function (url, options) {\n  return new Promise(resolve => {\n    if (preFetched[url]) {\n      resolve()\n      return\n    }\n\n    supportedPrefetchStrategy(url, options)\n      .then(() => {\n        resolve()\n        preFetched[url] = true\n      })\n      .catch(() => {}) // 404s are logged to the console anyway\n  })\n}\n\nexport default prefetch\n","import prefetchHelper from \"./prefetch\"\nimport emitter from \"./emitter\"\nimport { setMatchPaths, findPath, findMatchPath } from \"./find-path\"\n\n/**\n * Available resource loading statuses\n */\nexport const PageResourceStatus = {\n  /**\n   * At least one of critical resources failed to load\n   */\n  Error: `error`,\n  /**\n   * Resources loaded successfully\n   */\n  Success: `success`,\n}\n\nconst preferDefault = m => (m && m.default) || m\n\nconst stripSurroundingSlashes = s => {\n  s = s[0] === `/` ? s.slice(1) : s\n  s = s.endsWith(`/`) ? s.slice(0, -1) : s\n  return s\n}\n\nconst createPageDataUrl = path => {\n  const fixedPath = path === `/` ? `index` : stripSurroundingSlashes(path)\n  return `${__PATH_PREFIX__}/page-data/${fixedPath}/page-data.json`\n}\n\nfunction doFetch(url, method = `GET`) {\n  return new Promise((resolve, reject) => {\n    const req = new XMLHttpRequest()\n    req.open(method, url, true)\n    req.onreadystatechange = () => {\n      if (req.readyState == 4) {\n        resolve(req)\n      }\n    }\n    req.send(null)\n  })\n}\n\nconst doesConnectionSupportPrefetch = () => {\n  if (\n    `connection` in navigator &&\n    typeof navigator.connection !== `undefined`\n  ) {\n    if ((navigator.connection.effectiveType || ``).includes(`2g`)) {\n      return false\n    }\n    if (navigator.connection.saveData) {\n      return false\n    }\n  }\n  return true\n}\n\nconst toPageResources = (pageData, component = null) => {\n  const page = {\n    componentChunkName: pageData.componentChunkName,\n    path: pageData.path,\n    webpackCompilationHash: pageData.webpackCompilationHash,\n    matchPath: pageData.matchPath,\n    staticQueryHashes: pageData.staticQueryHashes,\n  }\n\n  return {\n    component,\n    json: pageData.result,\n    page,\n  }\n}\n\nexport class BaseLoader {\n  constructor(loadComponent, matchPaths) {\n    // Map of pagePath -> Page. Where Page is an object with: {\n    //   status: PageResourceStatus.Success || PageResourceStatus.Error,\n    //   payload: PageResources, // undefined if PageResourceStatus.Error\n    // }\n    // PageResources is {\n    //   component,\n    //   json: pageData.result,\n    //   page: {\n    //     componentChunkName,\n    //     path,\n    //     webpackCompilationHash,\n    //     staticQueryHashes\n    //   },\n    //   staticQueryResults\n    // }\n    this.pageDb = new Map()\n    this.inFlightDb = new Map()\n    this.staticQueryDb = {}\n    this.pageDataDb = new Map()\n    this.prefetchTriggered = new Set()\n    this.prefetchCompleted = new Set()\n    this.loadComponent = loadComponent\n    setMatchPaths(matchPaths)\n  }\n\n  inFlightNetworkRequests = new Map()\n\n  memoizedGet(url) {\n    let inFlightPromise = this.inFlightNetworkRequests.get(url)\n\n    if (!inFlightPromise) {\n      inFlightPromise = doFetch(url, `GET`)\n      this.inFlightNetworkRequests.set(url, inFlightPromise)\n    }\n\n    // Prefer duplication with then + catch over .finally to prevent problems in ie11 + firefox\n    return inFlightPromise\n      .then(response => {\n        this.inFlightNetworkRequests.delete(url)\n        return response\n      })\n      .catch(err => {\n        this.inFlightNetworkRequests.delete(url)\n        throw err\n      })\n  }\n\n  setApiRunner(apiRunner) {\n    this.apiRunner = apiRunner\n    this.prefetchDisabled = apiRunner(`disableCorePrefetching`).some(a => a)\n  }\n\n  fetchPageDataJson(loadObj) {\n    const { pagePath, retries = 0 } = loadObj\n    const url = createPageDataUrl(pagePath)\n    return this.memoizedGet(url).then(req => {\n      const { status, responseText } = req\n\n      // Handle 200\n      if (status === 200) {\n        try {\n          const jsonPayload = JSON.parse(responseText)\n          if (jsonPayload.path === undefined) {\n            throw new Error(`not a valid pageData response`)\n          }\n\n          return Object.assign(loadObj, {\n            status: PageResourceStatus.Success,\n            payload: jsonPayload,\n          })\n        } catch (err) {\n          // continue regardless of error\n        }\n      }\n\n      // Handle 404\n      if (status === 404 || status === 200) {\n        // If the request was for a 404 page and it doesn't exist, we're done\n        if (pagePath === `/404.html`) {\n          return Object.assign(loadObj, {\n            status: PageResourceStatus.Error,\n          })\n        }\n\n        // Need some code here to cache the 404 request. In case\n        // multiple loadPageDataJsons result in 404s\n        return this.fetchPageDataJson(\n          Object.assign(loadObj, { pagePath: `/404.html`, notFound: true })\n        )\n      }\n\n      // handle 500 response (Unrecoverable)\n      if (status === 500) {\n        return Object.assign(loadObj, {\n          status: PageResourceStatus.Error,\n        })\n      }\n\n      // Handle everything else, including status === 0, and 503s. Should retry\n      if (retries < 3) {\n        return this.fetchPageDataJson(\n          Object.assign(loadObj, { retries: retries + 1 })\n        )\n      }\n\n      // Retried 3 times already, result is an error.\n      return Object.assign(loadObj, {\n        status: PageResourceStatus.Error,\n      })\n    })\n  }\n\n  loadPageDataJson(rawPath) {\n    const pagePath = findPath(rawPath)\n    if (this.pageDataDb.has(pagePath)) {\n      const pageData = this.pageDataDb.get(pagePath)\n      if (process.env.BUILD_STAGE !== `develop` || !pageData.stale) {\n        return Promise.resolve(pageData)\n      }\n    }\n\n    return this.fetchPageDataJson({ pagePath }).then(pageData => {\n      this.pageDataDb.set(pagePath, pageData)\n\n      return pageData\n    })\n  }\n\n  findMatchPath(rawPath) {\n    return findMatchPath(rawPath)\n  }\n\n  // TODO check all uses of this and whether they use undefined for page resources not exist\n  loadPage(rawPath) {\n    const pagePath = findPath(rawPath)\n    if (this.pageDb.has(pagePath)) {\n      const page = this.pageDb.get(pagePath)\n      if (process.env.BUILD_STAGE !== `develop` || !page.payload.stale) {\n        return Promise.resolve(page.payload)\n      }\n    }\n\n    if (this.inFlightDb.has(pagePath)) {\n      return this.inFlightDb.get(pagePath)\n    }\n\n    const inFlightPromise = Promise.all([\n      this.loadAppData(),\n      this.loadPageDataJson(pagePath),\n    ]).then(allData => {\n      const result = allData[1]\n      if (result.status === PageResourceStatus.Error) {\n        return {\n          status: PageResourceStatus.Error,\n        }\n      }\n\n      let pageData = result.payload\n      const { componentChunkName, staticQueryHashes = [] } = pageData\n\n      const finalResult = {}\n\n      const componentChunkPromise = this.loadComponent(componentChunkName).then(\n        component => {\n          finalResult.createdAt = new Date()\n          let pageResources\n          if (!component) {\n            finalResult.status = PageResourceStatus.Error\n          } else {\n            finalResult.status = PageResourceStatus.Success\n            if (result.notFound === true) {\n              finalResult.notFound = true\n            }\n            pageData = Object.assign(pageData, {\n              webpackCompilationHash: allData[0]\n                ? allData[0].webpackCompilationHash\n                : ``,\n            })\n            pageResources = toPageResources(pageData, component)\n          }\n          // undefined if final result is an error\n          return pageResources\n        }\n      )\n\n      const staticQueryBatchPromise = Promise.all(\n        staticQueryHashes.map(staticQueryHash => {\n          // Check for cache in case this static query result has already been loaded\n          if (this.staticQueryDb[staticQueryHash]) {\n            const jsonPayload = this.staticQueryDb[staticQueryHash]\n            return { staticQueryHash, jsonPayload }\n          }\n\n          return this.memoizedGet(\n            `${__PATH_PREFIX__}/page-data/sq/d/${staticQueryHash}.json`\n          ).then(req => {\n            const jsonPayload = JSON.parse(req.responseText)\n            return { staticQueryHash, jsonPayload }\n          })\n        })\n      ).then(staticQueryResults => {\n        const staticQueryResultsMap = {}\n\n        staticQueryResults.forEach(({ staticQueryHash, jsonPayload }) => {\n          staticQueryResultsMap[staticQueryHash] = jsonPayload\n          this.staticQueryDb[staticQueryHash] = jsonPayload\n        })\n\n        return staticQueryResultsMap\n      })\n\n      return Promise.all([componentChunkPromise, staticQueryBatchPromise]).then(\n        ([pageResources, staticQueryResults]) => {\n          let payload\n          if (pageResources) {\n            payload = { ...pageResources, staticQueryResults }\n            finalResult.payload = payload\n            emitter.emit(`onPostLoadPageResources`, {\n              page: payload,\n              pageResources: payload,\n            })\n          }\n\n          this.pageDb.set(pagePath, finalResult)\n\n          return payload\n        }\n      )\n    })\n\n    inFlightPromise\n      .then(response => {\n        this.inFlightDb.delete(pagePath)\n      })\n      .catch(error => {\n        this.inFlightDb.delete(pagePath)\n        throw error\n      })\n\n    this.inFlightDb.set(pagePath, inFlightPromise)\n\n    return inFlightPromise\n  }\n\n  // returns undefined if loading page ran into errors\n  loadPageSync(rawPath) {\n    const pagePath = findPath(rawPath)\n    if (this.pageDb.has(pagePath)) {\n      const pageData = this.pageDb.get(pagePath).payload\n      return pageData\n    }\n    return undefined\n  }\n\n  shouldPrefetch(pagePath) {\n    // Skip prefetching if we know user is on slow or constrained connection\n    if (!doesConnectionSupportPrefetch()) {\n      return false\n    }\n\n    // Check if the page exists.\n    if (this.pageDb.has(pagePath)) {\n      return false\n    }\n\n    return true\n  }\n\n  prefetch(pagePath) {\n    if (!this.shouldPrefetch(pagePath)) {\n      return false\n    }\n\n    // Tell plugins with custom prefetching logic that they should start\n    // prefetching this path.\n    if (!this.prefetchTriggered.has(pagePath)) {\n      this.apiRunner(`onPrefetchPathname`, { pathname: pagePath })\n      this.prefetchTriggered.add(pagePath)\n    }\n\n    // If a plugin has disabled core prefetching, stop now.\n    if (this.prefetchDisabled) {\n      return false\n    }\n\n    const realPath = findPath(pagePath)\n    // Todo make doPrefetch logic cacheable\n    // eslint-disable-next-line consistent-return\n    this.doPrefetch(realPath).then(() => {\n      if (!this.prefetchCompleted.has(pagePath)) {\n        this.apiRunner(`onPostPrefetchPathname`, { pathname: pagePath })\n        this.prefetchCompleted.add(pagePath)\n      }\n    })\n\n    return true\n  }\n\n  doPrefetch(pagePath) {\n    const pageDataUrl = createPageDataUrl(pagePath)\n    return prefetchHelper(pageDataUrl, {\n      crossOrigin: `anonymous`,\n      as: `fetch`,\n    }).then(() =>\n      // This was just prefetched, so will return a response from\n      // the cache instead of making another request to the server\n      this.loadPageDataJson(pagePath)\n    )\n  }\n\n  hovering(rawPath) {\n    this.loadPage(rawPath)\n  }\n\n  getResourceURLsForPathname(rawPath) {\n    const pagePath = findPath(rawPath)\n    const page = this.pageDataDb.get(pagePath)\n    if (page) {\n      const pageResources = toPageResources(page.payload)\n\n      return [\n        ...createComponentUrls(pageResources.page.componentChunkName),\n        createPageDataUrl(pagePath),\n      ]\n    } else {\n      return null\n    }\n  }\n\n  isPageNotFound(rawPath) {\n    const pagePath = findPath(rawPath)\n    const page = this.pageDb.get(pagePath)\n    return !page || page.notFound\n  }\n\n  loadAppData(retries = 0) {\n    return this.memoizedGet(`${__PATH_PREFIX__}/page-data/app-data.json`).then(\n      req => {\n        const { status, responseText } = req\n\n        let appData\n\n        if (status !== 200 && retries < 3) {\n          // Retry 3 times incase of non-200 responses\n          return this.loadAppData(retries + 1)\n        }\n\n        // Handle 200\n        if (status === 200) {\n          try {\n            const jsonPayload = JSON.parse(responseText)\n            if (jsonPayload.webpackCompilationHash === undefined) {\n              throw new Error(`not a valid app-data response`)\n            }\n\n            appData = jsonPayload\n          } catch (err) {\n            // continue regardless of error\n          }\n        }\n\n        return appData\n      }\n    )\n  }\n}\n\nconst createComponentUrls = componentChunkName =>\n  (window.___chunkMapping[componentChunkName] || []).map(\n    chunk => __PATH_PREFIX__ + chunk\n  )\n\nexport class ProdLoader extends BaseLoader {\n  constructor(asyncRequires, matchPaths) {\n    const loadComponent = chunkName =>\n      asyncRequires.components[chunkName]\n        ? asyncRequires.components[chunkName]()\n            .then(preferDefault)\n            // loader will handle the case when component is null\n            .catch(() => null)\n        : Promise.resolve()\n\n    super(loadComponent, matchPaths)\n  }\n\n  doPrefetch(pagePath) {\n    return super.doPrefetch(pagePath).then(result => {\n      if (result.status !== PageResourceStatus.Success) {\n        return Promise.resolve()\n      }\n      const pageData = result.payload\n      const chunkName = pageData.componentChunkName\n      const componentUrls = createComponentUrls(chunkName)\n      return Promise.all(componentUrls.map(prefetchHelper)).then(() => pageData)\n    })\n  }\n\n  loadPageDataJson(rawPath) {\n    return super.loadPageDataJson(rawPath).then(data => {\n      if (data.notFound) {\n        // check if html file exist using HEAD request:\n        // if it does we should navigate to it instead of showing 404\n        return doFetch(rawPath, `HEAD`).then(req => {\n          if (req.status === 200) {\n            // page (.html file) actually exist (or we asked for 404 )\n            // returning page resources status as errored to trigger\n            // regular browser navigation to given page\n            return {\n              status: PageResourceStatus.Error,\n            }\n          }\n\n          // if HEAD request wasn't 200, return notFound result\n          // and show 404 page\n          return data\n        })\n      }\n      return data\n    })\n  }\n}\n\nlet instance\n\nexport const setLoader = _loader => {\n  instance = _loader\n}\n\nexport const publicLoader = {\n  // Deprecated methods. As far as we're aware, these are only used by\n  // core gatsby and the offline plugin, however there's a very small\n  // chance they're called by others.\n  getResourcesForPathname: rawPath => {\n    console.warn(\n      `Warning: getResourcesForPathname is deprecated. Use loadPage instead`\n    )\n    return instance.i.loadPage(rawPath)\n  },\n  getResourcesForPathnameSync: rawPath => {\n    console.warn(\n      `Warning: getResourcesForPathnameSync is deprecated. Use loadPageSync instead`\n    )\n    return instance.i.loadPageSync(rawPath)\n  },\n  enqueue: rawPath => instance.prefetch(rawPath),\n\n  // Real methods\n  getResourceURLsForPathname: rawPath =>\n    instance.getResourceURLsForPathname(rawPath),\n  loadPage: rawPath => instance.loadPage(rawPath),\n  loadPageSync: rawPath => instance.loadPageSync(rawPath),\n  prefetch: rawPath => instance.prefetch(rawPath),\n  isPageNotFound: rawPath => instance.isPageNotFound(rawPath),\n  hovering: rawPath => instance.hovering(rawPath),\n  loadAppData: () => instance.loadAppData(),\n}\n\nexport default publicLoader\n\nexport function getStaticQueryResults() {\n  if (instance) {\n    return instance.staticQueryDb\n  } else {\n    return {}\n  }\n}\n","var requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var global = require('../internals/global');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n","var anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    /* global ActiveXObject -- old IE */\n    activeXDocument = document.domain && new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\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\n * @example\n *\n *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n */\n\nvar toPairs = /*#__PURE__*/_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;","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 implemtation\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}","'use strict';\nvar $ = require('../internals/export');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {\n          createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    INCORRECT_VALUES_NAME = true;\n    defaultIterator = function values() { return nativeIterator.call(this); };\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);\n  }\n  Iterators[NAME] = defaultIterator;\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  return methods;\n};\n","import nth from \"./nth.js\";\n/**\n * Returns the first element of the given list or string. In some libraries\n * this function is named `first`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {Array|String} list\n * @return {*}\n * @see R.tail, R.init, R.last\n * @example\n *\n *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n *      R.head([]); //=> undefined\n *\n *      R.head('abc'); //=> 'a'\n *      R.head(''); //=> ''\n */\n\nvar head = /*#__PURE__*/nth(0);\nexport default head;","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\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 [xf] to return a new transformer (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} xf transducer to initialize 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, xf, fn) {\n  return function () {\n    if (arguments.length === 0) {\n      return fn();\n    }\n\n    var args = Array.prototype.slice.call(arguments, 0);\n    var obj = args.pop();\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, args);\n        }\n\n        idx += 1;\n      }\n\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n\n    return fn.apply(this, arguments);\n  };\n}","import identity from \"./identity.js\";\nimport uniqBy from \"./uniqBy.js\";\n/**\n * Returns a new list containing only one copy of each element in the original\n * list. [`R.equals`](#equals) is used to determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n *      R.uniq([1, '1']);     //=> [1, '1']\n *      R.uniq([[42], [42]]); //=> [[42]]\n */\n\nvar uniq = /*#__PURE__*/uniqBy(identity);\nexport default uniq;","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it)) {\n    throw TypeError(String(it) + ' is not an object');\n  } return it;\n};\n","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns the larger of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.maxBy, R.min\n * @example\n *\n *      R.max(789, 123); //=> 789\n *      R.max('a', 'b'); //=> 'b'\n */\n\nvar max = /*#__PURE__*/_curry2(function max(a, b) {\n  return b > a ? b : a;\n});\n\nexport default max;","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n  var propertyKey = toPrimitive(key);\n  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n  else object[propertyKey] = 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 _curry2 from \"./internal/_curry2.js\";\nimport map from \"./map.js\";\n/**\n * Returns a lens for the given getter and setter functions. The getter \"gets\"\n * the value of the focus; the setter \"sets\" the value of the focus. The setter\n * should not mutate the data structure.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n * @param {Function} getter\n * @param {Function} setter\n * @return {Lens}\n * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n * @example\n *\n *      const xLens = R.lens(R.prop('x'), R.assoc('x'));\n *\n *      R.view(xLens, {x: 1, y: 2});            //=> 1\n *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n */\n\nvar lens = /*#__PURE__*/_curry2(function lens(getter, setter) {\n  return function (toFunctorFn) {\n    return function (target) {\n      return map(function (focus) {\n        return setter(focus, target);\n      }, toFunctorFn(getter(target)));\n    };\n  };\n});\n\nexport default lens;","\"use strict\";\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.ScrollContainer = void 0;\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _scrollHandler = require(\"./scroll-handler\");\n\nvar _router = require(\"@reach/router\");\n\n// TODO: In Gatsby v3, this file should be removed.\n// We are deprecating this in V2 in favor of useScrollRestoration\nvar propTypes = {\n  scrollKey: _propTypes.default.string.isRequired,\n  shouldUpdateScroll: _propTypes.default.func,\n  children: _propTypes.default.element.isRequired\n};\nvar hasNotWarnedDeprecation = true;\n\nvar ScrollContainerImplementation = /*#__PURE__*/function (_React$Component) {\n  (0, _inheritsLoose2.default)(ScrollContainerImplementation, _React$Component);\n\n  function ScrollContainerImplementation(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n\n    if (process.env.NODE_ENV !== \"production\" && hasNotWarnedDeprecation) {\n      hasNotWarnedDeprecation = false;\n      console.log(\"Deprecation Warning:\\n\\n  Gatsby <ScrollContainer> is deprecated in Gatsby v2 and will be removed in Gatsby v3.\\n  Update to the React hook alternative useScrollRestoration, like this:.\\n  \\n  ```\\n  import React from 'react';\\n  import { useScrollRestoration } from 'gatsby-react-router-scroll';\\n\\n  function Component() {\\n    const scrollRestoration = useScrollRestoration('\" + _this.props.scrollKey + \"');\\n\\n    return <ul {...scrollRestoration} />;\\n  }\\n  ```\\n  \");\n    }\n\n    return _this;\n  }\n\n  var _proto = ScrollContainerImplementation.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    var _this2 = this;\n\n    // eslint-disable-next-line react/no-find-dom-node\n    var node = _reactDom.default.findDOMNode(this);\n\n    var _this$props = this.props,\n        location = _this$props.location,\n        scrollKey = _this$props.scrollKey;\n    if (!node) return;\n    node.addEventListener(\"scroll\", function () {\n      _this2.props.context.save(location, scrollKey, node.scrollTop);\n    });\n    var position = this.props.context.read(location, scrollKey);\n    node.scrollTo(0, position || 0);\n  };\n\n  _proto.render = function render() {\n    return this.props.children;\n  };\n\n  return ScrollContainerImplementation;\n}(React.Component);\n\nvar ScrollContainer = function ScrollContainer(props) {\n  return /*#__PURE__*/React.createElement(_router.Location, null, function (_ref) {\n    var location = _ref.location;\n    return /*#__PURE__*/React.createElement(_scrollHandler.ScrollContext.Consumer, null, function (context) {\n      return /*#__PURE__*/React.createElement(ScrollContainerImplementation, (0, _extends2.default)({}, props, {\n        context: context,\n        location: location\n      }));\n    });\n  });\n};\n\nexports.ScrollContainer = ScrollContainer;\nScrollContainer.propTypes = propTypes;","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","export default function _pipe(f, g) {\n  return function () {\n    return g.call(this, f.apply(this, arguments));\n  };\n}","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 */\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 _makeFlat from \"./internal/_makeFlat.js\";\n/**\n * Returns a new list by pulling every item out of it (and all its sub-arrays)\n * and putting them in a new array, depth-first.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b]\n * @param {Array} list The array to consider.\n * @return {Array} The flattened list.\n * @see R.unnest\n * @example\n *\n *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n */\n\nvar flatten = /*#__PURE__*/_curry1( /*#__PURE__*/_makeFlat(true));\n\nexport default flatten;","var store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof store.inspectSource != 'function') {\n  store.inspectSource = function (it) {\n    return functionToString.call(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","import _curry1 from \"./internal/_curry1.js\";\nimport liftN from \"./liftN.js\";\n/**\n * \"lifts\" a function of arity > 1 so that it may \"map over\" a list, Function or other\n * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.liftN\n * @example\n *\n *      const madd3 = R.lift((a, b, c) => a + b + c);\n *\n *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n *\n *      const madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e);\n *\n *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n */\n\nvar lift = /*#__PURE__*/_curry1(function lift(fn) {\n  return liftN(fn.length, fn);\n});\n\nexport default lift;","var id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\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 = /*#__PURE__*/_curry1(function toString(val) {\n  return _toString(val, []);\n});\n\nexport default toString;","import _curry3 from \"./internal/_curry3.js\"; // `Identity` is a functor that holds a single value, where `map` simply\n// transforms the held value with the provided function.\n\nvar Identity = function (x) {\n  return {\n    value: x,\n    map: function (f) {\n      return Identity(f(x));\n    }\n  };\n};\n/**\n * Returns the result of \"setting\" the portion of the given data structure\n * focused by the given lens to the result of applying the given function to\n * the focused value.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> (a -> a) -> s -> s\n * @param {Lens} lens\n * @param {*} v\n * @param {*} x\n * @return {*}\n * @see R.prop, R.lensIndex, R.lensProp\n * @example\n *\n *      const headLens = R.lensIndex(0);\n *\n *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n */\n\n\nvar over = /*#__PURE__*/_curry3(function over(lens, f, x) {\n  // The value returned by the getter function is first transformed with `f`,\n  // then set as the value of an `Identity`. This is then mapped over with the\n  // setter function of the lens.\n  return lens(function (y) {\n    return Identity(f(y));\n  })(x).value;\n});\n\nexport default over;","var fails = require('../internals/fails');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : typeof detection == 'function' ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","import _curry1 from \"./internal/_curry1.js\";\nimport assocPath from \"./assocPath.js\";\nimport lens from \"./lens.js\";\nimport path from \"./path.js\";\n/**\n * Returns a lens whose focus is the specified path.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @typedefn Idx = String | Int\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig [Idx] -> Lens s a\n * @param {Array} path The path to use.\n * @return {Lens}\n * @see R.view, R.set, R.over\n * @example\n *\n *      const xHeadYLens = R.lensPath(['x', 0, 'y']);\n *\n *      R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n *      //=> 2\n *      R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n *      //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}\n *      R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n *      //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}\n */\n\nvar lensPath = /*#__PURE__*/_curry1(function lensPath(p) {\n  return lens(path(p), assocPath(p));\n});\n\nexport default lensPath;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeRight, R.mergeDeepRight, R.mergeWith, R.mergeWithKey\n * @deprecated since v0.26.0\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      const withDefaults = R.merge({x: 0, y: 0});\n *      withDefaults({y: 2}); //=> {x: 0, y: 2}\n * @symb R.merge(a, b) = {...a, ...b}\n */\n\nvar merge = /*#__PURE__*/_curry2(function merge(l, r) {\n  return _objectAssign({}, l, r);\n});\n\nexport default merge;","const preferDefault = m => (m && m.default) || m\n\nif (process.env.BUILD_STAGE === `develop`) {\n  module.exports = preferDefault(require(`./public-page-renderer-dev`))\n} else if (process.env.BUILD_STAGE === `build-javascript`) {\n  module.exports = preferDefault(require(`./public-page-renderer-prod`))\n} else {\n  module.exports = () => null\n}\n","var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n  try {\n    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n  } catch (error) {\n    iteratorClose(iterator);\n    throw error;\n  }\n};\n","'use strict';\n// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`\nrequire('../modules/es.array.iterator');\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar USE_NATIVE_URL = require('../internals/native-url');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar InternalStateModule = require('../internals/internal-state');\nvar anInstance = require('../internals/an-instance');\nvar hasOwn = require('../internals/has');\nvar bind = require('../internals/function-bind-context');\nvar classof = require('../internals/classof');\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $fetch = getBuiltIn('fetch');\nvar Headers = getBuiltIn('Headers');\nvar ITERATOR = wellKnownSymbol('iterator');\nvar URL_SEARCH_PARAMS = 'URLSearchParams';\nvar URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);\nvar getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);\n\nvar plus = /\\+/g;\nvar sequences = Array(4);\n\nvar percentSequence = function (bytes) {\n  return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\\\da-f]{2}){' + bytes + '})', 'gi'));\n};\n\nvar percentDecode = function (sequence) {\n  try {\n    return decodeURIComponent(sequence);\n  } catch (error) {\n    return sequence;\n  }\n};\n\nvar deserialize = function (it) {\n  var result = it.replace(plus, ' ');\n  var bytes = 4;\n  try {\n    return decodeURIComponent(result);\n  } catch (error) {\n    while (bytes) {\n      result = result.replace(percentSequence(bytes--), percentDecode);\n    }\n    return result;\n  }\n};\n\nvar find = /[!'()~]|%20/g;\n\nvar replace = {\n  '!': '%21',\n  \"'\": '%27',\n  '(': '%28',\n  ')': '%29',\n  '~': '%7E',\n  '%20': '+'\n};\n\nvar replacer = function (match) {\n  return replace[match];\n};\n\nvar serialize = function (it) {\n  return encodeURIComponent(it).replace(find, replacer);\n};\n\nvar parseSearchParams = function (result, query) {\n  if (query) {\n    var attributes = query.split('&');\n    var index = 0;\n    var attribute, entry;\n    while (index < attributes.length) {\n      attribute = attributes[index++];\n      if (attribute.length) {\n        entry = attribute.split('=');\n        result.push({\n          key: deserialize(entry.shift()),\n          value: deserialize(entry.join('='))\n        });\n      }\n    }\n  }\n};\n\nvar updateSearchParams = function (query) {\n  this.entries.length = 0;\n  parseSearchParams(this.entries, query);\n};\n\nvar validateArgumentsLength = function (passed, required) {\n  if (passed < required) throw TypeError('Not enough arguments');\n};\n\nvar URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {\n  setInternalState(this, {\n    type: URL_SEARCH_PARAMS_ITERATOR,\n    iterator: getIterator(getInternalParamsState(params).entries),\n    kind: kind\n  });\n}, 'Iterator', function next() {\n  var state = getInternalIteratorState(this);\n  var kind = state.kind;\n  var step = state.iterator.next();\n  var entry = step.value;\n  if (!step.done) {\n    step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];\n  } return step;\n});\n\n// `URLSearchParams` constructor\n// https://url.spec.whatwg.org/#interface-urlsearchparams\nvar URLSearchParamsConstructor = function URLSearchParams(/* init */) {\n  anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS);\n  var init = arguments.length > 0 ? arguments[0] : undefined;\n  var that = this;\n  var entries = [];\n  var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key;\n\n  setInternalState(that, {\n    type: URL_SEARCH_PARAMS,\n    entries: entries,\n    updateURL: function () { /* empty */ },\n    updateSearchParams: updateSearchParams\n  });\n\n  if (init !== undefined) {\n    if (isObject(init)) {\n      iteratorMethod = getIteratorMethod(init);\n      if (typeof iteratorMethod === 'function') {\n        iterator = iteratorMethod.call(init);\n        next = iterator.next;\n        while (!(step = next.call(iterator)).done) {\n          entryIterator = getIterator(anObject(step.value));\n          entryNext = entryIterator.next;\n          if (\n            (first = entryNext.call(entryIterator)).done ||\n            (second = entryNext.call(entryIterator)).done ||\n            !entryNext.call(entryIterator).done\n          ) throw TypeError('Expected sequence with length 2');\n          entries.push({ key: first.value + '', value: second.value + '' });\n        }\n      } else for (key in init) if (hasOwn(init, key)) entries.push({ key: key, value: init[key] + '' });\n    } else {\n      parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + '');\n    }\n  }\n};\n\nvar URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;\n\nredefineAll(URLSearchParamsPrototype, {\n  // `URLSearchParams.prototype.append` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-append\n  append: function append(name, value) {\n    validateArgumentsLength(arguments.length, 2);\n    var state = getInternalParamsState(this);\n    state.entries.push({ key: name + '', value: value + '' });\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.delete` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-delete\n  'delete': function (name) {\n    validateArgumentsLength(arguments.length, 1);\n    var state = getInternalParamsState(this);\n    var entries = state.entries;\n    var key = name + '';\n    var index = 0;\n    while (index < entries.length) {\n      if (entries[index].key === key) entries.splice(index, 1);\n      else index++;\n    }\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.get` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-get\n  get: function get(name) {\n    validateArgumentsLength(arguments.length, 1);\n    var entries = getInternalParamsState(this).entries;\n    var key = name + '';\n    var index = 0;\n    for (; index < entries.length; index++) {\n      if (entries[index].key === key) return entries[index].value;\n    }\n    return null;\n  },\n  // `URLSearchParams.prototype.getAll` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-getall\n  getAll: function getAll(name) {\n    validateArgumentsLength(arguments.length, 1);\n    var entries = getInternalParamsState(this).entries;\n    var key = name + '';\n    var result = [];\n    var index = 0;\n    for (; index < entries.length; index++) {\n      if (entries[index].key === key) result.push(entries[index].value);\n    }\n    return result;\n  },\n  // `URLSearchParams.prototype.has` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-has\n  has: function has(name) {\n    validateArgumentsLength(arguments.length, 1);\n    var entries = getInternalParamsState(this).entries;\n    var key = name + '';\n    var index = 0;\n    while (index < entries.length) {\n      if (entries[index++].key === key) return true;\n    }\n    return false;\n  },\n  // `URLSearchParams.prototype.set` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-set\n  set: function set(name, value) {\n    validateArgumentsLength(arguments.length, 1);\n    var state = getInternalParamsState(this);\n    var entries = state.entries;\n    var found = false;\n    var key = name + '';\n    var val = value + '';\n    var index = 0;\n    var entry;\n    for (; index < entries.length; index++) {\n      entry = entries[index];\n      if (entry.key === key) {\n        if (found) entries.splice(index--, 1);\n        else {\n          found = true;\n          entry.value = val;\n        }\n      }\n    }\n    if (!found) entries.push({ key: key, value: val });\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.sort` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-sort\n  sort: function sort() {\n    var state = getInternalParamsState(this);\n    var entries = state.entries;\n    // Array#sort is not stable in some engines\n    var slice = entries.slice();\n    var entry, entriesIndex, sliceIndex;\n    entries.length = 0;\n    for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) {\n      entry = slice[sliceIndex];\n      for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) {\n        if (entries[entriesIndex].key > entry.key) {\n          entries.splice(entriesIndex, 0, entry);\n          break;\n        }\n      }\n      if (entriesIndex === sliceIndex) entries.push(entry);\n    }\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.forEach` method\n  forEach: function forEach(callback /* , thisArg */) {\n    var entries = getInternalParamsState(this).entries;\n    var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3);\n    var index = 0;\n    var entry;\n    while (index < entries.length) {\n      entry = entries[index++];\n      boundFunction(entry.value, entry.key, this);\n    }\n  },\n  // `URLSearchParams.prototype.keys` method\n  keys: function keys() {\n    return new URLSearchParamsIterator(this, 'keys');\n  },\n  // `URLSearchParams.prototype.values` method\n  values: function values() {\n    return new URLSearchParamsIterator(this, 'values');\n  },\n  // `URLSearchParams.prototype.entries` method\n  entries: function entries() {\n    return new URLSearchParamsIterator(this, 'entries');\n  }\n}, { enumerable: true });\n\n// `URLSearchParams.prototype[@@iterator]` method\nredefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);\n\n// `URLSearchParams.prototype.toString` method\n// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior\nredefine(URLSearchParamsPrototype, 'toString', function toString() {\n  var entries = getInternalParamsState(this).entries;\n  var result = [];\n  var index = 0;\n  var entry;\n  while (index < entries.length) {\n    entry = entries[index++];\n    result.push(serialize(entry.key) + '=' + serialize(entry.value));\n  } return result.join('&');\n}, { enumerable: true });\n\nsetToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);\n\n$({ global: true, forced: !USE_NATIVE_URL }, {\n  URLSearchParams: URLSearchParamsConstructor\n});\n\n// Wrap `fetch` for correct work with polyfilled `URLSearchParams`\n// https://github.com/zloirock/core-js/issues/674\nif (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') {\n  $({ global: true, enumerable: true, forced: true }, {\n    fetch: function fetch(input /* , init */) {\n      var args = [input];\n      var init, body, headers;\n      if (arguments.length > 1) {\n        init = arguments[1];\n        if (isObject(init)) {\n          body = init.body;\n          if (classof(body) === URL_SEARCH_PARAMS) {\n            headers = init.headers ? new Headers(init.headers) : new Headers();\n            if (!headers.has('content-type')) {\n              headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');\n            }\n            init = create(init, {\n              body: createPropertyDescriptor(0, String(body)),\n              headers: createPropertyDescriptor(0, headers)\n            });\n          }\n        }\n        args.push(init);\n      } return $fetch.apply(this, args);\n    }\n  });\n}\n\nmodule.exports = {\n  URLSearchParams: URLSearchParamsConstructor,\n  getState: getInternalParamsState\n};\n","var anObject = require('../internals/an-object');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nmodule.exports = function (it) {\n  var iteratorMethod = getIteratorMethod(it);\n  if (typeof iteratorMethod != 'function') {\n    throw TypeError(String(it) + ' is not iterable');\n  } return anObject(iteratorMethod.call(it));\n};\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nexport default function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n  idx = 0;\n\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n\n  idx = 0;\n\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n\n  return result;\n}","export default function _isTransformer(obj) {\n  return obj != null && typeof obj['@@transducer/step'] === 'function';\n}","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 = /*#__PURE__*/_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;","/*\n  Why commonjs and not ES imports/exports?\n\n  This module is used to alias `create-react-context` package, but drop the the actual implementation part\n  because Gatsby requires version of react that has implementatoin baked in.\n  \n  Package source is using ES modules:\n    - https://github.com/jamiebuilds/create-react-context/blob/v0.3.0/src/index.js\n  \n  But to build this package `babel-plugin-add-module-exports` is used ( https://www.npmjs.com/package/babel-plugin-add-module-exports).\n  Which result in both `module.exports` and `exports.default` being set to same thing.\n\n  We don't use that babel plugin so we only have `exports.default`.\n\n  This cause problems in various 3rd party react components that rely on `module.exports` being set.\n  See https://github.com/gatsbyjs/gatsby/issues/23645 for example of it.\n  \n  Instead of adding same babel plugin we mimic output here. Adding babel plugin just for this would:\n   a) unnecesairly slow down compilation for all other files (if we just apply it everywhere)\n   b) or complicate babel-loader configuration with overwrite specifically for this file\n*/\n\nconst { createContext } = require(`react`)\n\nmodule.exports = createContext\nmodule.exports.default = createContext\n","export default function _isPlaceholder(a) {\n  return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","import _curry2 from \"./internal/_curry2.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\nimport nth from \"./nth.js\";\n/**\n * Retrieves the values at given paths of an object.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Object\n * @typedefn Idx = [String | Int]\n * @sig [Idx] -> {a} -> [a | Undefined]\n * @param {Array} pathsArray The array of paths to be fetched.\n * @param {Object} obj The object to retrieve the nested properties from.\n * @return {Array} A list consisting of values at paths specified by \"pathsArray\".\n * @see R.path\n * @example\n *\n *      R.paths([['a', 'b'], ['p', 0, 'q']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3]\n *      R.paths([['a', 'b'], ['p', 'r']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined]\n */\n\nvar paths = /*#__PURE__*/_curry2(function paths(pathsArray, obj) {\n  return pathsArray.map(function (paths) {\n    var val = obj;\n    var idx = 0;\n    var p;\n\n    while (idx < paths.length) {\n      if (val == null) {\n        return;\n      }\n\n      p = paths[idx];\n      val = _isInteger(p) ? nth(p, val) : val[p];\n      idx += 1;\n    }\n\n    return val;\n  });\n});\n\nexport default paths;","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 + 1] = value;\n    refTo[idx + 1] = copiedValue;\n\n    for (var key in value) {\n      copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key];\n    }\n\n    return copiedValue;\n  };\n\n  switch (type(value)) {\n    case 'Object':\n      return copy({});\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    default:\n      return value;\n  }\n}","function _extends() {\n  module.exports = _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  return _extends.apply(this, arguments);\n}\n\nmodule.exports = _extends;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.es/ecma262/#sec-tointeger\nmodule.exports = function (argument) {\n  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\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 */\n\nvar _isArrayLike = /*#__PURE__*/_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.nodeType === 1) {\n    return !!x.length;\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;","'use strict';\nvar fails = require('../internals/fails');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\nvar returnThis = function () { return this; };\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {\n  var test = {};\n  // FF44- legacy iterators case\n  return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif ((!IS_PURE || NEW_ITERATOR_PROTOTYPE) && !has(IteratorPrototype, ITERATOR)) {\n  createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","import _arity from \"./internal/_arity.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport map from \"./map.js\";\nimport max from \"./max.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic.\n * `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments\n * to `fn` are applied to each of the predicates in turn until one returns a\n * \"truthy\" value, at which point `fn` returns the result of applying its\n * arguments to the corresponding transformer. If none of the predicates\n * matches, `fn` returns undefined.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Logic\n * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n * @param {Array} pairs A list of [predicate, transformer]\n * @return {Function}\n * @see R.ifElse, R.unless, R.when\n * @example\n *\n *      const fn = R.cond([\n *        [R.equals(0),   R.always('water freezes at 0°C')],\n *        [R.equals(100), R.always('water boils at 100°C')],\n *        [R.T,           temp => 'nothing special happens at ' + temp + '°C']\n *      ]);\n *      fn(0); //=> 'water freezes at 0°C'\n *      fn(50); //=> 'nothing special happens at 50°C'\n *      fn(100); //=> 'water boils at 100°C'\n */\n\nvar cond = /*#__PURE__*/_curry1(function cond(pairs) {\n  var arity = reduce(max, 0, map(function (pair) {\n    return pair[0].length;\n  }, pairs));\n  return _arity(arity, function () {\n    var idx = 0;\n\n    while (idx < pairs.length) {\n      if (pairs[idx][0].apply(this, arguments)) {\n        return pairs[idx][1].apply(this, arguments);\n      }\n\n      idx += 1;\n    }\n  });\n});\n\nexport default cond;","import React from \"react\"\nimport PropTypes from \"prop-types\"\n\nimport loader from \"./loader\"\nimport InternalPageRenderer from \"./page-renderer\"\n\nconst ProdPageRenderer = ({ location }) => {\n  const pageResources = loader.loadPageSync(location.pathname)\n  if (!pageResources) {\n    return null\n  }\n  return React.createElement(InternalPageRenderer, {\n    location,\n    pageResources,\n    ...pageResources.json,\n  })\n}\n\nProdPageRenderer.propTypes = {\n  location: PropTypes.shape({\n    pathname: PropTypes.string.isRequired,\n  }).isRequired,\n}\n\nexport default ProdPageRenderer\n","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XMap = /*#__PURE__*/function () {\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 = /*#__PURE__*/_curry2(function _xmap(f, xf) {\n  return new XMap(f, xf);\n});\n\nexport default _xmap;","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\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 = /*#__PURE__*/_curry2( /*#__PURE__*/_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 equals from \"./equals.js\";\nimport take from \"./take.js\";\n/**\n * Checks if a list starts with the provided sublist.\n *\n * Similarly, checks if a string starts with the provided substring.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> [a] -> Boolean\n * @sig String -> String -> Boolean\n * @param {*} prefix\n * @param {*} list\n * @return {Boolean}\n * @see R.endsWith\n * @example\n *\n *      R.startsWith('a', 'abc')                //=> true\n *      R.startsWith('b', 'abc')                //=> false\n *      R.startsWith(['a'], ['a', 'b', 'c'])    //=> true\n *      R.startsWith(['b'], ['a', 'b', 'c'])    //=> false\n */\n\nvar startsWith = /*#__PURE__*/_curry2(function (prefix, list) {\n  return equals(take(prefix.length, list), prefix);\n});\n\nexport default startsWith;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if one or both of its arguments are `true`. Returns `false`\n * if both arguments are `false`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {Any} a\n * @param {Any} b\n * @return {Any} the first argument if truthy, otherwise the second argument.\n * @see R.either, R.xor\n * @example\n *\n *      R.or(true, true); //=> true\n *      R.or(true, false); //=> true\n *      R.or(false, true); //=> true\n *      R.or(false, false); //=> false\n */\n\nvar or = /*#__PURE__*/_curry2(function or(a, b) {\n  return a || b;\n});\n\nexport default or;","/**\n * A function that always returns `false`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig * -> Boolean\n * @param {*}\n * @return {Boolean}\n * @see R.T\n * @example\n *\n *      R.F(); //=> false\n */\nvar F = function () {\n  return false;\n};\n\nexport default F;","import _concat from \"./internal/_concat.js\";\nimport _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Creates a new list iteration function from an existing one by adding two new\n * parameters to its callback function: the current index, and the entire list.\n *\n * This would turn, for instance, [`R.map`](#map) function into one that\n * more closely resembles `Array.prototype.map`. Note that this will only work\n * for functions in which the iteration callback function is the first\n * parameter, and where the list is the last parameter. (This latter might be\n * unimportant if the list parameter is not used.)\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Function\n * @category List\n * @sig ((a ... -> b) ... -> [a] -> *) -> ((a ..., Int, [a] -> b) ... -> [a] -> *)\n * @param {Function} fn A list iteration function that does not pass index or list to its callback\n * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n * @example\n *\n *      const mapIndexed = R.addIndex(R.map);\n *      mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);\n *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n */\n\nvar addIndex = /*#__PURE__*/_curry1(function addIndex(fn) {\n  return curryN(fn.length, function () {\n    var idx = 0;\n    var origFn = arguments[0];\n    var list = arguments[arguments.length - 1];\n    var args = Array.prototype.slice.call(arguments, 0);\n\n    args[0] = function () {\n      var result = origFn.apply(this, _concat(arguments, [idx, list]));\n      idx += 1;\n      return result;\n    };\n\n    return fn.apply(this, args);\n  });\n});\n\nexport default addIndex;","import _concat from \"./internal/_concat.js\";\nimport _curry3 from \"./internal/_curry3.js\";\n/**\n * Applies a function to the value at the given index of an array, returning a\n * new copy of the array with the element at the given index replaced with the\n * result of the function application.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig Number -> (a -> a) -> [a] -> [a]\n * @param {Number} idx The index.\n * @param {Function} fn The function to apply.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @see R.update\n * @example\n *\n *      R.adjust(1, R.toUpper, ['a', 'b', 'c', 'd']);      //=> ['a', 'B', 'c', 'd']\n *      R.adjust(-1, R.toUpper, ['a', 'b', 'c', 'd']);     //=> ['a', 'b', 'c', 'D']\n * @symb R.adjust(-1, f, [a, b]) = [a, f(b)]\n * @symb R.adjust(0, f, [a, b]) = [f(a), b]\n */\n\nvar adjust = /*#__PURE__*/_curry3(function adjust(idx, fn, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n\n  var start = idx < 0 ? list.length : 0;\n\n  var _idx = start + idx;\n\n  var _list = _concat(list);\n\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n\nexport default adjust;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator) in\n * other languages and libraries.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      const t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\n\nvar always = /*#__PURE__*/_curry1(function always(val) {\n  return function () {\n    return val;\n  };\n});\n\nexport default always;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XAny = /*#__PURE__*/function () {\n  function XAny(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.any = false;\n  }\n\n  XAny.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAny.prototype['@@transducer/result'] = function (result) {\n    if (!this.any) {\n      result = this.xf['@@transducer/step'](result, false);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAny.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f(input)) {\n      this.any = true;\n      result = _reduced(this.xf['@@transducer/step'](result, true));\n    }\n\n    return result;\n  };\n\n  return XAny;\n}();\n\nvar _xany = /*#__PURE__*/_curry2(function _xany(f, xf) {\n  return new XAny(f, xf);\n});\n\nexport default _xany;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xany from \"./internal/_xany.js\";\n/**\n * Returns `true` if at least one of the elements of the list match the predicate,\n * `false` otherwise.\n *\n * Dispatches to the `any` 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 (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n *         otherwise.\n * @see R.all, R.none, R.transduce\n * @example\n *\n *      const lessThan0 = R.flip(R.lt)(0);\n *      const lessThan2 = R.flip(R.lt)(2);\n *      R.any(lessThan0)([1, 2]); //=> false\n *      R.any(lessThan2)([1, 2]); //=> true\n */\n\nvar any = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['any'], _xany, function any(fn, list) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (fn(list[idx])) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n}));\n\nexport default any;","export default function _aperture(n, list) {\n  var idx = 0;\n  var limit = list.length - (n - 1);\n  var acc = new Array(limit >= 0 ? limit : 0);\n\n  while (idx < limit) {\n    acc[idx] = Array.prototype.slice.call(list, idx, idx + n);\n    idx += 1;\n  }\n\n  return acc;\n}","import _concat from \"./_concat.js\";\nimport _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XAperture = /*#__PURE__*/function () {\n  function XAperture(n, xf) {\n    this.xf = xf;\n    this.pos = 0;\n    this.full = false;\n    this.acc = new Array(n);\n  }\n\n  XAperture.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAperture.prototype['@@transducer/result'] = function (result) {\n    this.acc = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAperture.prototype['@@transducer/step'] = function (result, input) {\n    this.store(input);\n    return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result;\n  };\n\n  XAperture.prototype.store = function (input) {\n    this.acc[this.pos] = input;\n    this.pos += 1;\n\n    if (this.pos === this.acc.length) {\n      this.pos = 0;\n      this.full = true;\n    }\n  };\n\n  XAperture.prototype.getCopy = function () {\n    return _concat(Array.prototype.slice.call(this.acc, this.pos), Array.prototype.slice.call(this.acc, 0, this.pos));\n  };\n\n  return XAperture;\n}();\n\nvar _xaperture = /*#__PURE__*/_curry2(function _xaperture(n, xf) {\n  return new XAperture(n, xf);\n});\n\nexport default _xaperture;","import _aperture from \"./internal/_aperture.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xaperture from \"./internal/_xaperture.js\";\n/**\n * Returns a new list, composed of n-tuples of consecutive elements. If `n` is\n * greater than the length of the list, an empty list is returned.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig Number -> [a] -> [[a]]\n * @param {Number} n The size of the tuples to create\n * @param {Array} list The list to split into `n`-length tuples\n * @return {Array} The resulting list of `n`-length tuples\n * @see R.transduce\n * @example\n *\n *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n */\n\nvar aperture = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xaperture, _aperture));\n\nexport default aperture;","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list containing the contents of the given list, followed by\n * the given element.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list of elements to add a new item to.\n *        list.\n * @return {Array} A new list containing the elements of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\n\nvar append = /*#__PURE__*/_curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n\nexport default append;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Takes a value and applies a function to it.\n *\n * This function is also known as the `thrush` combinator.\n *\n * @func\n * @memberOf R\n * @since v0.25.0\n * @category Function\n * @sig a -> (a -> b) -> b\n * @param {*} x The value\n * @param {Function} f The function to apply\n * @return {*} The result of applying `f` to `x`\n * @example\n *\n *      const t42 = R.applyTo(42);\n *      t42(R.identity); //=> 42\n *      t42(R.add(1)); //=> 43\n */\n\nvar applyTo = /*#__PURE__*/_curry2(function applyTo(x, f) {\n  return f(x);\n});\n\nexport default applyTo;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly `n` parameters. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} n The desired arity of the new function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n *         arity `n`.\n * @see R.binary, R.unary\n * @example\n *\n *      const takesTwoArgs = (a, b) => [a, b];\n *\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      const takesOneArg = R.nAry(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // Only `n` arguments are passed to the wrapped function\n *      takesOneArg(1, 2); //=> [1, undefined]\n * @symb R.nAry(0, f)(a, b) = f()\n * @symb R.nAry(1, f)(a, b) = f(a)\n * @symb R.nAry(2, f)(a, b) = f(a, b)\n */\n\nvar nAry = /*#__PURE__*/_curry2(function nAry(n, fn) {\n  switch (n) {\n    case 0:\n      return function () {\n        return fn.call(this);\n      };\n\n    case 1:\n      return function (a0) {\n        return fn.call(this, a0);\n      };\n\n    case 2:\n      return function (a0, a1) {\n        return fn.call(this, a0, a1);\n      };\n\n    case 3:\n      return function (a0, a1, a2) {\n        return fn.call(this, a0, a1, a2);\n      };\n\n    case 4:\n      return function (a0, a1, a2, a3) {\n        return fn.call(this, a0, a1, a2, a3);\n      };\n\n    case 5:\n      return function (a0, a1, a2, a3, a4) {\n        return fn.call(this, a0, a1, a2, a3, a4);\n      };\n\n    case 6:\n      return function (a0, a1, a2, a3, a4, a5) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5);\n      };\n\n    case 7:\n      return function (a0, a1, a2, a3, a4, a5, a6) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n      };\n\n    case 8:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n      };\n\n    case 9:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n      };\n\n    case 10:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n      };\n\n    default:\n      throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n  }\n});\n\nexport default nAry;","import _curry1 from \"./internal/_curry1.js\";\nimport nAry from \"./nAry.js\";\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly 2 parameters. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Function\n * @sig (* -> c) -> (a, b -> c)\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n *         arity 2.\n * @see R.nAry, R.unary\n * @example\n *\n *      const takesThreeArgs = function(a, b, c) {\n *        return [a, b, c];\n *      };\n *      takesThreeArgs.length; //=> 3\n *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n *\n *      const takesTwoArgs = R.binary(takesThreeArgs);\n *      takesTwoArgs.length; //=> 2\n *      // Only 2 arguments are passed to the wrapped function\n *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n * @symb R.binary(f)(a, b, c) = f(a, b)\n */\n\nvar binary = /*#__PURE__*/_curry1(function binary(fn) {\n  return nAry(2, fn);\n});\n\nexport default binary;","import curry from \"./curry.js\";\n/**\n * Returns the result of calling its first argument with the remaining\n * arguments. This is occasionally useful as a converging function for\n * [`R.converge`](#converge): the first branch can produce a function while the\n * remaining branches produce values to be passed to that function as its\n * arguments.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig (*... -> a),*... -> a\n * @param {Function} fn The function to apply to the remaining arguments.\n * @param {...*} args Any number of positional arguments.\n * @return {*}\n * @see R.apply\n * @example\n *\n *      R.call(R.add, 1, 2); //=> 3\n *\n *      const indentN = R.pipe(R.repeat(' '),\n *                           R.join(''),\n *                           R.replace(/^(?!$)/gm));\n *\n *      const format = R.converge(R.call, [\n *                                  R.pipe(R.prop('indent'), indentN),\n *                                  R.prop('value')\n *                              ]);\n *\n *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n * @symb R.call(f, a, b) = f(a, b)\n */\n\nvar call = /*#__PURE__*/curry(function call(fn) {\n  return fn.apply(this, Array.prototype.slice.call(arguments, 1));\n});\nexport default call;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Restricts a number to be within a range.\n *\n * Also works for other ordered types such as Strings and Dates.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Relation\n * @sig Ord a => a -> a -> a -> a\n * @param {Number} minimum The lower limit of the clamp (inclusive)\n * @param {Number} maximum The upper limit of the clamp (inclusive)\n * @param {Number} value Value to be clamped\n * @return {Number} Returns `minimum` when `val < minimum`, `maximum` when `val > maximum`, returns `val` otherwise\n * @example\n *\n *      R.clamp(1, 10, -5) // => 1\n *      R.clamp(1, 10, 15) // => 10\n *      R.clamp(1, 10, 4)  // => 4\n */\n\nvar clamp = /*#__PURE__*/_curry3(function clamp(min, max, value) {\n  if (min > max) {\n    throw new Error('min must not be greater than max in clamp(min, max, value)');\n  }\n\n  return value < min ? min : value > max ? max : value;\n});\n\nexport default clamp;","import _clone from \"./internal/_clone.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Creates a deep copy of the value which may contain (nested) `Array`s and\n * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n * assigned by reference rather than copied\n *\n * Dispatches to a `clone` method if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {*} -> {*}\n * @param {*} value The object or array to clone\n * @return {*} A deeply cloned copy of `val`\n * @example\n *\n *      const objects = [{}, {}, {}];\n *      const objectsClone = R.clone(objects);\n *      objects === objectsClone; //=> false\n *      objects[0] === objectsClone[0]; //=> false\n */\n\nvar clone = /*#__PURE__*/_curry1(function clone(value) {\n  return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], [], true);\n});\n\nexport default clone;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Makes a comparator function out of a function that reports whether the first\n * element is less than the second.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((a, b) -> Boolean) -> ((a, b) -> Number)\n * @param {Function} pred A predicate function of arity two which will return `true` if the first argument\n * is less than the second, `false` otherwise\n * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`\n * @example\n *\n *      const byAge = R.comparator((a, b) => a.age < b.age);\n *      const people = [\n *        { name: 'Emma', age: 70 },\n *        { name: 'Peter', age: 78 },\n *        { name: 'Mikhail', age: 62 },\n *      ];\n *      const peopleByIncreasingAge = R.sort(byAge, people);\n *        //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]\n */\n\nvar comparator = /*#__PURE__*/_curry1(function comparator(pred) {\n  return function (a, b) {\n    return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n  };\n});\n\nexport default comparator;","import chain from \"./chain.js\";\nimport compose from \"./compose.js\";\nimport map from \"./map.js\";\n/**\n * Returns the right-to-left Kleisli composition of the provided functions,\n * each of which must return a value of a type supported by [`chain`](#chain).\n *\n * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), f)`.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Function\n * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (a -> m z)\n * @param {...Function} ...functions The functions to compose\n * @return {Function}\n * @see R.pipeK\n * @deprecated since v0.26.0\n * @example\n *\n *       //  get :: String -> Object -> Maybe *\n *       const get = R.curry((propName, obj) => Maybe(obj[propName]))\n *\n *       //  getStateCode :: Maybe String -> Maybe String\n *       const getStateCode = R.composeK(\n *         R.compose(Maybe.of, R.toUpper),\n *         get('state'),\n *         get('address'),\n *         get('user'),\n *       );\n *       getStateCode({\"user\":{\"address\":{\"state\":\"ny\"}}}); //=> Maybe.Just(\"NY\")\n *       getStateCode({}); //=> Maybe.Nothing()\n * @symb R.composeK(f, g, h)(a) = R.chain(f, R.chain(g, h(a)))\n */\n\nexport default function composeK() {\n  if (arguments.length === 0) {\n    throw new Error('composeK requires at least one argument');\n  }\n\n  var init = Array.prototype.slice.call(arguments);\n  var last = init.pop();\n  return compose(compose.apply(this, map(chain, init)), last);\n}","export default function _pipeP(f, g) {\n  return function () {\n    var ctx = this;\n    return f.apply(ctx, arguments).then(function (x) {\n      return g.call(ctx, x);\n    });\n  };\n}","import _arity from \"./internal/_arity.js\";\nimport _pipeP from \"./internal/_pipeP.js\";\nimport reduce from \"./reduce.js\";\nimport tail from \"./tail.js\";\n/**\n * Performs left-to-right composition of one or more Promise-returning\n * functions. The first argument may have any arity; the remaining arguments\n * must be unary.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.composeP\n * @deprecated since v0.26.0\n * @example\n *\n *      //  followersForUser :: String -> Promise [User]\n *      const followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n */\n\nexport default function pipeP() {\n  if (arguments.length === 0) {\n    throw new Error('pipeP requires at least one argument');\n  }\n\n  return _arity(arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)));\n}","import pipeP from \"./pipeP.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Performs right-to-left composition of one or more Promise-returning\n * functions. The last arguments may have any arity; the remaining\n * arguments must be unary.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)\n * @param {...Function} functions The functions to compose\n * @return {Function}\n * @see R.pipeP\n * @deprecated since v0.26.0\n * @example\n *\n *      const db = {\n *        users: {\n *          JOE: {\n *            name: 'Joe',\n *            followers: ['STEVE', 'SUZY']\n *          }\n *        }\n *      }\n *\n *      // We'll pretend to do a db lookup which returns a promise\n *      const lookupUser = (userId) => Promise.resolve(db.users[userId])\n *      const lookupFollowers = (user) => Promise.resolve(user.followers)\n *      lookupUser('JOE').then(lookupFollowers)\n *\n *      //  followersForUser :: String -> Promise [UserId]\n *      const followersForUser = R.composeP(lookupFollowers, lookupUser);\n *      followersForUser('JOE').then(followers => console.log('Followers:', followers))\n *      // Followers: [\"STEVE\",\"SUZY\"]\n */\n\nexport default function composeP() {\n  if (arguments.length === 0) {\n    throw new Error('composeP requires at least one argument');\n  }\n\n  return pipeP.apply(this, reverse(arguments));\n}","import _arity from \"./internal/_arity.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport head from \"./head.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport tail from \"./tail.js\";\nimport identity from \"./identity.js\";\n/**\n * Performs left-to-right function composition using transforming function. The first argument may have\n * any arity; the remaining arguments must be unary.\n *\n * **Note:** The result of pipeWith is not automatically curried. Transforming function is not used on the\n * first argument.\n *\n * @func\n * @memberOf R\n * @since v0.26.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.composeWith, R.pipe\n * @example\n *\n *      const pipeWhileNotNil = R.pipeWith((f, res) => R.isNil(res) ? res : f(res));\n *      const f = pipeWhileNotNil([Math.pow, R.negate, R.inc])\n *\n *      f(3, 4); // -(3^4) + 1\n * @symb R.pipeWith(f)([g, h, i])(...args) = f(i, f(h, g(...args)))\n */\n\nvar pipeWith = /*#__PURE__*/_curry2(function pipeWith(xf, list) {\n  if (list.length <= 0) {\n    return identity;\n  }\n\n  var headList = head(list);\n  var tailList = tail(list);\n  return _arity(headList.length, function () {\n    return _reduce(function (result, f) {\n      return xf.call(this, f, result);\n    }, headList.apply(this, arguments), tailList);\n  });\n});\n\nexport default pipeWith;","import _curry2 from \"./internal/_curry2.js\";\nimport pipeWith from \"./pipeWith.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Performs right-to-left function composition using transforming function. 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. Transforming function is not used on the\n * last argument.\n *\n * @func\n * @memberOf R\n * @since v0.26.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.compose, R.pipeWith\n * @example\n *\n *      const composeWhileNotNil = R.composeWith((f, res) => R.isNil(res) ? res : f(res));\n *\n *      composeWhileNotNil([R.inc, R.prop('age')])({age: 1}) //=> 2\n *      composeWhileNotNil([R.inc, R.prop('age')])({}) //=> undefined\n *\n * @symb R.composeWith(f)([g, h, i])(...args) = f(g, f(h, i(...args)))\n */\n\nvar composeWith = /*#__PURE__*/_curry2(function composeWith(xf, list) {\n  return pipeWith.apply(this, [xf, reverse(list)]);\n});\n\nexport default composeWith;","import _curry2 from \"./internal/_curry2.js\";\nimport curry from \"./curry.js\";\nimport nAry from \"./nAry.js\";\n/**\n * Wraps a constructor function inside a curried function that can be called\n * with the same arguments and returns the same type. The arity of the function\n * returned is specified to allow using variadic constructor functions.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Function\n * @sig Number -> (* -> {*}) -> (* -> {*})\n * @param {Number} n The arity of the constructor function.\n * @param {Function} Fn The constructor function to wrap.\n * @return {Function} A wrapped, curried constructor function.\n * @example\n *\n *      // Variadic Constructor function\n *      function Salad() {\n *        this.ingredients = arguments;\n *      }\n *\n *      Salad.prototype.recipe = function() {\n *        const instructions = R.map(ingredient => 'Add a dollop of ' + ingredient, this.ingredients);\n *        return R.join('\\n', instructions);\n *      };\n *\n *      const ThreeLayerSalad = R.constructN(3, Salad);\n *\n *      // Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments.\n *      const salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup');\n *\n *      console.log(salad.recipe());\n *      // Add a dollop of Mayonnaise\n *      // Add a dollop of Potato Chips\n *      // Add a dollop of Ketchup\n */\n\nvar constructN = /*#__PURE__*/_curry2(function constructN(n, Fn) {\n  if (n > 10) {\n    throw new Error('Constructor with greater than ten arguments');\n  }\n\n  if (n === 0) {\n    return function () {\n      return new Fn();\n    };\n  }\n\n  return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n    switch (arguments.length) {\n      case 1:\n        return new Fn($0);\n\n      case 2:\n        return new Fn($0, $1);\n\n      case 3:\n        return new Fn($0, $1, $2);\n\n      case 4:\n        return new Fn($0, $1, $2, $3);\n\n      case 5:\n        return new Fn($0, $1, $2, $3, $4);\n\n      case 6:\n        return new Fn($0, $1, $2, $3, $4, $5);\n\n      case 7:\n        return new Fn($0, $1, $2, $3, $4, $5, $6);\n\n      case 8:\n        return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n\n      case 9:\n        return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n\n      case 10:\n        return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n    }\n  }));\n});\n\nexport default constructN;","import _curry1 from \"./internal/_curry1.js\";\nimport constructN from \"./constructN.js\";\n/**\n * Wraps a constructor function inside a curried function that can be called\n * with the same arguments and returns the same type.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (* -> {*}) -> (* -> {*})\n * @param {Function} fn The constructor function to wrap.\n * @return {Function} A wrapped, curried constructor function.\n * @see R.invoker\n * @example\n *\n *      // Constructor function\n *      function Animal(kind) {\n *        this.kind = kind;\n *      };\n *      Animal.prototype.sighting = function() {\n *        return \"It's a \" + this.kind + \"!\";\n *      }\n *\n *      const AnimalConstructor = R.construct(Animal)\n *\n *      // Notice we no longer need the 'new' keyword:\n *      AnimalConstructor('Pig'); //=> {\"kind\": \"Pig\", \"sighting\": function (){...}};\n *\n *      const animalTypes = [\"Lion\", \"Tiger\", \"Bear\"];\n *      const animalSighting = R.invoker(0, 'sighting');\n *      const sightNewAnimal = R.compose(animalSighting, AnimalConstructor);\n *      R.map(sightNewAnimal, animalTypes); //=> [\"It's a Lion!\", \"It's a Tiger!\", \"It's a Bear!\"]\n */\n\nvar construct = /*#__PURE__*/_curry1(function construct(Fn) {\n  return constructN(Fn.length, Fn);\n});\n\nexport default construct;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the specified value is equal, in [`R.equals`](#equals)\n * terms, to at least one element of the given list; `false` otherwise.\n * Works also with strings.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.\n * @see R.includes\n * @deprecated since v0.26.0\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true\n *      R.contains([42], [[42]]); //=> true\n *      R.contains('ba', 'banana'); //=>true\n */\n\nvar contains = /*#__PURE__*/_curry2(_includes);\n\nexport default contains;","import _curry2 from \"./internal/_curry2.js\";\nimport _map from \"./internal/_map.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Accepts a converging function and a list of branching functions and returns\n * a new function. The arity of the new function is the same as the arity of\n * the longest branching function. When invoked, this new function is applied\n * to some arguments, and each branching function is applied to those same\n * arguments. The results of each branching function are passed as arguments\n * to the converging function to produce the return value.\n *\n * @func\n * @memberOf R\n * @since v0.4.2\n * @category Function\n * @sig ((x1, x2, ...) -> z) -> [((a, b, ...) -> x1), ((a, b, ...) -> x2), ...] -> (a -> b -> ... -> z)\n * @param {Function} after A function. `after` will be invoked with the return values of\n *        `fn1` and `fn2` as its arguments.\n * @param {Array} functions A list of functions.\n * @return {Function} A new function.\n * @see R.useWith\n * @example\n *\n *      const average = R.converge(R.divide, [R.sum, R.length])\n *      average([1, 2, 3, 4, 5, 6, 7]) //=> 4\n *\n *      const strangeConcat = R.converge(R.concat, [R.toUpper, R.toLower])\n *      strangeConcat(\"Yodel\") //=> \"YODELyodel\"\n *\n * @symb R.converge(f, [g, h])(a, b) = f(g(a, b), h(a, b))\n */\n\nvar converge = /*#__PURE__*/_curry2(function converge(after, fns) {\n  return curryN(reduce(max, 0, pluck('length', fns)), function () {\n    var args = arguments;\n    var context = this;\n    return after.apply(context, _map(function (fn) {\n      return fn.apply(context, args);\n    }, fns));\n  });\n});\n\nexport default converge;","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 = /*#__PURE__*/reduceBy(function (acc, elem) {\n  return acc + 1;\n}, 0);\nexport default countBy;","import add from \"./add.js\";\n/**\n * Decrements its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number} n - 1\n * @see R.inc\n * @example\n *\n *      R.dec(42); //=> 41\n */\n\nvar dec = /*#__PURE__*/add(-1);\nexport default dec;","import _includesWith from \"./internal/_includesWith.js\";\nimport _curry3 from \"./internal/_curry3.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements in the first list not\n * contained in the second list. Duplication is determined according to the\n * value returned by applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` that are not in `list2`.\n * @see R.difference, R.symmetricDifference, R.symmetricDifferenceWith\n * @example\n *\n *      const cmp = (x, y) => x.a === y.a;\n *      const l1 = [{a: 1}, {a: 2}, {a: 3}];\n *      const l2 = [{a: 3}, {a: 4}];\n *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n */\n\nvar differenceWith = /*#__PURE__*/_curry3(function differenceWith(pred, first, second) {\n  var out = [];\n  var idx = 0;\n  var firstLen = first.length;\n\n  while (idx < firstLen) {\n    if (!_includesWith(pred, first[idx], second) && !_includesWith(pred, first[idx], out)) {\n      out.push(first[idx]);\n    }\n\n    idx += 1;\n  }\n\n  return out;\n});\n\nexport default differenceWith;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop The name of the property to dissociate\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original but without the specified property\n * @see R.assoc, R.omit\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\n\nvar dissoc = /*#__PURE__*/_curry2(function dissoc(prop, obj) {\n  var result = {};\n\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n\n  delete result[prop];\n  return result;\n});\n\nexport default dissoc;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Removes the sub-list of `list` starting at index `start` and containing\n * `count` elements. _Note that this is not destructive_: it returns a copy of\n * the list with the changes.\n * <small>No lists have been harmed in the application of this function.</small>\n *\n * @func\n * @memberOf R\n * @since v0.2.2\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @param {Number} start The position to start removing elements\n * @param {Number} count The number of elements to remove\n * @param {Array} list The list to remove from\n * @return {Array} A new Array with `count` elements from `start` removed.\n * @see R.without\n * @example\n *\n *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n */\n\nvar remove = /*#__PURE__*/_curry3(function remove(start, count, list) {\n  var result = Array.prototype.slice.call(list, 0);\n  result.splice(start, count);\n  return result;\n});\n\nexport default remove;","import _curry3 from \"./internal/_curry3.js\";\nimport adjust from \"./adjust.js\";\nimport always from \"./always.js\";\n/**\n * Returns a new copy of the array with the element at the provided index\n * replaced with the given value.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig Number -> a -> [a] -> [a]\n * @param {Number} idx The index to update.\n * @param {*} x The value to exist at the given index of the returned array.\n * @param {Array|Arguments} list The source array-like object to be updated.\n * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n * @see R.adjust\n * @example\n *\n *      R.update(1, '_', ['a', 'b', 'c']);      //=> ['a', '_', 'c']\n *      R.update(-1, '_', ['a', 'b', 'c']);     //=> ['a', 'b', '_']\n * @symb R.update(-1, a, [b, c]) = [b, a]\n * @symb R.update(0, a, [b, c]) = [a, c]\n * @symb R.update(1, a, [b, c]) = [b, a]\n */\n\nvar update = /*#__PURE__*/_curry3(function update(idx, x, list) {\n  return adjust(idx, always(x), list);\n});\n\nexport default update;","import _curry2 from \"./internal/_curry2.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport assoc from \"./assoc.js\";\nimport dissoc from \"./dissoc.js\";\nimport remove from \"./remove.js\";\nimport update from \"./update.js\";\n/**\n * Makes a shallow clone of an object, omitting the property at the given path.\n * Note that this copies and flattens prototype properties onto the new object\n * as well. All non-primitive properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.11.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {k: v} -> {k: v}\n * @param {Array} path The path to the value to omit\n * @param {Object} obj The object to clone\n * @return {Object} A new object without the property at path\n * @see R.assocPath\n * @example\n *\n *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n */\n\nvar dissocPath = /*#__PURE__*/_curry2(function dissocPath(path, obj) {\n  switch (path.length) {\n    case 0:\n      return obj;\n\n    case 1:\n      return _isInteger(path[0]) && _isArray(obj) ? remove(path[0], 1, obj) : dissoc(path[0], obj);\n\n    default:\n      var head = path[0];\n      var tail = Array.prototype.slice.call(path, 1);\n\n      if (obj[head] == null) {\n        return obj;\n      } else if (_isInteger(head) && _isArray(obj)) {\n        return update(head, dissocPath(tail, obj[head]), obj);\n      } else {\n        return assoc(head, dissocPath(tail, obj[head]), obj);\n      }\n\n  }\n});\n\nexport default dissocPath;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Divides two numbers. Equivalent to `a / b`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a / b`.\n * @see R.multiply\n * @example\n *\n *      R.divide(71, 100); //=> 0.71\n *\n *      const half = R.divide(R.__, 2);\n *      half(42); //=> 21\n *\n *      const reciprocal = R.divide(1);\n *      reciprocal(4);   //=> 0.25\n */\n\nvar divide = /*#__PURE__*/_curry2(function divide(a, b) {\n  return a / b;\n});\n\nexport default divide;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDrop = /*#__PURE__*/function () {\n  function XDrop(n, xf) {\n    this.xf = xf;\n    this.n = n;\n  }\n\n  XDrop.prototype['@@transducer/init'] = _xfBase.init;\n  XDrop.prototype['@@transducer/result'] = _xfBase.result;\n\n  XDrop.prototype['@@transducer/step'] = function (result, input) {\n    if (this.n > 0) {\n      this.n -= 1;\n      return result;\n    }\n\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return XDrop;\n}();\n\nvar _xdrop = /*#__PURE__*/_curry2(function _xdrop(n, xf) {\n  return new XDrop(n, xf);\n});\n\nexport default _xdrop;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdrop from \"./internal/_xdrop.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns all but the first `n` elements of the given list, string, or\n * transducer/transformer (or object with a `drop` method).\n *\n * Dispatches to the `drop` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n\n * @param {*} list\n * @return {*} A copy of list without the first `n` elements\n * @see R.take, R.transduce, R.dropLast, R.dropWhile\n * @example\n *\n *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n *      R.drop(3, 'ramda');               //=> 'da'\n */\n\nvar drop = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['drop'], _xdrop, function drop(n, xs) {\n  return slice(Math.max(0, n), Infinity, xs);\n}));\n\nexport default drop;","import take from \"../take.js\";\nexport default function dropLast(n, xs) {\n  return take(n < xs.length ? xs.length - n : 0, xs);\n}","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropLast = /*#__PURE__*/function () {\n  function XDropLast(n, xf) {\n    this.xf = xf;\n    this.pos = 0;\n    this.full = false;\n    this.acc = new Array(n);\n  }\n\n  XDropLast.prototype['@@transducer/init'] = _xfBase.init;\n\n  XDropLast.prototype['@@transducer/result'] = function (result) {\n    this.acc = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XDropLast.prototype['@@transducer/step'] = function (result, input) {\n    if (this.full) {\n      result = this.xf['@@transducer/step'](result, this.acc[this.pos]);\n    }\n\n    this.store(input);\n    return result;\n  };\n\n  XDropLast.prototype.store = function (input) {\n    this.acc[this.pos] = input;\n    this.pos += 1;\n\n    if (this.pos === this.acc.length) {\n      this.pos = 0;\n      this.full = true;\n    }\n  };\n\n  return XDropLast;\n}();\n\nvar _xdropLast = /*#__PURE__*/_curry2(function _xdropLast(n, xf) {\n  return new XDropLast(n, xf);\n});\n\nexport default _xdropLast;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _dropLast from \"./internal/_dropLast.js\";\nimport _xdropLast from \"./internal/_xdropLast.js\";\n/**\n * Returns a list containing all but the last `n` elements of the given `list`.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n The number of elements of `list` to skip.\n * @param {Array} list The list of elements to consider.\n * @return {Array} A copy of the list with only the first `list.length - n` elements\n * @see R.takeLast, R.drop, R.dropWhile, R.dropLastWhile\n * @example\n *\n *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n *      R.dropLast(3, 'ramda');               //=> 'ra'\n */\n\nvar dropLast = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xdropLast, _dropLast));\n\nexport default dropLast;","import slice from \"../slice.js\";\nexport default function dropLastWhile(pred, xs) {\n  var idx = xs.length - 1;\n\n  while (idx >= 0 && pred(xs[idx])) {\n    idx -= 1;\n  }\n\n  return slice(0, idx + 1, xs);\n}","import _curry2 from \"./_curry2.js\";\nimport _reduce from \"./_reduce.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropLastWhile = /*#__PURE__*/function () {\n  function XDropLastWhile(fn, xf) {\n    this.f = fn;\n    this.retained = [];\n    this.xf = xf;\n  }\n\n  XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;\n\n  XDropLastWhile.prototype['@@transducer/result'] = function (result) {\n    this.retained = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XDropLastWhile.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.retain(result, input) : this.flush(result, input);\n  };\n\n  XDropLastWhile.prototype.flush = function (result, input) {\n    result = _reduce(this.xf['@@transducer/step'], result, this.retained);\n    this.retained = [];\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  XDropLastWhile.prototype.retain = function (result, input) {\n    this.retained.push(input);\n    return result;\n  };\n\n  return XDropLastWhile;\n}();\n\nvar _xdropLastWhile = /*#__PURE__*/_curry2(function _xdropLastWhile(fn, xf) {\n  return new XDropLastWhile(fn, xf);\n});\n\nexport default _xdropLastWhile;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _dropLastWhile from \"./internal/_dropLastWhile.js\";\nimport _xdropLastWhile from \"./internal/_xdropLastWhile.js\";\n/**\n * Returns a new list excluding all the tailing elements of a given list which\n * satisfy the supplied predicate function. It passes each value from the right\n * to the supplied predicate function, skipping elements until the predicate\n * function returns a `falsy` value. The predicate function is applied to one argument:\n * *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} predicate The function to be called on each element\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array without any trailing elements that return `falsy` values from the `predicate`.\n * @see R.takeLastWhile, R.addIndex, R.drop, R.dropWhile\n * @example\n *\n *      const lteThree = x => x <= 3;\n *\n *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]\n *\n *      R.dropLastWhile(x => x !== 'd' , 'Ramda'); //=> 'Ramd'\n */\n\nvar dropLastWhile = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xdropLastWhile, _dropLastWhile));\n\nexport default dropLastWhile;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropRepeatsWith = /*#__PURE__*/function () {\n  function XDropRepeatsWith(pred, xf) {\n    this.xf = xf;\n    this.pred = pred;\n    this.lastValue = undefined;\n    this.seenFirstValue = false;\n  }\n\n  XDropRepeatsWith.prototype['@@transducer/init'] = _xfBase.init;\n  XDropRepeatsWith.prototype['@@transducer/result'] = _xfBase.result;\n\n  XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n    var sameAsLast = false;\n\n    if (!this.seenFirstValue) {\n      this.seenFirstValue = true;\n    } else if (this.pred(this.lastValue, input)) {\n      sameAsLast = true;\n    }\n\n    this.lastValue = input;\n    return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n  };\n\n  return XDropRepeatsWith;\n}();\n\nvar _xdropRepeatsWith = /*#__PURE__*/_curry2(function _xdropRepeatsWith(pred, xf) {\n  return new XDropRepeatsWith(pred, xf);\n});\n\nexport default _xdropRepeatsWith;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdropRepeatsWith from \"./internal/_xdropRepeatsWith.js\";\nimport last from \"./last.js\";\n/**\n * Returns a new list without any consecutively repeating elements. Equality is\n * determined by applying the supplied predicate to each pair of consecutive elements. The\n * first element in a series of equal elements will be preserved.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig ((a, a) -> Boolean) -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list The array to consider.\n * @return {Array} `list` without repeating elements.\n * @see R.transduce\n * @example\n *\n *      const l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n *      R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]\n */\n\nvar dropRepeatsWith = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n  var result = [];\n  var idx = 1;\n  var len = list.length;\n\n  if (len !== 0) {\n    result[0] = list[0];\n\n    while (idx < len) {\n      if (!pred(last(result), list[idx])) {\n        result[result.length] = list[idx];\n      }\n\n      idx += 1;\n    }\n  }\n\n  return result;\n}));\n\nexport default dropRepeatsWith;","import _curry1 from \"./internal/_curry1.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdropRepeatsWith from \"./internal/_xdropRepeatsWith.js\";\nimport dropRepeatsWith from \"./dropRepeatsWith.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns a new list without any consecutively repeating elements.\n * [`R.equals`](#equals) is used to determine equality.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The array to consider.\n * @return {Array} `list` without repeating elements.\n * @see R.transduce\n * @example\n *\n *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n */\n\nvar dropRepeats = /*#__PURE__*/_curry1( /*#__PURE__*/_dispatchable([], /*#__PURE__*/_xdropRepeatsWith(equals), /*#__PURE__*/dropRepeatsWith(equals)));\n\nexport default dropRepeats;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XDropWhile = /*#__PURE__*/function () {\n  function XDropWhile(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n\n  XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f) {\n      if (this.f(input)) {\n        return result;\n      }\n\n      this.f = null;\n    }\n\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return XDropWhile;\n}();\n\nvar _xdropWhile = /*#__PURE__*/_curry2(function _xdropWhile(f, xf) {\n  return new XDropWhile(f, xf);\n});\n\nexport default _xdropWhile;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xdropWhile from \"./internal/_xdropWhile.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns a new list excluding the leading elements of a given list which\n * satisfy the supplied predicate function. It passes each value to the supplied\n * predicate function, skipping elements while the predicate function returns\n * `true`. The predicate function is applied to one argument: *(value)*.\n *\n * Dispatches to the `dropWhile` 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.9.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.takeWhile, R.transduce, R.addIndex\n * @example\n *\n *      const lteTwo = x => x <= 2;\n *\n *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n *\n *      R.dropWhile(x => x !== 'd' , 'Ramda'); //=> 'da'\n */\n\nvar dropWhile = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['dropWhile'], _xdropWhile, function dropWhile(pred, xs) {\n  var idx = 0;\n  var len = xs.length;\n\n  while (idx < len && pred(xs[idx])) {\n    idx += 1;\n  }\n\n  return slice(idx, Infinity, xs);\n}));\n\nexport default dropWhile;","import _curry2 from \"./internal/_curry2.js\";\nimport drop from \"./drop.js\";\n/**\n * Returns a new list containing the last `n` elements of the given list.\n * If `n > list.length`, returns a list of `list.length` elements.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n The number of elements to return.\n * @param {Array} xs The collection to consider.\n * @return {Array}\n * @see R.dropLast\n * @example\n *\n *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.takeLast(3, 'ramda');               //=> 'mda'\n */\n\nvar takeLast = /*#__PURE__*/_curry2(function takeLast(n, xs) {\n  return drop(n >= 0 ? xs.length - n : 0, xs);\n});\n\nexport default takeLast;","import _curry2 from \"./internal/_curry2.js\";\nimport equals from \"./equals.js\";\nimport takeLast from \"./takeLast.js\";\n/**\n * Checks if a list ends with the provided sublist.\n *\n * Similarly, checks if a string ends with the provided substring.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> [a] -> Boolean\n * @sig String -> String -> Boolean\n * @param {*} suffix\n * @param {*} list\n * @return {Boolean}\n * @see R.startsWith\n * @example\n *\n *      R.endsWith('c', 'abc')                //=> true\n *      R.endsWith('b', 'abc')                //=> false\n *      R.endsWith(['c'], ['a', 'b', 'c'])    //=> true\n *      R.endsWith(['b'], ['a', 'b', 'c'])    //=> false\n */\n\nvar endsWith = /*#__PURE__*/_curry2(function (suffix, list) {\n  return equals(takeLast(suffix.length, list), suffix);\n});\n\nexport default endsWith;","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\n/**\n * Takes a function and two values in its domain and returns `true` if the\n * values map to the same value in the codomain; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Relation\n * @sig (a -> b) -> a -> a -> Boolean\n * @param {Function} f\n * @param {*} x\n * @param {*} y\n * @return {Boolean}\n * @example\n *\n *      R.eqBy(Math.abs, 5, -5); //=> true\n */\n\nvar eqBy = /*#__PURE__*/_curry3(function eqBy(f, x, y) {\n  return equals(f(x), f(y));\n});\n\nexport default eqBy;","import _curry3 from \"./internal/_curry3.js\";\nimport equals from \"./equals.js\";\n/**\n * Reports whether two objects have the same value, in [`R.equals`](#equals)\n * terms, for the specified property. Useful as a curried predicate.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig k -> {k: v} -> {k: v} -> Boolean\n * @param {String} prop The name of the property to compare\n * @param {Object} obj1\n * @param {Object} obj2\n * @return {Boolean}\n *\n * @example\n *\n *      const o1 = { a: 1, b: 2, c: 3, d: 4 };\n *      const o2 = { a: 10, b: 20, c: 3, d: 40 };\n *      R.eqProps('a', o1, o2); //=> false\n *      R.eqProps('c', o1, o2); //=> true\n */\n\nvar eqProps = /*#__PURE__*/_curry3(function eqProps(prop, obj1, obj2) {\n  return equals(obj1[prop], obj2[prop]);\n});\n\nexport default eqProps;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFindLast = /*#__PURE__*/function () {\n  function XFindLast(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFindLast.prototype['@@transducer/result'] = function (result) {\n    return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n  };\n\n  XFindLast.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f(input)) {\n      this.last = input;\n    }\n\n    return result;\n  };\n\n  return XFindLast;\n}();\n\nvar _xfindLast = /*#__PURE__*/_curry2(function _xfindLast(f, xf) {\n  return new XFindLast(f, xf);\n});\n\nexport default _xfindLast;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfindLast from \"./internal/_xfindLast.js\";\n/**\n * Returns the last element of the list which matches the predicate, or\n * `undefined` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> a | undefined\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Object} The element found, or `undefined`.\n * @see R.transduce\n * @example\n *\n *      const xs = [{a: 1, b: 0}, {a:1, b: 1}];\n *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n */\n\nvar findLast = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xfindLast, function findLast(fn, list) {\n  var idx = list.length - 1;\n\n  while (idx >= 0) {\n    if (fn(list[idx])) {\n      return list[idx];\n    }\n\n    idx -= 1;\n  }\n}));\n\nexport default findLast;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XFindLastIndex = /*#__PURE__*/function () {\n  function XFindLastIndex(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.idx = -1;\n    this.lastIdx = -1;\n  }\n\n  XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n    return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n  };\n\n  XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n    this.idx += 1;\n\n    if (this.f(input)) {\n      this.lastIdx = this.idx;\n    }\n\n    return result;\n  };\n\n  return XFindLastIndex;\n}();\n\nvar _xfindLastIndex = /*#__PURE__*/_curry2(function _xfindLastIndex(f, xf) {\n  return new XFindLastIndex(f, xf);\n});\n\nexport default _xfindLastIndex;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xfindLastIndex from \"./internal/_xfindLastIndex.js\";\n/**\n * Returns the index of the last element of the list which matches the\n * predicate, or `-1` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> Number\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Number} The index of the element found, or `-1`.\n * @see R.transduce\n * @example\n *\n *      const xs = [{a: 1, b: 0}, {a:1, b: 1}];\n *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n */\n\nvar findLastIndex = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xfindLastIndex, function findLastIndex(fn, list) {\n  var idx = list.length - 1;\n\n  while (idx >= 0) {\n    if (fn(list[idx])) {\n      return idx;\n    }\n\n    idx -= 1;\n  }\n\n  return -1;\n}));\n\nexport default findLastIndex;","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Returns a new function much like the supplied one, except that the first two\n * arguments' order is reversed.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((a, b, c, ...) -> z) -> (b -> a -> c -> ... -> z)\n * @param {Function} fn The function to invoke with its first two parameters reversed.\n * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n * @example\n *\n *      const mergeThree = (a, b, c) => [].concat(a, b, c);\n *\n *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n *\n *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n * @symb R.flip(f)(a, b, c) = f(b, a, c)\n */\n\nvar flip = /*#__PURE__*/_curry1(function flip(fn) {\n  return curryN(fn.length, function (a, b) {\n    var args = Array.prototype.slice.call(arguments, 0);\n    args[0] = b;\n    args[1] = a;\n    return fn.apply(this, args);\n  });\n});\n\nexport default flip;","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Iterate over an input `list`, calling a provided function `fn` for each\n * element in the list.\n *\n * `fn` receives one argument: *(value)*.\n *\n * Note: `R.forEach` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.forEach` method. For more\n * details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n *\n * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns\n * the original array. In some libraries this function is named `each`.\n *\n * Dispatches to the `forEach` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> *) -> [a] -> [a]\n * @param {Function} fn The function to invoke. Receives one argument, `value`.\n * @param {Array} list The list to iterate over.\n * @return {Array} The original list.\n * @see R.addIndex\n * @example\n *\n *      const printXPlusFive = x => console.log(x + 5);\n *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n *      // logs 6\n *      // logs 7\n *      // logs 8\n * @symb R.forEach(f, [a, b, c]) = [a, b, c]\n */\n\nvar forEach = /*#__PURE__*/_curry2( /*#__PURE__*/_checkForMethod('forEach', function forEach(fn, list) {\n  var len = list.length;\n  var idx = 0;\n\n  while (idx < len) {\n    fn(list[idx]);\n    idx += 1;\n  }\n\n  return list;\n}));\n\nexport default forEach;","import _curry2 from \"./internal/_curry2.js\";\nimport keys from \"./keys.js\";\n/**\n * Iterate over an input `object`, calling a provided function `fn` for each\n * key and value in the object.\n *\n * `fn` receives three argument: *(value, key, obj)*.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Object\n * @sig ((a, String, StrMap a) -> Any) -> StrMap a -> StrMap a\n * @param {Function} fn The function to invoke. Receives three argument, `value`, `key`, `obj`.\n * @param {Object} obj The object to iterate over.\n * @return {Object} The original object.\n * @example\n *\n *      const printKeyConcatValue = (value, key) => console.log(key + ':' + value);\n *      R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2}); //=> {x: 1, y: 2}\n *      // logs x:1\n *      // logs y:2\n * @symb R.forEachObjIndexed(f, {x: a, y: b}) = {x: a, y: b}\n */\n\nvar forEachObjIndexed = /*#__PURE__*/_curry2(function forEachObjIndexed(fn, obj) {\n  var keyList = keys(obj);\n  var idx = 0;\n\n  while (idx < keyList.length) {\n    var key = keyList[idx];\n    fn(obj[key], key, obj);\n    idx += 1;\n  }\n\n  return obj;\n});\n\nexport default forEachObjIndexed;","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 = /*#__PURE__*/_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 a list and returns a list of lists where each sublist's elements are\n * all satisfied pairwise comparison according to the provided function.\n * Only adjacent elements are passed to the comparison function.\n *\n * @func\n * @memberOf R\n * @since v0.21.0\n * @category List\n * @sig ((a, a) → Boolean) → [a] → [[a]]\n * @param {Function} fn Function for determining whether two given (adjacent)\n *        elements should be in the same group\n * @param {Array} list The array to group. Also accepts a string, which will be\n *        treated as a list of characters.\n * @return {List} A list that contains sublists of elements,\n *         whose concatenations are equal to the original list.\n * @example\n *\n * R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]]\n *\n * R.groupWith((a, b) => a + 1 === b, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0, 1], [1, 2, 3], [5], [8], [13], [21]]\n *\n * R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]]\n *\n * R.groupWith(R.eqBy(isVowel), 'aestiou')\n * //=> ['ae', 'st', 'iou']\n */\n\nvar groupWith = /*#__PURE__*/_curry2(function (fn, list) {\n  var res = [];\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    var nextidx = idx + 1;\n\n    while (nextidx < len && fn(list[nextidx - 1], list[nextidx])) {\n      nextidx += 1;\n    }\n\n    res.push(list.slice(idx, nextidx));\n    idx = nextidx;\n  }\n\n  return res;\n});\n\nexport default groupWith;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is greater than the second; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @see R.lt\n * @example\n *\n *      R.gt(2, 1); //=> true\n *      R.gt(2, 2); //=> false\n *      R.gt(2, 3); //=> false\n *      R.gt('a', 'z'); //=> false\n *      R.gt('z', 'a'); //=> true\n */\n\nvar gt = /*#__PURE__*/_curry2(function gt(a, b) {\n  return a > b;\n});\n\nexport default gt;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is greater than or equal to the second;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {Number} a\n * @param {Number} b\n * @return {Boolean}\n * @see R.lte\n * @example\n *\n *      R.gte(2, 1); //=> true\n *      R.gte(2, 2); //=> true\n *      R.gte(2, 3); //=> false\n *      R.gte('a', 'z'); //=> false\n *      R.gte('z', 'a'); //=> true\n */\n\nvar gte = /*#__PURE__*/_curry2(function gte(a, b) {\n  return a >= b;\n});\n\nexport default gte;","import _curry2 from \"./internal/_curry2.js\";\nimport hasPath from \"./hasPath.js\";\n/**\n * Returns whether or not an object has an own property with the specified name\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Object\n * @sig s -> {s: x} -> Boolean\n * @param {String} prop The name of the property to check for.\n * @param {Object} obj The object to query.\n * @return {Boolean} Whether the property exists.\n * @example\n *\n *      const hasName = R.has('name');\n *      hasName({name: 'alice'});   //=> true\n *      hasName({name: 'bob'});     //=> true\n *      hasName({});                //=> false\n *\n *      const point = {x: 0, y: 0};\n *      const pointHas = R.has(R.__, point);\n *      pointHas('x');  //=> true\n *      pointHas('y');  //=> true\n *      pointHas('z');  //=> false\n */\n\nvar has = /*#__PURE__*/_curry2(function has(prop, obj) {\n  return hasPath([prop], obj);\n});\n\nexport default has;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns whether or not an object or its prototype chain has a property with\n * the specified name\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Object\n * @sig s -> {s: x} -> Boolean\n * @param {String} prop The name of the property to check for.\n * @param {Object} obj The object to query.\n * @return {Boolean} Whether the property exists.\n * @example\n *\n *      function Rectangle(width, height) {\n *        this.width = width;\n *        this.height = height;\n *      }\n *      Rectangle.prototype.area = function() {\n *        return this.width * this.height;\n *      };\n *\n *      const square = new Rectangle(2, 2);\n *      R.hasIn('width', square);  //=> true\n *      R.hasIn('area', square);  //=> true\n */\n\nvar hasIn = /*#__PURE__*/_curry2(function hasIn(prop, obj) {\n  return prop in obj;\n});\n\nexport default hasIn;","import _objectIs from \"./internal/_objectIs.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * Note this is merely a curried version of ES6 `Object.is`.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      const o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\n\nvar identical = /*#__PURE__*/_curry2(_objectIs);\n\nexport default identical;","import add from \"./add.js\";\n/**\n * Increments its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number} n + 1\n * @see R.dec\n * @example\n *\n *      R.inc(42); //=> 43\n */\n\nvar inc = /*#__PURE__*/add(1);\nexport default inc;","import slice from \"./slice.js\";\n/**\n * Returns all but the last element of the given list or string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.last, R.head, R.tail\n * @example\n *\n *      R.init([1, 2, 3]);  //=> [1, 2]\n *      R.init([1, 2]);     //=> [1]\n *      R.init([1]);        //=> []\n *      R.init([]);         //=> []\n *\n *      R.init('abc');  //=> 'ab'\n *      R.init('ab');   //=> 'a'\n *      R.init('a');    //=> ''\n *      R.init('');     //=> ''\n */\n\nvar init = /*#__PURE__*/slice(0, -1);\nexport default init;","import _includesWith from \"./internal/_includesWith.js\";\nimport _curry3 from \"./internal/_curry3.js\";\nimport _filter from \"./internal/_filter.js\";\n/**\n * Takes a predicate `pred`, a list `xs`, and a list `ys`, and returns a list\n * `xs'` comprising each of the elements of `xs` which is equal to one or more\n * elements of `ys` according to `pred`.\n *\n * `pred` must be a binary function expecting an element from each list.\n *\n * `xs`, `ys`, and `xs'` are treated as sets, semantically, so ordering should\n * not be significant, but since `xs'` is ordered the implementation guarantees\n * that its values are in the same order as they appear in `xs`. Duplicates are\n * not removed, so `xs'` may contain duplicates if `xs` contains duplicates.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Relation\n * @sig ((a, b) -> Boolean) -> [a] -> [b] -> [a]\n * @param {Function} pred\n * @param {Array} xs\n * @param {Array} ys\n * @return {Array}\n * @see R.intersection\n * @example\n *\n *      R.innerJoin(\n *        (record, id) => record.id === id,\n *        [{id: 824, name: 'Richie Furay'},\n *         {id: 956, name: 'Dewey Martin'},\n *         {id: 313, name: 'Bruce Palmer'},\n *         {id: 456, name: 'Stephen Stills'},\n *         {id: 177, name: 'Neil Young'}],\n *        [177, 456, 999]\n *      );\n *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n */\n\nvar innerJoin = /*#__PURE__*/_curry3(function innerJoin(pred, xs, ys) {\n  return _filter(function (x) {\n    return _includesWith(pred, x, ys);\n  }, xs);\n});\n\nexport default innerJoin;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Inserts the supplied element into the list, at the specified `index`. _Note that\n\n * this is not destructive_: it returns a copy of the list with the changes.\n * <small>No lists have been harmed in the application of this function.</small>\n *\n * @func\n * @memberOf R\n * @since v0.2.2\n * @category List\n * @sig Number -> a -> [a] -> [a]\n * @param {Number} index The position to insert the element\n * @param {*} elt The element to insert into the Array\n * @param {Array} list The list to insert into\n * @return {Array} A new Array with `elt` inserted at `index`.\n * @example\n *\n *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n */\n\nvar insert = /*#__PURE__*/_curry3(function insert(idx, elt, list) {\n  idx = idx < list.length && idx >= 0 ? idx : list.length;\n  var result = Array.prototype.slice.call(list, 0);\n  result.splice(idx, 0, elt);\n  return result;\n});\n\nexport default insert;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Inserts the sub-list into the list, at the specified `index`. _Note that this is not\n * destructive_: it returns a copy of the list with the changes.\n * <small>No lists have been harmed in the application of this function.</small>\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category List\n * @sig Number -> [a] -> [a] -> [a]\n * @param {Number} index The position to insert the sub-list\n * @param {Array} elts The sub-list to insert into the Array\n * @param {Array} list The list to insert the sub-list into\n * @return {Array} A new Array with `elts` inserted starting at `index`.\n * @example\n *\n *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n */\n\nvar insertAll = /*#__PURE__*/_curry3(function insertAll(idx, elts, list) {\n  idx = idx < list.length && idx >= 0 ? idx : list.length;\n  return [].concat(Array.prototype.slice.call(list, 0, idx), elts, Array.prototype.slice.call(list, idx));\n});\n\nexport default insertAll;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _filter from \"./internal/_filter.js\";\nimport flip from \"./flip.js\";\nimport uniq from \"./uniq.js\";\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of those\n * elements common to both lists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The list of elements found in both `list1` and `list2`.\n * @see R.innerJoin\n * @example\n *\n *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n */\n\nvar intersection = /*#__PURE__*/_curry2(function intersection(list1, list2) {\n  var lookupList, filteredList;\n\n  if (list1.length > list2.length) {\n    lookupList = list1;\n    filteredList = list2;\n  } else {\n    lookupList = list2;\n    filteredList = list1;\n  }\n\n  return uniq(_filter(flip(_includes)(lookupList), filteredList));\n});\n\nexport default intersection;","import _checkForMethod from \"./internal/_checkForMethod.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new list with the separator interposed between elements.\n *\n * Dispatches to the `intersperse` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} separator The element to add to the list.\n * @param {Array} list The list to be interposed.\n * @return {Array} The new list.\n * @example\n *\n *      R.intersperse('a', ['b', 'n', 'n', 's']); //=> ['b', 'a', 'n', 'a', 'n', 'a', 's']\n */\n\nvar intersperse = /*#__PURE__*/_curry2( /*#__PURE__*/_checkForMethod('intersperse', function intersperse(separator, list) {\n  var out = [];\n  var idx = 0;\n  var length = list.length;\n\n  while (idx < length) {\n    if (idx === length - 1) {\n      out.push(list[idx]);\n    } else {\n      out.push(list[idx], separator);\n    }\n\n    idx += 1;\n  }\n\n  return out;\n}));\n\nexport default intersperse;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates an object containing a single key:value pair.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Object\n * @sig String -> a -> {String:a}\n * @param {String} key\n * @param {*} val\n * @return {Object}\n * @see R.pair\n * @example\n *\n *      const matchPhrases = R.compose(\n *        R.objOf('must'),\n *        R.map(R.objOf('match_phrase'))\n *      );\n *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n */\n\nvar objOf = /*#__PURE__*/_curry2(function objOf(key, val) {\n  var obj = {};\n  obj[key] = val;\n  return obj;\n});\n\nexport default objOf;","import _objectAssign from \"./_objectAssign.js\";\nimport _identity from \"./_identity.js\";\nimport _isArrayLike from \"./_isArrayLike.js\";\nimport _isTransformer from \"./_isTransformer.js\";\nimport objOf from \"../objOf.js\";\nvar _stepCatArray = {\n  '@@transducer/init': Array,\n  '@@transducer/step': function (xs, x) {\n    xs.push(x);\n    return xs;\n  },\n  '@@transducer/result': _identity\n};\nvar _stepCatString = {\n  '@@transducer/init': String,\n  '@@transducer/step': function (a, b) {\n    return a + b;\n  },\n  '@@transducer/result': _identity\n};\nvar _stepCatObject = {\n  '@@transducer/init': Object,\n  '@@transducer/step': function (result, input) {\n    return _objectAssign(result, _isArrayLike(input) ? objOf(input[0], input[1]) : input);\n  },\n  '@@transducer/result': _identity\n};\nexport default function _stepCat(obj) {\n  if (_isTransformer(obj)) {\n    return obj;\n  }\n\n  if (_isArrayLike(obj)) {\n    return _stepCatArray;\n  }\n\n  if (typeof obj === 'string') {\n    return _stepCatString;\n  }\n\n  if (typeof obj === 'object') {\n    return _stepCatObject;\n  }\n\n  throw new Error('Cannot create transformer for ' + obj);\n}","import _clone from \"./internal/_clone.js\";\nimport _curry3 from \"./internal/_curry3.js\";\nimport _isTransformer from \"./internal/_isTransformer.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _stepCat from \"./internal/_stepCat.js\";\n/**\n * Transforms the items of the list with the transducer and appends the\n * transformed items to the accumulator using an appropriate iterator function\n * based on the accumulator type.\n *\n * The accumulator can be an array, string, object or a transformer. Iterated\n * items will be appended to arrays and concatenated to strings. Objects will\n * be merged directly or 2-item arrays will be merged as key, value pairs.\n *\n * The accumulator can also be a transformer object that provides a 2-arity\n * reducing iterator function, step, 0-arity initial value function, init, and\n * 1-arity result extraction function result. The step function is used as the\n * iterator function in reduce. The result function is used to convert the\n * final accumulator into the return type and in most cases is R.identity. The\n * init function is used to provide the initial accumulator.\n *\n * The iteration is performed with [`R.reduce`](#reduce) after initializing the\n * transducer.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig a -> (b -> b) -> [c] -> a\n * @param {*} acc The initial accumulator value.\n * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.transduce\n * @example\n *\n *      const numbers = [1, 2, 3, 4];\n *      const transducer = R.compose(R.map(R.add(1)), R.take(2));\n *\n *      R.into([], transducer, numbers); //=> [2, 3]\n *\n *      const intoArray = R.into([]);\n *      intoArray(transducer, numbers); //=> [2, 3]\n */\n\nvar into = /*#__PURE__*/_curry3(function into(acc, xf, list) {\n  return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list);\n});\n\nexport default into;","import _curry1 from \"./internal/_curry1.js\";\nimport _has from \"./internal/_has.js\";\nimport keys from \"./keys.js\";\n/**\n * Same as [`R.invertObj`](#invertObj), however this accounts for objects with\n * duplicate values by putting the values into an array.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {s: x} -> {x: [ s, ... ]}\n * @param {Object} obj The object or array to invert\n * @return {Object} out A new object with keys in an array.\n * @see R.invertObj\n * @example\n *\n *      const raceResultsByFirstName = {\n *        first: 'alice',\n *        second: 'jake',\n *        third: 'alice',\n *      };\n *      R.invert(raceResultsByFirstName);\n *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n */\n\nvar invert = /*#__PURE__*/_curry1(function invert(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var idx = 0;\n  var out = {};\n\n  while (idx < len) {\n    var key = props[idx];\n    var val = obj[key];\n    var list = _has(val, out) ? out[val] : out[val] = [];\n    list[list.length] = key;\n    idx += 1;\n  }\n\n  return out;\n});\n\nexport default invert;","import _curry1 from \"./internal/_curry1.js\";\nimport keys from \"./keys.js\";\n/**\n * Returns a new object with the keys of the given object as values, and the\n * values of the given object, which are coerced to strings, as keys. Note\n * that the last key found is preferred when handling the same value.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {s: x} -> {x: s}\n * @param {Object} obj The object or array to invert\n * @return {Object} out A new object\n * @see R.invert\n * @example\n *\n *      const raceResults = {\n *        first: 'alice',\n *        second: 'jake'\n *      };\n *      R.invertObj(raceResults);\n *      //=> { 'alice': 'first', 'jake':'second' }\n *\n *      // Alternatively:\n *      const raceResults = ['alice', 'jake'];\n *      R.invertObj(raceResults);\n *      //=> { 'alice': '0', 'jake':'1' }\n */\n\nvar invertObj = /*#__PURE__*/_curry1(function invertObj(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var idx = 0;\n  var out = {};\n\n  while (idx < len) {\n    var key = props[idx];\n    out[obj[key]] = key;\n    idx += 1;\n  }\n\n  return out;\n});\n\nexport default invertObj;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * See if an object (`val`) is an instance of the supplied constructor. This\n * function will check up the inheritance chain, if any.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\n\nvar is = /*#__PURE__*/_curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n\nexport default is;","import _curry1 from \"./internal/_curry1.js\";\nimport converge from \"./converge.js\";\n/**\n * juxt applies a list of functions to a list of values.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Function\n * @sig [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n])\n * @param {Array} fns An array of functions\n * @return {Function} A function that returns a list of values after applying each of the original `fns` to its parameters.\n * @see R.applySpec\n * @example\n *\n *      const getRange = R.juxt([Math.min, Math.max]);\n *      getRange(3, 4, 9, -3); //=> [-3, 9]\n * @symb R.juxt([f, g, h])(a, b) = [f(a, b), g(a, b), h(a, b)]\n */\n\nvar juxt = /*#__PURE__*/_curry1(function juxt(fns) {\n  return converge(function () {\n    return Array.prototype.slice.call(arguments, 0);\n  }, fns);\n});\n\nexport default juxt;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Returns a list containing the names of all the properties of the supplied\n * object, including prototype properties.\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.2.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 and prototype properties.\n * @see R.keys, R.valuesIn\n * @example\n *\n *      const F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      const f = new F();\n *      R.keysIn(f); //=> ['x', 'y']\n */\n\nvar keysIn = /*#__PURE__*/_curry1(function keysIn(obj) {\n  var prop;\n  var ks = [];\n\n  for (prop in obj) {\n    ks[ks.length] = prop;\n  }\n\n  return ks;\n});\n\nexport default keysIn;","import _curry2 from \"./internal/_curry2.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport equals from \"./equals.js\";\n/**\n * Returns the position of the last occurrence of an item in an array, or -1 if\n * the item is not included in the array. [`R.equals`](#equals) is used to\n * determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Number\n * @param {*} target The item to find.\n * @param {Array} xs The array to search in.\n * @return {Number} the index of the target, or -1 if the target is not found.\n * @see R.indexOf\n * @example\n *\n *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n */\n\nvar lastIndexOf = /*#__PURE__*/_curry2(function lastIndexOf(target, xs) {\n  if (typeof xs.lastIndexOf === 'function' && !_isArray(xs)) {\n    return xs.lastIndexOf(target);\n  } else {\n    var idx = xs.length - 1;\n\n    while (idx >= 0) {\n      if (equals(xs[idx], target)) {\n        return idx;\n      }\n\n      idx -= 1;\n    }\n\n    return -1;\n  }\n});\n\nexport default lastIndexOf;","import _curry1 from \"./internal/_curry1.js\";\nimport lens from \"./lens.js\";\nimport nth from \"./nth.js\";\nimport update from \"./update.js\";\n/**\n * Returns a lens whose focus is the specified index.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Number -> Lens s a\n * @param {Number} n\n * @return {Lens}\n * @see R.view, R.set, R.over, R.nth\n * @example\n *\n *      const headLens = R.lensIndex(0);\n *\n *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n */\n\nvar lensIndex = /*#__PURE__*/_curry1(function lensIndex(n) {\n  return lens(nth(n), update(n));\n});\n\nexport default lensIndex;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is less than the second; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @see R.gt\n * @example\n *\n *      R.lt(2, 1); //=> false\n *      R.lt(2, 2); //=> false\n *      R.lt(2, 3); //=> true\n *      R.lt('a', 'z'); //=> true\n *      R.lt('z', 'a'); //=> false\n */\n\nvar lt = /*#__PURE__*/_curry2(function lt(a, b) {\n  return a < b;\n});\n\nexport default lt;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns `true` if the first argument is less than or equal to the second;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {Number} a\n * @param {Number} b\n * @return {Boolean}\n * @see R.gte\n * @example\n *\n *      R.lte(2, 1); //=> false\n *      R.lte(2, 2); //=> true\n *      R.lte(2, 3); //=> true\n *      R.lte('a', 'z'); //=> true\n *      R.lte('z', 'a'); //=> false\n */\n\nvar lte = /*#__PURE__*/_curry2(function lte(a, b) {\n  return a <= b;\n});\n\nexport default lte;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * The `mapAccum` function behaves like a combination of map and reduce; it\n * applies a function to each element of a list, passing an accumulating\n * parameter from left to right, and returning a final value of this\n * accumulator together with the new list.\n *\n * The iterator function receives two arguments, *acc* and *value*, and should\n * return a tuple *[acc, value]*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.scan, R.addIndex, R.mapAccumRight\n * @example\n *\n *      const digits = ['1', '2', '3', '4'];\n *      const appender = (a, b) => [a + b, a + b];\n *\n *      R.mapAccum(appender, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n * @symb R.mapAccum(f, a, [b, c, d]) = [\n *   f(f(f(a, b)[0], c)[0], d)[0],\n *   [\n *     f(a, b)[1],\n *     f(f(a, b)[0], c)[1],\n *     f(f(f(a, b)[0], c)[0], d)[1]\n *   ]\n * ]\n */\n\nvar mapAccum = /*#__PURE__*/_curry3(function mapAccum(fn, acc, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n  var tuple = [acc];\n\n  while (idx < len) {\n    tuple = fn(tuple[0], list[idx]);\n    result[idx] = tuple[1];\n    idx += 1;\n  }\n\n  return [tuple[0], result];\n});\n\nexport default mapAccum;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * The `mapAccumRight` function behaves like a combination of map and reduce; it\n * applies a function to each element of a list, passing an accumulating\n * parameter from right to left, and returning a final value of this\n * accumulator together with the new list.\n *\n * Similar to [`mapAccum`](#mapAccum), except moves through the input list from\n * the right to the left.\n *\n * The iterator function receives two arguments, *acc* and *value*, and should\n * return a tuple *[acc, value]*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.addIndex, R.mapAccum\n * @example\n *\n *      const digits = ['1', '2', '3', '4'];\n *      const appender = (a, b) => [b + a, b + a];\n *\n *      R.mapAccumRight(appender, 5, digits); //=> ['12345', ['12345', '2345', '345', '45']]\n * @symb R.mapAccumRight(f, a, [b, c, d]) = [\n *   f(f(f(a, d)[0], c)[0], b)[0],\n *   [\n *     f(a, d)[1],\n *     f(f(a, d)[0], c)[1],\n *     f(f(f(a, d)[0], c)[0], b)[1]\n *   ]\n * ]\n */\n\nvar mapAccumRight = /*#__PURE__*/_curry3(function mapAccumRight(fn, acc, list) {\n  var idx = list.length - 1;\n  var result = [];\n  var tuple = [acc];\n\n  while (idx >= 0) {\n    tuple = fn(tuple[0], list[idx]);\n    result[idx] = tuple[1];\n    idx -= 1;\n  }\n\n  return [tuple[0], result];\n});\n\nexport default mapAccumRight;","import _curry2 from \"./internal/_curry2.js\";\nimport _isInteger from \"./internal/_isInteger.js\";\n/**\n * `mathMod` behaves like the modulo operator should mathematically, unlike the\n * `%` operator (and by extension, [`R.modulo`](#modulo)). So while\n * `-17 % 5` is `-2`, `mathMod(-17, 5)` is `3`. `mathMod` requires Integer\n * arguments, and returns NaN when the modulus is zero or negative.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} m The dividend.\n * @param {Number} p the modulus.\n * @return {Number} The result of `b mod a`.\n * @see R.modulo\n * @example\n *\n *      R.mathMod(-17, 5);  //=> 3\n *      R.mathMod(17, 5);   //=> 2\n *      R.mathMod(17, -5);  //=> NaN\n *      R.mathMod(17, 0);   //=> NaN\n *      R.mathMod(17.2, 5); //=> NaN\n *      R.mathMod(17, 5.3); //=> NaN\n *\n *      const clock = R.mathMod(R.__, 12);\n *      clock(15); //=> 3\n *      clock(24); //=> 0\n *\n *      const seventeenMod = R.mathMod(17);\n *      seventeenMod(3);  //=> 2\n *      seventeenMod(4);  //=> 1\n *      seventeenMod(10); //=> 7\n */\n\nvar mathMod = /*#__PURE__*/_curry2(function mathMod(m, p) {\n  if (!_isInteger(m)) {\n    return NaN;\n  }\n\n  if (!_isInteger(p) || p < 1) {\n    return NaN;\n  }\n\n  return (m % p + p) % p;\n});\n\nexport default mathMod;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Takes a function and two values, and returns whichever value produces the\n * larger result when passed to the provided function.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Relation\n * @sig Ord b => (a -> b) -> a -> a -> a\n * @param {Function} f\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.max, R.minBy\n * @example\n *\n *      //  square :: Number -> Number\n *      const square = n => n * n;\n *\n *      R.maxBy(square, -3, 2); //=> -3\n *\n *      R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5\n *      R.reduce(R.maxBy(square), 0, []); //=> 0\n */\n\nvar maxBy = /*#__PURE__*/_curry3(function maxBy(f, a, b) {\n  return f(b) > f(a) ? b : a;\n});\n\nexport default maxBy;","import _curry1 from \"./internal/_curry1.js\";\nimport sum from \"./sum.js\";\n/**\n * Returns the mean of the given list of numbers.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list\n * @return {Number}\n * @see R.median\n * @example\n *\n *      R.mean([2, 7, 9]); //=> 6\n *      R.mean([]); //=> NaN\n */\n\nvar mean = /*#__PURE__*/_curry1(function mean(list) {\n  return sum(list) / list.length;\n});\n\nexport default mean;","import _curry1 from \"./internal/_curry1.js\";\nimport mean from \"./mean.js\";\n/**\n * Returns the median of the given list of numbers.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list\n * @return {Number}\n * @see R.mean\n * @example\n *\n *      R.median([2, 9, 7]); //=> 7\n *      R.median([7, 2, 10, 9]); //=> 8\n *      R.median([]); //=> NaN\n */\n\nvar median = /*#__PURE__*/_curry1(function median(list) {\n  var len = list.length;\n\n  if (len === 0) {\n    return NaN;\n  }\n\n  var width = 2 - len % 2;\n  var idx = (len - width) / 2;\n  return mean(Array.prototype.slice.call(list, 0).sort(function (a, b) {\n    return a < b ? -1 : a > b ? 1 : 0;\n  }).slice(idx, idx + width));\n});\n\nexport default median;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Merges a list of objects together into one object.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig [{k: v}] -> {k: v}\n * @param {Array} list An array of objects\n * @return {Object} A merged object.\n * @see R.reduce\n * @example\n *\n *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n * @symb R.mergeAll([{ x: 1 }, { y: 2 }, { z: 3 }]) = { x: 1, y: 2, z: 3 }\n */\n\nvar mergeAll = /*#__PURE__*/_curry1(function mergeAll(list) {\n  return _objectAssign.apply(null, [{}].concat(list));\n});\n\nexport default mergeAll;","import _curry3 from \"./internal/_curry3.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Creates a new object with the own properties of the two provided objects. If\n * a key exists in both objects, the provided function is applied to the key\n * and the values associated with the key in each object, with the result being\n * used as the value associated with the key in the returned object.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeDeepWithKey, R.merge, R.mergeWith\n * @example\n *\n *      let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r\n *      R.mergeWithKey(concatValues,\n *                     { a: true, thing: 'foo', values: [10, 20] },\n *                     { b: true, thing: 'bar', values: [15, 35] });\n *      //=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] }\n * @symb R.mergeWithKey(f, { x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: f('y', 2, 5), z: 3 }\n */\n\nvar mergeWithKey = /*#__PURE__*/_curry3(function mergeWithKey(fn, l, r) {\n  var result = {};\n  var k;\n\n  for (k in l) {\n    if (_has(k, l)) {\n      result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];\n    }\n  }\n\n  for (k in r) {\n    if (_has(k, r) && !_has(k, result)) {\n      result[k] = r[k];\n    }\n  }\n\n  return result;\n});\n\nexport default mergeWithKey;","import _curry3 from \"./internal/_curry3.js\";\nimport _isObject from \"./internal/_isObject.js\";\nimport mergeWithKey from \"./mergeWithKey.js\";\n/**\n * Creates a new object with the own properties of the two provided objects.\n * If a key exists in both objects:\n * - and both associated values are also objects then the values will be\n *   recursively merged.\n * - otherwise the provided function is applied to the key and associated values\n *   using the resulting value as the new value associated with the key.\n * If a key only exists in one object, the value will be associated with the key\n * of the resulting object.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.mergeWithKey, R.mergeDeepWith\n * @example\n *\n *      let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r\n *      R.mergeDeepWithKey(concatValues,\n *                         { a: true, c: { thing: 'foo', values: [10, 20] }},\n *                         { b: true, c: { thing: 'bar', values: [15, 35] }});\n *      //=> { a: true, b: true, c: { thing: 'bar', values: [10, 20, 15, 35] }}\n */\n\nvar mergeDeepWithKey = /*#__PURE__*/_curry3(function mergeDeepWithKey(fn, lObj, rObj) {\n  return mergeWithKey(function (k, lVal, rVal) {\n    if (_isObject(lVal) && _isObject(rVal)) {\n      return mergeDeepWithKey(fn, lVal, rVal);\n    } else {\n      return fn(k, lVal, rVal);\n    }\n  }, lObj, rObj);\n});\n\nexport default mergeDeepWithKey;","import _curry2 from \"./internal/_curry2.js\";\nimport mergeDeepWithKey from \"./mergeDeepWithKey.js\";\n/**\n * Creates a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects:\n * - and both values are objects, the two values will be recursively merged\n * - otherwise the value from the first object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig {a} -> {a} -> {a}\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.merge, R.mergeDeepRight, R.mergeDeepWith, R.mergeDeepWithKey\n * @example\n *\n *      R.mergeDeepLeft({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},\n *                      { age: 40, contact: { email: 'baa@example.com' }});\n *      //=> { name: 'fred', age: 10, contact: { email: 'moo@example.com' }}\n */\n\nvar mergeDeepLeft = /*#__PURE__*/_curry2(function mergeDeepLeft(lObj, rObj) {\n  return mergeDeepWithKey(function (k, lVal, rVal) {\n    return lVal;\n  }, lObj, rObj);\n});\n\nexport default mergeDeepLeft;","import _curry2 from \"./internal/_curry2.js\";\nimport mergeDeepWithKey from \"./mergeDeepWithKey.js\";\n/**\n * Creates a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects:\n * - and both values are objects, the two values will be recursively merged\n * - otherwise the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig {a} -> {a} -> {a}\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.merge, R.mergeDeepLeft, R.mergeDeepWith, R.mergeDeepWithKey\n * @example\n *\n *      R.mergeDeepRight({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},\n *                       { age: 40, contact: { email: 'baa@example.com' }});\n *      //=> { name: 'fred', age: 40, contact: { email: 'baa@example.com' }}\n */\n\nvar mergeDeepRight = /*#__PURE__*/_curry2(function mergeDeepRight(lObj, rObj) {\n  return mergeDeepWithKey(function (k, lVal, rVal) {\n    return rVal;\n  }, lObj, rObj);\n});\n\nexport default mergeDeepRight;","import _curry3 from \"./internal/_curry3.js\";\nimport mergeDeepWithKey from \"./mergeDeepWithKey.js\";\n/**\n * Creates a new object with the own properties of the two provided objects.\n * If a key exists in both objects:\n * - and both associated values are also objects then the values will be\n *   recursively merged.\n * - otherwise the provided function is applied to associated values using the\n *   resulting value as the new value associated with the key.\n * If a key only exists in one object, the value will be associated with the key\n * of the resulting object.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig ((a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.mergeWith, R.mergeDeepWithKey\n * @example\n *\n *      R.mergeDeepWith(R.concat,\n *                      { a: true, c: { values: [10, 20] }},\n *                      { b: true, c: { values: [15, 35] }});\n *      //=> { a: true, b: true, c: { values: [10, 20, 15, 35] }}\n */\n\nvar mergeDeepWith = /*#__PURE__*/_curry3(function mergeDeepWith(fn, lObj, rObj) {\n  return mergeDeepWithKey(function (k, lVal, rVal) {\n    return fn(lVal, rVal);\n  }, lObj, rObj);\n});\n\nexport default mergeDeepWith;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the first object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeRight, R.mergeDeepLeft, R.mergeWith, R.mergeWithKey\n * @example\n *\n *      R.mergeLeft({ 'age': 40 }, { 'name': 'fred', 'age': 10 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      const resetToDefault = R.mergeLeft({x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n * @symb R.mergeLeft(a, b) = {...b, ...a}\n */\n\nvar mergeLeft = /*#__PURE__*/_curry2(function mergeLeft(l, r) {\n  return _objectAssign({}, r, l);\n});\n\nexport default mergeLeft;","import _objectAssign from \"./internal/_objectAssign.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeLeft, R.mergeDeepRight, R.mergeWith, R.mergeWithKey\n * @example\n *\n *      R.mergeRight({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      const withDefaults = R.mergeRight({x: 0, y: 0});\n *      withDefaults({y: 2}); //=> {x: 0, y: 2}\n * @symb R.mergeRight(a, b) = {...a, ...b}\n */\n\nvar mergeRight = /*#__PURE__*/_curry2(function mergeRight(l, r) {\n  return _objectAssign({}, l, r);\n});\n\nexport default mergeRight;","import _curry3 from \"./internal/_curry3.js\";\nimport mergeWithKey from \"./mergeWithKey.js\";\n/**\n * Creates a new object with the own properties of the two provided objects. If\n * a key exists in both objects, the provided function is applied to the values\n * associated with the key in each object, with the result being used as the\n * value associated with the key in the returned object.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @sig ((a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeDeepWith, R.merge, R.mergeWithKey\n * @example\n *\n *      R.mergeWith(R.concat,\n *                  { a: true, values: [10, 20] },\n *                  { b: true, values: [15, 35] });\n *      //=> { a: true, b: true, values: [10, 20, 15, 35] }\n */\n\nvar mergeWith = /*#__PURE__*/_curry3(function mergeWith(fn, l, r) {\n  return mergeWithKey(function (_, _l, _r) {\n    return fn(_l, _r);\n  }, l, r);\n});\n\nexport default mergeWith;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Takes a function and two values, and returns whichever value produces the\n * smaller result when passed to the provided function.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Relation\n * @sig Ord b => (a -> b) -> a -> a -> a\n * @param {Function} f\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.min, R.maxBy\n * @example\n *\n *      //  square :: Number -> Number\n *      const square = n => n * n;\n *\n *      R.minBy(square, -3, 2); //=> 2\n *\n *      R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1\n *      R.reduce(R.minBy(square), Infinity, []); //=> Infinity\n */\n\nvar minBy = /*#__PURE__*/_curry3(function minBy(f, a, b) {\n  return f(b) < f(a) ? b : a;\n});\n\nexport default minBy;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Divides the first parameter by the second and returns the remainder. Note\n * that this function preserves the JavaScript-style behavior for modulo. For\n * mathematical modulo see [`mathMod`](#mathMod).\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The value to the divide.\n * @param {Number} b The pseudo-modulus\n * @return {Number} The result of `b % a`.\n * @see R.mathMod\n * @example\n *\n *      R.modulo(17, 3); //=> 2\n *      // JS behavior:\n *      R.modulo(-17, 3); //=> -2\n *      R.modulo(17, -3); //=> 2\n *\n *      const isOdd = R.modulo(R.__, 2);\n *      isOdd(42); //=> 0\n *      isOdd(21); //=> 1\n */\n\nvar modulo = /*#__PURE__*/_curry2(function modulo(a, b) {\n  return a % b;\n});\n\nexport default modulo;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Move an item, at index `from`, to index `to`, in a list of elements.\n * A new list will be created containing the new elements order.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @param {Number} from The source index\n * @param {Number} to The destination index\n * @param {Array} list The list which will serve to realise the move\n * @return {Array} The new list reordered\n * @example\n *\n *      R.move(0, 2, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['b', 'c', 'a', 'd', 'e', 'f']\n *      R.move(-1, 0, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['f', 'a', 'b', 'c', 'd', 'e'] list rotation\n */\n\nvar move = /*#__PURE__*/_curry3(function (from, to, list) {\n  var length = list.length;\n  var result = list.slice();\n  var positiveFrom = from < 0 ? length + from : from;\n  var positiveTo = to < 0 ? length + to : to;\n  var item = result.splice(positiveFrom, 1);\n  return positiveFrom < 0 || positiveFrom >= list.length || positiveTo < 0 || positiveTo >= list.length ? list : [].concat(result.slice(0, positiveTo)).concat(item).concat(result.slice(positiveTo, list.length));\n});\n\nexport default move;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Multiplies two numbers. Equivalent to `a * b` but curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a * b`.\n * @see R.divide\n * @example\n *\n *      const double = R.multiply(2);\n *      const triple = R.multiply(3);\n *      double(3);       //=>  6\n *      triple(4);       //=> 12\n *      R.multiply(2, 5);  //=> 10\n */\n\nvar multiply = /*#__PURE__*/_curry2(function multiply(a, b) {\n  return a * b;\n});\n\nexport default multiply;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Negates its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number}\n * @example\n *\n *      R.negate(42); //=> -42\n */\n\nvar negate = /*#__PURE__*/_curry1(function negate(n) {\n  return -n;\n});\n\nexport default negate;","import _complement from \"./internal/_complement.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport all from \"./all.js\";\n/**\n * Returns `true` if no elements of the list match the predicate, `false`\n * otherwise.\n *\n * Dispatches to the `all` 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.12.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n * @see R.all, R.any\n * @example\n *\n *      const isEven = n => n % 2 === 0;\n *      const isOdd = n => n % 2 === 1;\n *\n *      R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true\n *      R.none(isOdd, [1, 3, 5, 7, 8, 11]); //=> false\n */\n\nvar none = /*#__PURE__*/_curry2(function none(fn, input) {\n  return all(_complement(fn), input);\n});\n\nexport default none;","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\nimport nth from \"./nth.js\";\n/**\n * Returns a function which returns its nth argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig Number -> *... -> *\n * @param {Number} n\n * @return {Function}\n * @example\n *\n *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n * @symb R.nthArg(-1)(a, b, c) = c\n * @symb R.nthArg(0)(a, b, c) = a\n * @symb R.nthArg(1)(a, b, c) = b\n */\n\nvar nthArg = /*#__PURE__*/_curry1(function nthArg(n) {\n  var arity = n < 0 ? 1 : n + 1;\n  return curryN(arity, function () {\n    return nth(n, arguments);\n  });\n});\n\nexport default nthArg;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * `o` is a curried composition function that returns a unary function.\n * Like [`compose`](#compose), `o` performs right-to-left function composition.\n * Unlike [`compose`](#compose), the rightmost function passed to `o` will be\n * invoked with only one argument. Also, unlike [`compose`](#compose), `o` is\n * limited to accepting only 2 unary functions. The name o was chosen because\n * of its similarity to the mathematical composition operator ∘.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Function\n * @sig (b -> c) -> (a -> b) -> a -> c\n * @param {Function} f\n * @param {Function} g\n * @return {Function}\n * @see R.compose, R.pipe\n * @example\n *\n *      const classyGreeting = name => \"The name's \" + name.last + \", \" + name.first + \" \" + name.last\n *      const yellGreeting = R.o(R.toUpper, classyGreeting);\n *      yellGreeting({first: 'James', last: 'Bond'}); //=> \"THE NAME'S BOND, JAMES BOND\"\n *\n *      R.o(R.multiply(10), R.add(10))(-4) //=> 60\n *\n * @symb R.o(f, g, x) = f(g(x))\n */\n\nvar o = /*#__PURE__*/_curry3(function o(f, g, x) {\n  return f(g(x));\n});\n\nexport default o;","export default function _of(x) {\n  return [x];\n}","import _curry1 from \"./internal/_curry1.js\";\nimport _of from \"./internal/_of.js\";\n/**\n * Returns a singleton array containing the value provided.\n *\n * Note this `of` is different from the ES6 `of`; See\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig a -> [a]\n * @param {*} x any value\n * @return {Array} An array wrapping `x`.\n * @example\n *\n *      R.of(null); //=> [null]\n *      R.of([42]); //=> [[42]]\n */\n\nvar of = /*#__PURE__*/_curry1(_of);\n\nexport default of;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [String] -> {String: *} -> {String: *}\n * @param {Array} names an array of String property names to omit from the new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with properties from `names` not on it.\n * @see R.pick\n * @example\n *\n *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n */\n\nvar omit = /*#__PURE__*/_curry2(function omit(names, obj) {\n  var result = {};\n  var index = {};\n  var idx = 0;\n  var len = names.length;\n\n  while (idx < len) {\n    index[names[idx]] = 1;\n    idx += 1;\n  }\n\n  for (var prop in obj) {\n    if (!index.hasOwnProperty(prop)) {\n      result[prop] = obj[prop];\n    }\n  }\n\n  return result;\n});\n\nexport default omit;","import _arity from \"./internal/_arity.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Accepts a function `fn` and returns a function that guards invocation of\n * `fn` such that `fn` can only ever be called once, no matter how many times\n * the returned function is invoked. The first value calculated is returned in\n * subsequent invocations.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (a... -> b) -> (a... -> b)\n * @param {Function} fn The function to wrap in a call-only-once wrapper.\n * @return {Function} The wrapped function.\n * @example\n *\n *      const addOneOnce = R.once(x => x + 1);\n *      addOneOnce(10); //=> 11\n *      addOneOnce(addOneOnce(50)); //=> 11\n */\n\nvar once = /*#__PURE__*/_curry1(function once(fn) {\n  var called = false;\n  var result;\n  return _arity(fn.length, function () {\n    if (called) {\n      return result;\n    }\n\n    called = true;\n    result = fn.apply(this, arguments);\n    return result;\n  });\n});\n\nexport default once;","import _isFunction from \"./_isFunction.js\";\nimport _toString from \"./_toString.js\";\nexport default function _assertPromise(name, p) {\n  if (p == null || !_isFunction(p.then)) {\n    throw new TypeError('`' + name + '` expected a Promise, received ' + _toString(p, []));\n  }\n}","import _curry2 from \"./internal/_curry2.js\";\nimport _assertPromise from \"./internal/_assertPromise.js\";\n/**\n * Returns the result of applying the onFailure function to the value inside\n * a failed promise. This is useful for handling rejected promises\n * inside function compositions.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig (e -> b) -> (Promise e a) -> (Promise e b)\n * @sig (e -> (Promise f b)) -> (Promise e a) -> (Promise f b)\n * @param {Function} onFailure The function to apply. Can return a value or a promise of a value.\n * @param {Promise} p\n * @return {Promise} The result of calling `p.then(null, onFailure)`\n * @see R.then\n * @example\n *\n *      var failedFetch = (id) => Promise.reject('bad ID');\n *      var useDefault = () => ({ firstName: 'Bob', lastName: 'Loblaw' })\n *\n *      //recoverFromFailure :: String -> Promise ({firstName, lastName})\n *      var recoverFromFailure = R.pipe(\n *        failedFetch,\n *        R.otherwise(useDefault),\n *        R.then(R.pick(['firstName', 'lastName'])),\n *      );\n *      recoverFromFailure(12345).then(console.log)\n */\n\nvar otherwise = /*#__PURE__*/_curry2(function otherwise(f, p) {\n  _assertPromise('otherwise', p);\n\n  return p.then(null, f);\n});\n\nexport default otherwise;","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 = /*#__PURE__*/_curry2(function pair(fst, snd) {\n  return [fst, snd];\n});\n\nexport default pair;","import _arity from \"./_arity.js\";\nimport _curry2 from \"./_curry2.js\";\nexport default function _createPartialApplicator(concat) {\n  return _curry2(function (fn, args) {\n    return _arity(Math.max(0, fn.length - args.length), function () {\n      return fn.apply(this, concat(args, arguments));\n    });\n  });\n}","import _concat from \"./internal/_concat.js\";\nimport _createPartialApplicator from \"./internal/_createPartialApplicator.js\";\n/**\n * Takes a function `f` and a list of arguments, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the arguments\n * provided initially followed by the arguments provided to `g`.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)\n * @param {Function} f\n * @param {Array} args\n * @return {Function}\n * @see R.partialRight, R.curry\n * @example\n *\n *      const multiply2 = (a, b) => a * b;\n *      const double = R.partial(multiply2, [2]);\n *      double(2); //=> 4\n *\n *      const greet = (salutation, title, firstName, lastName) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      const sayHello = R.partial(greet, ['Hello']);\n *      const sayHelloToMs = R.partial(sayHello, ['Ms.']);\n *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partial(f, [a, b])(c, d) = f(a, b, c, d)\n */\n\nvar partial = /*#__PURE__*/_createPartialApplicator(_concat);\n\nexport default partial;","import _concat from \"./internal/_concat.js\";\nimport _createPartialApplicator from \"./internal/_createPartialApplicator.js\";\nimport flip from \"./flip.js\";\n/**\n * Takes a function `f` and a list of arguments, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the arguments\n * provided to `g` followed by the arguments provided initially.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x)\n * @param {Function} f\n * @param {Array} args\n * @return {Function}\n * @see R.partial\n * @example\n *\n *      const greet = (salutation, title, firstName, lastName) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      const greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);\n *\n *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partialRight(f, [a, b])(c, d) = f(c, d, a, b)\n */\n\nvar partialRight = /*#__PURE__*/_createPartialApplicator( /*#__PURE__*/flip(_concat));\n\nexport default partialRight;","import filter from \"./filter.js\";\nimport juxt from \"./juxt.js\";\nimport reject from \"./reject.js\";\n/**\n * Takes a predicate and a list or other `Filterable` object and returns the\n * pair of filterable objects of the same type of elements which do and do not\n * satisfy, the predicate, respectively. Filterable objects include plain objects or any object\n * that has a filter method such as `Array`.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> [f a, f a]\n * @param {Function} pred A predicate to determine which side the element belongs to.\n * @param {Array} filterable the list (or other filterable) to partition.\n * @return {Array} An array, containing first the subset of elements that satisfy the\n *         predicate, and second the subset of elements that do not satisfy.\n * @see R.filter, R.reject\n * @example\n *\n *      R.partition(R.includes('s'), ['sss', 'ttt', 'foo', 'bars']);\n *      // => [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n *\n *      R.partition(R.includes('s'), { a: 'sss', b: 'ttt', foo: 'bars' });\n *      // => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' }  ]\n */\n\nvar partition = /*#__PURE__*/juxt([filter, reject]);\nexport default partition;","import _curry3 from \"./internal/_curry3.js\";\nimport path from \"./path.js\";\n/**\n * Returns `true` if the specified object property at given path satisfies the\n * given predicate; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Logic\n * @typedefn Idx = String | Int\n * @sig (a -> Boolean) -> [Idx] -> {a} -> Boolean\n * @param {Function} pred\n * @param {Array} propPath\n * @param {*} obj\n * @return {Boolean}\n * @see R.propSatisfies, R.path\n * @example\n *\n *      R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true\n *      R.pathSatisfies(R.is(Object), [], {x: {y: 2}}); //=> true\n */\n\nvar pathSatisfies = /*#__PURE__*/_curry3(function pathSatisfies(pred, propPath, obj) {\n  return pred(path(propPath, obj));\n});\n\nexport default pathSatisfies;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a partial copy of an object containing only the keys specified. If\n * the key does not exist, the property is ignored.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> {k: v}\n * @param {Array} names an array of String property names to copy onto a new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties from `names` on it.\n * @see R.omit, R.props\n * @example\n *\n *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n */\n\nvar pick = /*#__PURE__*/_curry2(function pick(names, obj) {\n  var result = {};\n  var idx = 0;\n\n  while (idx < names.length) {\n    if (names[idx] in obj) {\n      result[names[idx]] = obj[names[idx]];\n    }\n\n    idx += 1;\n  }\n\n  return result;\n});\n\nexport default pick;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a partial copy of an object containing only the keys that satisfy\n * the supplied predicate.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @sig ((v, k) -> Boolean) -> {k: v} -> {k: v}\n * @param {Function} pred A predicate to determine whether or not a key\n *        should be included on the output object.\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties that satisfy `pred`\n *         on it.\n * @see R.pick, R.filter\n * @example\n *\n *      const isUpperCase = (val, key) => key.toUpperCase() === key;\n *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n */\n\nvar pickBy = /*#__PURE__*/_curry2(function pickBy(test, obj) {\n  var result = {};\n\n  for (var prop in obj) {\n    if (test(obj[prop], prop, obj)) {\n      result[prop] = obj[prop];\n    }\n  }\n\n  return result;\n});\n\nexport default pickBy;","import composeK from \"./composeK.js\";\nimport reverse from \"./reverse.js\";\n/**\n * Returns the left-to-right Kleisli composition of the provided functions,\n * each of which must return a value of a type supported by [`chain`](#chain).\n *\n * `R.pipeK(f, g, h)` is equivalent to `R.pipe(f, R.chain(g), R.chain(h))`.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Function\n * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (a -> m z)\n * @param {...Function}\n * @return {Function}\n * @see R.composeK\n * @deprecated since v0.26.0\n * @example\n *\n *      //  parseJson :: String -> Maybe *\n *      //  get :: String -> Object -> Maybe *\n *\n *      //  getStateCode :: Maybe String -> Maybe String\n *      const getStateCode = R.pipeK(\n *        parseJson,\n *        get('user'),\n *        get('address'),\n *        get('state'),\n *        R.compose(Maybe.of, R.toUpper)\n *      );\n *\n *      getStateCode('{\"user\":{\"address\":{\"state\":\"ny\"}}}');\n *      //=> Just('NY')\n *      getStateCode('[Invalid JSON]');\n *      //=> Nothing()\n * @symb R.pipeK(f, g, h)(a) = R.chain(h, R.chain(g, f(a)))\n */\n\nexport default function pipeK() {\n  if (arguments.length === 0) {\n    throw new Error('pipeK requires at least one argument');\n  }\n\n  return composeK.apply(this, reverse(arguments));\n}","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list with the given element at the front, followed by the\n * contents of the list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The item to add to the head of the output list.\n * @param {Array} list The array to add to the tail of the output list.\n * @return {Array} A new array.\n * @see R.append\n * @example\n *\n *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n */\n\nvar prepend = /*#__PURE__*/_curry2(function prepend(el, list) {\n  return _concat([el], list);\n});\n\nexport default prepend;","import multiply from \"./multiply.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Multiplies together all the elements of a list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list An array of numbers\n * @return {Number} The product of all the numbers in the list.\n * @see R.reduce\n * @example\n *\n *      R.product([2,4,6,8,100,1]); //=> 38400\n */\n\nvar product = /*#__PURE__*/reduce(multiply, 1);\nexport default product;","import _curry2 from \"./internal/_curry2.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Accepts a function `fn` and a list of transformer functions and returns a\n * new curried function. When the new function is invoked, it calls the\n * function `fn` with parameters consisting of the result of calling each\n * supplied handler on successive arguments to the new function.\n *\n * If more arguments are passed to the returned function than transformer\n * functions, those arguments are passed directly to `fn` as additional\n * parameters. If you expect additional arguments that don't need to be\n * transformed, although you can ignore them, it's best to pass an identity\n * function so that the new function reports the correct arity.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((x1, x2, ...) -> z) -> [(a -> x1), (b -> x2), ...] -> (a -> b -> ... -> z)\n * @param {Function} fn The function to wrap.\n * @param {Array} transformers A list of transformer functions\n * @return {Function} The wrapped function.\n * @see R.converge\n * @example\n *\n *      R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81\n *      R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81\n *      R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32\n *      R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32\n * @symb R.useWith(f, [g, h])(a, b) = f(g(a), h(b))\n */\n\nvar useWith = /*#__PURE__*/_curry2(function useWith(fn, transformers) {\n  return curryN(transformers.length, function () {\n    var args = [];\n    var idx = 0;\n\n    while (idx < transformers.length) {\n      args.push(transformers[idx].call(this, arguments[idx]));\n      idx += 1;\n    }\n\n    return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length)));\n  });\n});\n\nexport default useWith;","import _map from \"./internal/_map.js\";\nimport identity from \"./identity.js\";\nimport pickAll from \"./pickAll.js\";\nimport useWith from \"./useWith.js\";\n/**\n * Reasonable analog to SQL `select` statement.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @category Relation\n * @sig [k] -> [{k: v}] -> [{k: v}]\n * @param {Array} props The property names to project\n * @param {Array} objs The objects to query\n * @return {Array} An array of objects with just the `props` properties.\n * @example\n *\n *      const abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n *      const fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n *      const kids = [abby, fred];\n *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n */\n\nvar project = /*#__PURE__*/useWith(_map, [pickAll, identity]); // passing `identity` gives correct arity\n\nexport default project;","import _curry3 from \"./internal/_curry3.js\";\nimport is from \"./is.js\";\n/**\n * Returns `true` if the specified object property is of the given type;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Type\n * @sig Type -> String -> Object -> Boolean\n * @param {Function} type\n * @param {String} name\n * @param {*} obj\n * @return {Boolean}\n * @see R.is, R.propSatisfies\n * @example\n *\n *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n *      R.propIs(Number, 'x', {});            //=> false\n */\n\nvar propIs = /*#__PURE__*/_curry3(function propIs(type, name, obj) {\n  return is(type, obj[name]);\n});\n\nexport default propIs;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Returns `true` if the specified object property satisfies the given\n * predicate; `false` otherwise. You can test multiple properties with\n * [`R.where`](#where).\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Logic\n * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n * @param {Function} pred\n * @param {String} name\n * @param {*} obj\n * @return {Boolean}\n * @see R.where, R.propEq, R.propIs\n * @example\n *\n *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n */\n\nvar propSatisfies = /*#__PURE__*/_curry3(function propSatisfies(pred, name, obj) {\n  return pred(obj[name]);\n});\n\nexport default propSatisfies;","import _curry2 from \"./internal/_curry2.js\";\nimport path from \"./path.js\";\n/**\n * Acts as multiple `prop`: array of keys in, array of values out. Preserves\n * order.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> [v]\n * @param {Array} ps The property names to fetch\n * @param {Object} obj The object to query\n * @return {Array} The corresponding values or partially applied function.\n * @example\n *\n *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n *\n *      const fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n */\n\nvar props = /*#__PURE__*/_curry2(function props(ps, obj) {\n  return ps.map(function (p) {\n    return path([p], obj);\n  });\n});\n\nexport default props;","import _curry2 from \"./internal/_curry2.js\";\nimport _isNumber from \"./internal/_isNumber.js\";\n/**\n * Returns a list of numbers from `from` (inclusive) to `to` (exclusive).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> Number -> [Number]\n * @param {Number} from The first number in the list.\n * @param {Number} to One more than the last number in the list.\n * @return {Array} The list of numbers in the set `[a, b)`.\n * @example\n *\n *      R.range(1, 5);    //=> [1, 2, 3, 4]\n *      R.range(50, 53);  //=> [50, 51, 52]\n */\n\nvar range = /*#__PURE__*/_curry2(function range(from, to) {\n  if (!(_isNumber(from) && _isNumber(to))) {\n    throw new TypeError('Both arguments to range must be numbers');\n  }\n\n  var result = [];\n  var n = from;\n\n  while (n < to) {\n    result.push(n);\n    n += 1;\n  }\n\n  return result;\n});\n\nexport default range;","import _curry3 from \"./internal/_curry3.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 * Similar to [`reduce`](#reduce), except moves through the input list from the\n * right to the left.\n *\n * The iterator function receives two values: *(value, acc)*, while the arguments'\n * order of `reduce`'s iterator function is *(acc, value)*.\n *\n * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduceRight` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> b) -> b -> [a] -> b\n * @param {Function} fn The iterator function. Receives two values, the current element from the array\n *        and the accumulator.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.addIndex\n * @example\n *\n *      R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2\n *      //    -               -2\n *      //   / \\              / \\\n *      //  1   -            1   3\n *      //     / \\              / \\\n *      //    2   -     ==>    2  -1\n *      //       / \\              / \\\n *      //      3   -            3   4\n *      //         / \\              / \\\n *      //        4   0            4   0\n *\n * @symb R.reduceRight(f, a, [b, c, d]) = f(b, f(c, f(d, a)))\n */\n\nvar reduceRight = /*#__PURE__*/_curry3(function reduceRight(fn, acc, list) {\n  var idx = list.length - 1;\n\n  while (idx >= 0) {\n    acc = fn(list[idx], acc);\n    idx -= 1;\n  }\n\n  return acc;\n});\n\nexport default reduceRight;","import _curryN from \"./internal/_curryN.js\";\nimport _reduce from \"./internal/_reduce.js\";\nimport _reduced from \"./internal/_reduced.js\";\n/**\n * Like [`reduce`](#reduce), `reduceWhile` returns a single item by iterating\n * through the list, successively calling the iterator function. `reduceWhile`\n * also takes a predicate that is evaluated before each step. If the predicate\n * returns `false`, it \"short-circuits\" the iteration and returns the current\n * value of the accumulator.\n *\n * @func\n * @memberOf R\n * @since v0.22.0\n * @category List\n * @sig ((a, b) -> Boolean) -> ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} pred The predicate. It is passed the accumulator and the\n *        current element.\n * @param {Function} fn The iterator function. Receives two values, the\n *        accumulator and the current element.\n * @param {*} a The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.reduced\n * @example\n *\n *      const isOdd = (acc, x) => x % 2 === 1;\n *      const xs = [1, 3, 5, 60, 777, 800];\n *      R.reduceWhile(isOdd, R.add, 0, xs); //=> 9\n *\n *      const ys = [2, 4, 6]\n *      R.reduceWhile(isOdd, R.add, 111, ys); //=> 111\n */\n\nvar reduceWhile = /*#__PURE__*/_curryN(4, [], function _reduceWhile(pred, fn, a, list) {\n  return _reduce(function (acc, x) {\n    return pred(acc, x) ? fn(acc, x) : _reduced(acc);\n  }, a, list);\n});\n\nexport default reduceWhile;","import _curry1 from \"./internal/_curry1.js\";\nimport _reduced from \"./internal/_reduced.js\";\n/**\n * Returns a value wrapped to indicate that it is the final value of the reduce\n * and transduce functions. The returned value should be considered a black\n * box: the internal structure is not guaranteed to be stable.\n *\n * Note: this optimization is only available to the below functions:\n * - [`reduce`](#reduce)\n * - [`reduceWhile`](#reduceWhile)\n * - [`transduce`](#transduce)\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category List\n * @sig a -> *\n * @param {*} x The final value of the reduce.\n * @return {*} The wrapped value.\n * @see R.reduce, R.reduceWhile, R.transduce\n * @example\n *\n *     R.reduce(\n *       (acc, item) => item > 3 ? R.reduced(acc) : acc.concat(item),\n *       [],\n *       [1, 2, 3, 4, 5]) // [1, 2, 3]\n */\n\nvar reduced = /*#__PURE__*/_curry1(_reduced);\n\nexport default reduced;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @func\n * @memberOf R\n * @since v0.2.3\n * @category List\n * @sig (Number -> a) -> Number -> [a]\n * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n * @return {Array} An array containing the return values of all calls to `fn`.\n * @see R.repeat\n * @example\n *\n *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n * @symb R.times(f, 0) = []\n * @symb R.times(f, 1) = [f(0)]\n * @symb R.times(f, 2) = [f(0), f(1)]\n */\n\nvar times = /*#__PURE__*/_curry2(function times(fn, n) {\n  var len = Number(n);\n  var idx = 0;\n  var list;\n\n  if (len < 0 || isNaN(len)) {\n    throw new RangeError('n must be a non-negative number');\n  }\n\n  list = new Array(len);\n\n  while (idx < len) {\n    list[idx] = fn(idx);\n    idx += 1;\n  }\n\n  return list;\n});\n\nexport default times;","import _curry2 from \"./internal/_curry2.js\";\nimport always from \"./always.js\";\nimport times from \"./times.js\";\n/**\n * Returns a fixed list of size `n` containing a specified identical value.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig a -> n -> [a]\n * @param {*} value The value to repeat.\n * @param {Number} n The desired size of the output list.\n * @return {Array} A new array containing `n` `value`s.\n * @see R.times\n * @example\n *\n *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n *\n *      const obj = {};\n *      const repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n * @symb R.repeat(a, 0) = []\n * @symb R.repeat(a, 1) = [a]\n * @symb R.repeat(a, 2) = [a, a]\n */\n\nvar repeat = /*#__PURE__*/_curry2(function repeat(value, n) {\n  return times(always(value), n);\n});\n\nexport default repeat;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Scan is similar to [`reduce`](#reduce), but returns a list of successively\n * reduced values from the left\n *\n * @func\n * @memberOf R\n * @since v0.10.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 {Array} A list of all intermediately reduced values.\n * @see R.reduce, R.mapAccum\n * @example\n *\n *      const numbers = [1, 2, 3, 4];\n *      const factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n * @symb R.scan(f, a, [b, c]) = [a, f(a, b), f(f(a, b), c)]\n */\n\nvar scan = /*#__PURE__*/_curry3(function scan(fn, acc, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [acc];\n\n  while (idx < len) {\n    acc = fn(acc, list[idx]);\n    result[idx + 1] = acc;\n    idx += 1;\n  }\n\n  return result;\n});\n\nexport default scan;","import _curry2 from \"./internal/_curry2.js\";\nimport ap from \"./ap.js\";\nimport map from \"./map.js\";\nimport prepend from \"./prepend.js\";\nimport reduceRight from \"./reduceRight.js\";\n/**\n * Transforms a [Traversable](https://github.com/fantasyland/fantasy-land#traversable)\n * of [Applicative](https://github.com/fantasyland/fantasy-land#applicative) into an\n * Applicative of Traversable.\n *\n * Dispatches to the `sequence` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (Applicative f, Traversable t) => (a -> f a) -> t (f a) -> f (t a)\n * @param {Function} of\n * @param {*} traversable\n * @return {*}\n * @see R.traverse\n * @example\n *\n *      R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n *      R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n *\n *      R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)]\n *      R.sequence(R.of, Nothing());       //=> [Nothing()]\n */\n\nvar sequence = /*#__PURE__*/_curry2(function sequence(of, traversable) {\n  return typeof traversable.sequence === 'function' ? traversable.sequence(of) : reduceRight(function (x, acc) {\n    return ap(map(prepend, x), acc);\n  }, of([]), traversable);\n});\n\nexport default sequence;","import _curry3 from \"./internal/_curry3.js\";\nimport always from \"./always.js\";\nimport over from \"./over.js\";\n/**\n * Returns the result of \"setting\" the portion of the given data structure\n * focused by the given lens to the given value.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> a -> s -> s\n * @param {Lens} lens\n * @param {*} v\n * @param {*} x\n * @return {*}\n * @see R.prop, R.lensIndex, R.lensProp\n * @example\n *\n *      const xLens = R.lensProp('x');\n *\n *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n */\n\nvar set = /*#__PURE__*/_curry3(function set(lens, v, x) {\n  return over(lens, always(v), x);\n});\n\nexport default set;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Sorts a list according to a list of comparators.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Relation\n * @sig [(a, a) -> Number] -> [a] -> [a]\n * @param {Array} functions A list of comparator functions.\n * @param {Array} list The list to sort.\n * @return {Array} A new list sorted according to the comarator functions.\n * @example\n *\n *      const alice = {\n *        name: 'alice',\n *        age: 40\n *      };\n *      const bob = {\n *        name: 'bob',\n *        age: 30\n *      };\n *      const clara = {\n *        name: 'clara',\n *        age: 40\n *      };\n *      const people = [clara, bob, alice];\n *      const ageNameSort = R.sortWith([\n *        R.descend(R.prop('age')),\n *        R.ascend(R.prop('name'))\n *      ]);\n *      ageNameSort(people); //=> [alice, clara, bob]\n */\n\nvar sortWith = /*#__PURE__*/_curry2(function sortWith(fns, list) {\n  return Array.prototype.slice.call(list, 0).sort(function (a, b) {\n    var result = 0;\n    var i = 0;\n\n    while (result === 0 && i < fns.length) {\n      result = fns[i](a, b);\n      i += 1;\n    }\n\n    return result;\n  });\n});\n\nexport default sortWith;","import _curry2 from \"./internal/_curry2.js\";\nimport slice from \"./slice.js\";\n/**\n * Splits a collection into slices of the specified length.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [[a]]\n * @sig Number -> String -> [String]\n * @param {Number} n\n * @param {Array} list\n * @return {Array}\n * @example\n *\n *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n */\n\nvar splitEvery = /*#__PURE__*/_curry2(function splitEvery(n, list) {\n  if (n <= 0) {\n    throw new Error('First argument to splitEvery must be a positive integer');\n  }\n\n  var result = [];\n  var idx = 0;\n\n  while (idx < list.length) {\n    result.push(slice(idx, idx += n, list));\n  }\n\n  return result;\n});\n\nexport default splitEvery;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Takes a list and a predicate and returns a pair of lists with the following properties:\n *\n *  - the result of concatenating the two output lists is equivalent to the input list;\n *  - none of the elements of the first output list satisfies the predicate; and\n *  - if the second output list is non-empty, its first element satisfies the predicate.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [[a], [a]]\n * @param {Function} pred The predicate that determines where the array is split.\n * @param {Array} list The array to be split.\n * @return {Array}\n * @example\n *\n *      R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]);   //=> [[1], [2, 3, 1, 2, 3]]\n */\n\nvar splitWhen = /*#__PURE__*/_curry2(function splitWhen(pred, list) {\n  var idx = 0;\n  var len = list.length;\n  var prefix = [];\n\n  while (idx < len && !pred(list[idx])) {\n    prefix.push(list[idx]);\n    idx += 1;\n  }\n\n  return [prefix, Array.prototype.slice.call(list, idx)];\n});\n\nexport default splitWhen;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Subtracts its second argument from its first argument.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a - b`.\n * @see R.add\n * @example\n *\n *      R.subtract(10, 8); //=> 2\n *\n *      const minus5 = R.subtract(R.__, 5);\n *      minus5(17); //=> 12\n *\n *      const complementaryAngle = R.subtract(90);\n *      complementaryAngle(30); //=> 60\n *      complementaryAngle(72); //=> 18\n */\n\nvar subtract = /*#__PURE__*/_curry2(function subtract(a, b) {\n  return Number(a) - Number(b);\n});\n\nexport default subtract;","import _curry3 from \"./internal/_curry3.js\";\nimport concat from \"./concat.js\";\nimport differenceWith from \"./differenceWith.js\";\n/**\n * Finds the set (i.e. no duplicates) of all elements contained in the first or\n * second list, but not both. Duplication is determined according to the value\n * returned by applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` or `list2`, but not both.\n * @see R.symmetricDifference, R.difference, R.differenceWith\n * @example\n *\n *      const eqA = R.eqBy(R.prop('a'));\n *      const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];\n *      const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];\n *      R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]\n */\n\nvar symmetricDifferenceWith = /*#__PURE__*/_curry3(function symmetricDifferenceWith(pred, list1, list2) {\n  return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1));\n});\n\nexport default symmetricDifferenceWith;","import _curry2 from \"./internal/_curry2.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns a new list containing the last `n` elements of a given list, passing\n * each value to the supplied predicate function, and terminating when the\n * predicate function returns `false`. Excludes the element that caused the\n * predicate function to fail. The predicate function is passed one argument:\n * *(value)*.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropLastWhile, R.addIndex\n * @example\n *\n *      const isNotOne = x => x !== 1;\n *\n *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n *\n *      R.takeLastWhile(x => x !== 'R' , 'Ramda'); //=> 'amda'\n */\n\nvar takeLastWhile = /*#__PURE__*/_curry2(function takeLastWhile(fn, xs) {\n  var idx = xs.length - 1;\n\n  while (idx >= 0 && fn(xs[idx])) {\n    idx -= 1;\n  }\n\n  return slice(idx + 1, Infinity, xs);\n});\n\nexport default takeLastWhile;","import _curry2 from \"./_curry2.js\";\nimport _reduced from \"./_reduced.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XTakeWhile = /*#__PURE__*/function () {\n  function XTakeWhile(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n\n  XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n  };\n\n  return XTakeWhile;\n}();\n\nvar _xtakeWhile = /*#__PURE__*/_curry2(function _xtakeWhile(f, xf) {\n  return new XTakeWhile(f, xf);\n});\n\nexport default _xtakeWhile;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xtakeWhile from \"./internal/_xtakeWhile.js\";\nimport slice from \"./slice.js\";\n/**\n * Returns a new list containing the first `n` elements of a given list,\n * passing each value to the supplied predicate function, and terminating when\n * the predicate function returns `false`. Excludes the element that caused the\n * predicate function to fail. The predicate function is passed one argument:\n * *(value)*.\n *\n * Dispatches to the `takeWhile` 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 (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropWhile, R.transduce, R.addIndex\n * @example\n *\n *      const isNotFour = x => x !== 4;\n *\n *      R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]\n *\n *      R.takeWhile(x => x !== 'd' , 'Ramda'); //=> 'Ram'\n */\n\nvar takeWhile = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['takeWhile'], _xtakeWhile, function takeWhile(fn, xs) {\n  var idx = 0;\n  var len = xs.length;\n\n  while (idx < len && fn(xs[idx])) {\n    idx += 1;\n  }\n\n  return slice(0, idx, xs);\n}));\n\nexport default takeWhile;","import _curry2 from \"./_curry2.js\";\nimport _xfBase from \"./_xfBase.js\";\n\nvar XTap = /*#__PURE__*/function () {\n  function XTap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XTap.prototype['@@transducer/init'] = _xfBase.init;\n  XTap.prototype['@@transducer/result'] = _xfBase.result;\n\n  XTap.prototype['@@transducer/step'] = function (result, input) {\n    this.f(input);\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return XTap;\n}();\n\nvar _xtap = /*#__PURE__*/_curry2(function _xtap(f, xf) {\n  return new XTap(f, xf);\n});\n\nexport default _xtap;","import _curry2 from \"./internal/_curry2.js\";\nimport _dispatchable from \"./internal/_dispatchable.js\";\nimport _xtap from \"./internal/_xtap.js\";\n/**\n * Runs the given function with the supplied object, then returns the object.\n *\n * Acts as a transducer if a transformer is given as second parameter.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (a -> *) -> a -> a\n * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n * @param {*} x\n * @return {*} `x`.\n * @example\n *\n *      const sayX = x => console.log('x is ' + x);\n *      R.tap(sayX, 100); //=> 100\n *      // logs 'x is 100'\n * @symb R.tap(f, a) = a\n */\n\nvar tap = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xtap, function tap(fn, x) {\n  fn(x);\n  return x;\n}));\n\nexport default tap;","import _curry2 from \"./internal/_curry2.js\";\nimport _assertPromise from \"./internal/_assertPromise.js\";\n/**\n * Returns the result of applying the onSuccess function to the value inside\n * a successfully resolved promise. This is useful for working with promises\n * inside function compositions.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Function\n * @sig (a -> b) -> (Promise e a) -> (Promise e b)\n * @sig (a -> (Promise e b)) -> (Promise e a) -> (Promise e b)\n * @param {Function} onSuccess The function to apply. Can return a value or a promise of a value.\n * @param {Promise} p\n * @return {Promise} The result of calling `p.then(onSuccess)`\n * @see R.otherwise\n * @example\n *\n *      var makeQuery = (email) => ({ query: { email }});\n *\n *      //getMemberName :: String -> Promise ({firstName, lastName})\n *      var getMemberName = R.pipe(\n *        makeQuery,\n *        fetchMember,\n *        R.andThen(R.pick(['firstName', 'lastName']))\n *      );\n */\n\nvar andThen = /*#__PURE__*/_curry2(function andThen(f, p) {\n  _assertPromise('andThen', p);\n\n  return p.then(f);\n});\n\nexport default andThen;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Converts an object into an array of key, value arrays. The object's own\n * properties and prototype properties are used. Note that the order of the\n * output array is not guaranteed to be consistent across different JS\n * 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\n *         and prototype properties.\n * @example\n *\n *      const F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      const f = new F();\n *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n */\n\nvar toPairsIn = /*#__PURE__*/_curry1(function toPairsIn(obj) {\n  var pairs = [];\n\n  for (var prop in obj) {\n    pairs[pairs.length] = [prop, obj[prop]];\n  }\n\n  return pairs;\n});\n\nexport default toPairsIn;","import _reduce from \"./internal/_reduce.js\";\nimport _xwrap from \"./internal/_xwrap.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Initializes a transducer using supplied iterator function. Returns a single\n * item by iterating through the list, successively calling the transformed\n * iterator function and passing it an accumulator value and the current value\n * from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It will be\n * wrapped as a transformer to initialize the transducer. A transformer can be\n * passed directly in place of an iterator function. In both cases, iteration\n * may be stopped early with the [`R.reduced`](#reduced) function.\n *\n * A transducer is a function that accepts a transformer and returns a\n * transformer and can be composed directly.\n *\n * A transformer is an an object that provides a 2-arity reducing iterator\n * function, step, 0-arity initial value function, init, and 1-arity result\n * extraction function, result. The step function is used as the iterator\n * function in reduce. The result function is used to convert the final\n * accumulator into the return type and in most cases is\n * [`R.identity`](#identity). The init function can be used to provide an\n * initial accumulator, but is ignored by transduce.\n *\n * The iteration is performed with [`R.reduce`](#reduce) after initializing the transducer.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig (c -> c) -> ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array. Wrapped as transformer, if necessary, and used to\n *        initialize the transducer\n * @param {*} acc The initial accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.reduced, R.into\n * @example\n *\n *      const numbers = [1, 2, 3, 4];\n *      const transducer = R.compose(R.map(R.add(1)), R.take(2));\n *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n *\n *      const isOdd = (x) => x % 2 === 1;\n *      const firstOddTransducer = R.compose(R.filter(isOdd), R.take(1));\n *      R.transduce(firstOddTransducer, R.flip(R.append), [], R.range(0, 100)); //=> [1]\n */\n\nvar transduce = /*#__PURE__*/curryN(4, function transduce(xf, fn, acc, list) {\n  return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n});\nexport default transduce;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Transposes the rows and columns of a 2D list.\n * When passed a list of `n` lists of length `x`,\n * returns a list of `x` lists of length `n`.\n *\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig [[a]] -> [[a]]\n * @param {Array} list A 2D list\n * @return {Array} A 2D list\n * @example\n *\n *      R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']]\n *      R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n *\n *      // If some of the rows are shorter than the following rows, their elements are skipped:\n *      R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]\n * @symb R.transpose([[a], [b], [c]]) = [a, b, c]\n * @symb R.transpose([[a, b], [c, d]]) = [[a, c], [b, d]]\n * @symb R.transpose([[a, b], [c]]) = [[a, c], [b]]\n */\n\nvar transpose = /*#__PURE__*/_curry1(function transpose(outerlist) {\n  var i = 0;\n  var result = [];\n\n  while (i < outerlist.length) {\n    var innerlist = outerlist[i];\n    var j = 0;\n\n    while (j < innerlist.length) {\n      if (typeof result[j] === 'undefined') {\n        result[j] = [];\n      }\n\n      result[j].push(innerlist[j]);\n      j += 1;\n    }\n\n    i += 1;\n  }\n\n  return result;\n});\n\nexport default transpose;","import _curry3 from \"./internal/_curry3.js\";\nimport map from \"./map.js\";\nimport sequence from \"./sequence.js\";\n/**\n * Maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning\n * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),\n * then uses [`sequence`](#sequence) to transform the resulting Traversable of Applicative\n * into an Applicative of Traversable.\n *\n * Dispatches to the `traverse` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (Applicative f, Traversable t) => (a -> f a) -> (a -> f b) -> t a -> f (t b)\n * @param {Function} of\n * @param {Function} f\n * @param {*} traversable\n * @return {*}\n * @see R.sequence\n * @example\n *\n *      // Returns `Maybe.Nothing` if the given divisor is `0`\n *      const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d)\n *\n *      R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Maybe.Just([5, 2.5, 2])\n *      R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Maybe.Nothing\n */\n\nvar traverse = /*#__PURE__*/_curry3(function traverse(of, f, traversable) {\n  return typeof traversable['fantasy-land/traverse'] === 'function' ? traversable['fantasy-land/traverse'](f, of) : sequence(of, map(f, traversable));\n});\n\nexport default traverse;","import _curry1 from \"./internal/_curry1.js\";\nvar ws = '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\nvar zeroWidth = '\\u200b';\nvar hasProtoTrim = typeof String.prototype.trim === 'function';\n/**\n * Removes (strips) whitespace from both ends of the string.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to trim.\n * @return {String} Trimmed version of `str`.\n * @example\n *\n *      R.trim('   xyz  '); //=> 'xyz'\n *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n */\n\nvar trim = !hasProtoTrim || /*#__PURE__*/ws.trim() || ! /*#__PURE__*/zeroWidth.trim() ? /*#__PURE__*/_curry1(function trim(str) {\n  var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n  var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n  return str.replace(beginRx, '').replace(endRx, '');\n}) : /*#__PURE__*/_curry1(function trim(str) {\n  return str.trim();\n});\nexport default trim;","import _arity from \"./internal/_arity.js\";\nimport _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * `tryCatch` takes two functions, a `tryer` and a `catcher`. The returned\n * function evaluates the `tryer`; if it does not throw, it simply returns the\n * result. If the `tryer` *does* throw, the returned function evaluates the\n * `catcher` function and returns its result. Note that for effective\n * composition with this function, both the `tryer` and `catcher` functions\n * must return the same type of results.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Function\n * @sig (...x -> a) -> ((e, ...x) -> a) -> (...x -> a)\n * @param {Function} tryer The function that may throw.\n * @param {Function} catcher The function that will be evaluated if `tryer` throws.\n * @return {Function} A new function that will catch exceptions and send then to the catcher.\n * @example\n *\n *      R.tryCatch(R.prop('x'), R.F)({x: true}); //=> true\n *      R.tryCatch(() => { throw 'foo'}, R.always('catched'))('bar') // => 'catched'\n *      R.tryCatch(R.times(R.identity), R.always([]))('s') // => []\n *      R.tryCatch(() => { throw 'this is not a valid value'}, (err, value)=>({error : err,  value }))('bar') // => {'error': 'this is not a valid value', 'value': 'bar'}\n */\n\nvar tryCatch = /*#__PURE__*/_curry2(function _tryCatch(tryer, catcher) {\n  return _arity(tryer.length, function () {\n    try {\n      return tryer.apply(this, arguments);\n    } catch (e) {\n      return catcher.apply(this, _concat([e], arguments));\n    }\n  });\n});\n\nexport default tryCatch;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Takes a function `fn`, which takes a single array argument, and returns a\n * function which:\n *\n *   - takes any number of positional arguments;\n *   - passes these arguments to `fn` as an array; and\n *   - returns the result.\n *\n * In other words, `R.unapply` derives a variadic function from a function which\n * takes an array. `R.unapply` is the inverse of [`R.apply`](#apply).\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Function\n * @sig ([*...] -> a) -> (*... -> a)\n * @param {Function} fn\n * @return {Function}\n * @see R.apply\n * @example\n *\n *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n * @symb R.unapply(f)(a, b) = f([a, b])\n */\n\nvar unapply = /*#__PURE__*/_curry1(function unapply(fn) {\n  return function () {\n    return fn(Array.prototype.slice.call(arguments, 0));\n  };\n});\n\nexport default unapply;","import _curry1 from \"./internal/_curry1.js\";\nimport nAry from \"./nAry.js\";\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly 1 parameter. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Function\n * @sig (* -> b) -> (a -> b)\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n *         arity 1.\n * @see R.binary, R.nAry\n * @example\n *\n *      const takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      const takesOneArg = R.unary(takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // Only 1 argument is passed to the wrapped function\n *      takesOneArg(1, 2); //=> [1, undefined]\n * @symb R.unary(f)(a, b, c) = f(a)\n */\n\nvar unary = /*#__PURE__*/_curry1(function unary(fn) {\n  return nAry(1, fn);\n});\n\nexport default unary;","import _curry2 from \"./internal/_curry2.js\";\nimport curryN from \"./curryN.js\";\n/**\n * Returns a function of arity `n` from a (manually) curried function.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Function\n * @sig Number -> (a -> b) -> (a -> c)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to uncurry.\n * @return {Function} A new function.\n * @see R.curry\n * @example\n *\n *      const addFour = a => b => c => d => a + b + c + d;\n *\n *      const uncurriedAddFour = R.uncurryN(4, addFour);\n *      uncurriedAddFour(1, 2, 3, 4); //=> 10\n */\n\nvar uncurryN = /*#__PURE__*/_curry2(function uncurryN(depth, fn) {\n  return curryN(depth, function () {\n    var currentDepth = 1;\n    var value = fn;\n    var idx = 0;\n    var endIdx;\n\n    while (currentDepth <= depth && typeof value === 'function') {\n      endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n      value = value.apply(this, Array.prototype.slice.call(arguments, idx, endIdx));\n      currentDepth += 1;\n      idx = endIdx;\n    }\n\n    return value;\n  });\n});\n\nexport default uncurryN;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Builds a list from a seed value. Accepts an iterator function, which returns\n * either false to stop iteration or an array of length 2 containing the value\n * to add to the resulting list and the seed to be used in the next call to the\n * iterator function.\n *\n * The iterator function receives one argument: *(seed)*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig (a -> [b]) -> * -> [b]\n * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n *        either false to quit iteration or an array of length two to proceed. The element\n *        at index 0 of this array will be added to the resulting array, and the element\n *        at index 1 will be passed to the next call to `fn`.\n * @param {*} seed The seed value.\n * @return {Array} The final list.\n * @example\n *\n *      const f = n => n > 50 ? false : [-n, n + 10];\n *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n * @symb R.unfold(f, x) = [f(x)[0], f(f(x)[1])[0], f(f(f(x)[1])[1])[0], ...]\n */\n\nvar unfold = /*#__PURE__*/_curry2(function unfold(fn, seed) {\n  var pair = fn(seed);\n  var result = [];\n\n  while (pair && pair.length) {\n    result[result.length] = pair[0];\n    pair = fn(pair[1]);\n  }\n\n  return result;\n});\n\nexport default unfold;","import _concat from \"./internal/_concat.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport compose from \"./compose.js\";\nimport uniq from \"./uniq.js\";\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of the elements\n * of each list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} as The first list.\n * @param {Array} bs The second list.\n * @return {Array} The first and second lists concatenated, with\n *         duplicates removed.\n * @example\n *\n *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n */\n\nvar union = /*#__PURE__*/_curry2( /*#__PURE__*/compose(uniq, _concat));\n\nexport default union;","import _includesWith from \"./internal/_includesWith.js\";\nimport _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a new list containing only one copy of each element in the original\n * list, based upon the value returned by applying the supplied predicate to\n * two list elements. Prefers the first item if two items compare equal based\n * on the predicate.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category List\n * @sig ((a, a) -> Boolean) -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      const strEq = R.eqBy(String);\n *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n */\n\nvar uniqWith = /*#__PURE__*/_curry2(function uniqWith(pred, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n  var item;\n\n  while (idx < len) {\n    item = list[idx];\n\n    if (!_includesWith(pred, item, result)) {\n      result[result.length] = item;\n    }\n\n    idx += 1;\n  }\n\n  return result;\n});\n\nexport default uniqWith;","import _concat from \"./internal/_concat.js\";\nimport _curry3 from \"./internal/_curry3.js\";\nimport uniqWith from \"./uniqWith.js\";\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of the elements\n * of each list. Duplication is determined according to the value returned by\n * applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [*] -> [*] -> [*]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The first and second lists concatenated, with\n *         duplicates removed.\n * @see R.union\n * @example\n *\n *      const l1 = [{a: 1}, {a: 2}];\n *      const l2 = [{a: 1}, {a: 4}];\n *      R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n */\n\nvar unionWith = /*#__PURE__*/_curry3(function unionWith(pred, list1, list2) {\n  return uniqWith(pred, _concat(list1, list2));\n});\n\nexport default unionWith;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Takes a predicate, a transformation function, and an initial value,\n * and returns a value of the same type as the initial value.\n * It does so by applying the transformation until the predicate is satisfied,\n * at which point it returns the satisfactory value.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred A predicate function\n * @param {Function} fn The iterator function\n * @param {*} init Initial value\n * @return {*} Final value that satisfies predicate\n * @example\n *\n *      R.until(R.gt(R.__, 100), R.multiply(2))(1) // => 128\n */\n\nvar until = /*#__PURE__*/_curry3(function until(pred, fn, init) {\n  var val = init;\n\n  while (!pred(val)) {\n    val = fn(val);\n  }\n\n  return val;\n});\n\nexport default until;","import _curry1 from \"./internal/_curry1.js\";\n/**\n * Returns a list of all the properties, including prototype properties, of the\n * 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.2.0\n * @category Object\n * @sig {k: v} -> [v]\n * @param {Object} obj The object to extract values from\n * @return {Array} An array of the values of the object's own and prototype properties.\n * @see R.values, R.keysIn\n * @example\n *\n *      const F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      const f = new F();\n *      R.valuesIn(f); //=> ['X', 'Y']\n */\n\nvar valuesIn = /*#__PURE__*/_curry1(function valuesIn(obj) {\n  var prop;\n  var vs = [];\n\n  for (prop in obj) {\n    vs[vs.length] = obj[prop];\n  }\n\n  return vs;\n});\n\nexport default valuesIn;","import _curry2 from \"./internal/_curry2.js\"; // `Const` is a functor that effectively ignores the function given to `map`.\n\nvar Const = function (x) {\n  return {\n    value: x,\n    'fantasy-land/map': function () {\n      return this;\n    }\n  };\n};\n/**\n * Returns a \"view\" of the given data structure, determined by the given lens.\n * The lens's focus determines which portion of the data structure is visible.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> s -> a\n * @param {Lens} lens\n * @param {*} x\n * @return {*}\n * @see R.prop, R.lensIndex, R.lensProp\n * @example\n *\n *      const xLens = R.lensProp('x');\n *\n *      R.view(xLens, {x: 1, y: 2});  //=> 1\n *      R.view(xLens, {x: 4, y: 2});  //=> 4\n */\n\n\nvar view = /*#__PURE__*/_curry2(function view(lens, x) {\n  // Using `Const` effectively ignores the setter function of the `lens`,\n  // leaving the value returned by the getter function unmodified.\n  return lens(Const)(x).value;\n});\n\nexport default view;","import _curry2 from \"./internal/_curry2.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Takes a spec object and a test object; returns true if the test satisfies\n * the spec. Each of the spec's own properties must be a predicate function.\n * Each predicate is applied to the value of the corresponding property of the\n * test object. `where` returns true if all the predicates return true, false\n * otherwise.\n *\n * `where` is well suited to declaratively expressing constraints for other\n * functions such as [`filter`](#filter) and [`find`](#find).\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category Object\n * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n * @param {Object} spec\n * @param {Object} testObj\n * @return {Boolean}\n * @see R.propSatisfies, R.whereEq\n * @example\n *\n *      // pred :: Object -> Boolean\n *      const pred = R.where({\n *        a: R.equals('foo'),\n *        b: R.complement(R.equals('bar')),\n *        x: R.gt(R.__, 10),\n *        y: R.lt(R.__, 20)\n *      });\n *\n *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n */\n\nvar where = /*#__PURE__*/_curry2(function where(spec, testObj) {\n  for (var prop in spec) {\n    if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n      return false;\n    }\n  }\n\n  return true;\n});\n\nexport default where;","import _curry2 from \"./internal/_curry2.js\";\nimport equals from \"./equals.js\";\nimport map from \"./map.js\";\nimport where from \"./where.js\";\n/**\n * Takes a spec object and a test object; returns true if the test satisfies\n * the spec, false otherwise. An object satisfies the spec if, for each of the\n * spec's own properties, accessing that property of the object gives the same\n * value (in [`R.equals`](#equals) terms) as accessing that property of the\n * spec.\n *\n * `whereEq` is a specialization of [`where`](#where).\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @sig {String: *} -> {String: *} -> Boolean\n * @param {Object} spec\n * @param {Object} testObj\n * @return {Boolean}\n * @see R.propEq, R.where\n * @example\n *\n *      // pred :: Object -> Boolean\n *      const pred = R.whereEq({a: 1, b: 2});\n *\n *      pred({a: 1});              //=> false\n *      pred({a: 1, b: 2});        //=> true\n *      pred({a: 1, b: 2, c: 3});  //=> true\n *      pred({a: 1, b: 1});        //=> false\n */\n\nvar whereEq = /*#__PURE__*/_curry2(function whereEq(spec, testObj) {\n  return where(map(equals, spec), testObj);\n});\n\nexport default whereEq;","import _includes from \"./internal/_includes.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport flip from \"./flip.js\";\nimport reject from \"./reject.js\";\n/**\n * Returns a new list without values in the first argument.\n * [`R.equals`](#equals) is used to determine equality.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig [a] -> [a] -> [a]\n * @param {Array} list1 The values to be removed from `list2`.\n * @param {Array} list2 The array to remove values from.\n * @return {Array} The new array without values in `list1`.\n * @see R.transduce, R.difference, R.remove\n * @example\n *\n *      R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]\n */\n\nvar without = /*#__PURE__*/_curry2(function (xs, list) {\n  return reject(flip(_includes)(xs), list);\n});\n\nexport default without;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Exclusive disjunction logical operation.\n * Returns `true` if one of the arguments is truthy and the other is falsy.\n * Otherwise, it returns `false`.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Logic\n * @sig a -> b -> Boolean\n * @param {Any} a\n * @param {Any} b\n * @return {Boolean} true if one of the arguments is truthy and the other is falsy\n * @see R.or, R.and\n * @example\n *\n *      R.xor(true, true); //=> false\n *      R.xor(true, false); //=> true\n *      R.xor(false, true); //=> true\n *      R.xor(false, false); //=> false\n */\n\nvar xor = /*#__PURE__*/_curry2(function xor(a, b) {\n  return Boolean(!a ^ !b);\n});\n\nexport default xor;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new list out of the two supplied by creating each possible pair\n * from the lists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b] -> [[a,b]]\n * @param {Array} as The first list.\n * @param {Array} bs The second list.\n * @return {Array} The list made by combining each possible pair from\n *         `as` and `bs` into pairs (`[a, b]`).\n * @example\n *\n *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n * @symb R.xprod([a, b], [c, d]) = [[a, c], [a, d], [b, c], [b, d]]\n */\n\nvar xprod = /*#__PURE__*/_curry2(function xprod(a, b) {\n  // = xprodWith(prepend); (takes about 3 times as long...)\n  var idx = 0;\n  var ilen = a.length;\n  var j;\n  var jlen = b.length;\n  var result = [];\n\n  while (idx < ilen) {\n    j = 0;\n\n    while (j < jlen) {\n      result[result.length] = [a[idx], b[j]];\n      j += 1;\n    }\n\n    idx += 1;\n  }\n\n  return result;\n});\n\nexport default xprod;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Creates a new list out of the two supplied by pairing up equally-positioned\n * items from both lists. The returned list is truncated to the length of the\n * shorter of the two input lists.\n * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b] -> [[a,b]]\n * @param {Array} list1 The first array to consider.\n * @param {Array} list2 The second array to consider.\n * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n * @example\n *\n *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n * @symb R.zip([a, b, c], [d, e, f]) = [[a, d], [b, e], [c, f]]\n */\n\nvar zip = /*#__PURE__*/_curry2(function zip(a, b) {\n  var rv = [];\n  var idx = 0;\n  var len = Math.min(a.length, b.length);\n\n  while (idx < len) {\n    rv[idx] = [a[idx], b[idx]];\n    idx += 1;\n  }\n\n  return rv;\n});\n\nexport default zip;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Creates a new list out of the two supplied by applying the function to each\n * equally-positioned pair in the lists. The returned list is truncated to the\n * length of the shorter of the two input lists.\n *\n * @function\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> c) -> [a] -> [b] -> [c]\n * @param {Function} fn The function used to combine the two elements into one value.\n * @param {Array} list1 The first array to consider.\n * @param {Array} list2 The second array to consider.\n * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n *         using `fn`.\n * @example\n *\n *      const f = (x, y) => {\n *        // ...\n *      };\n *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n * @symb R.zipWith(fn, [a, b, c], [d, e, f]) = [fn(a, d), fn(b, e), fn(c, f)]\n */\n\nvar zipWith = /*#__PURE__*/_curry3(function zipWith(fn, a, b) {\n  var rv = [];\n  var idx = 0;\n  var len = Math.min(a.length, b.length);\n\n  while (idx < len) {\n    rv[idx] = fn(a[idx], b[idx]);\n    idx += 1;\n  }\n\n  return rv;\n});\n\nexport default zipWith;","import curryN from \"./curryN.js\";\nimport _curry1 from \"./internal/_curry1.js\";\n/**\n * Creates a thunk out of a function. A thunk delays a calculation until\n * its result is needed, providing lazy evaluation of arguments.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig ((a, b, ..., j) -> k) -> (a, b, ..., j) -> (() -> k)\n * @param {Function} fn A function to wrap in a thunk\n * @return {Function} Expects arguments for `fn` and returns a new function\n *  that, when called, applies those arguments to `fn`.\n * @see R.partial, R.partialRight\n * @example\n *\n *      R.thunkify(R.identity)(42)(); //=> 42\n *      R.thunkify((a, b) => a + b)(25, 17)(); //=> 42\n */\n\nvar thunkify = /*#__PURE__*/_curry1(function thunkify(fn) {\n  return curryN(fn.length, function createThunk() {\n    var fnArgs = arguments;\n    return function invokeThunk() {\n      return fn.apply(this, fnArgs);\n    };\n  });\n});\n\nexport default thunkify;","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Tests the final argument by passing it to the given predicate function. If\n * the predicate is not satisfied, the function will return the result of\n * calling the `whenFalseFn` function with the same argument. If the predicate\n * is satisfied, the argument is returned as is.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred        A predicate function\n * @param {Function} whenFalseFn A function to invoke when the `pred` evaluates\n *                               to a falsy value.\n * @param {*}        x           An object to test with the `pred` function and\n *                               pass to `whenFalseFn` if necessary.\n * @return {*} Either `x` or the result of applying `x` to `whenFalseFn`.\n * @see R.ifElse, R.when, R.cond\n * @example\n *\n *      let safeInc = R.unless(R.isNil, R.inc);\n *      safeInc(null); //=> null\n *      safeInc(1); //=> 2\n */\n\nvar unless = /*#__PURE__*/_curry3(function unless(pred, whenFalseFn, x) {\n  return pred(x) ? x : whenFalseFn(x);\n});\n\nexport default unless;","import _indexOf from \"./_indexOf.js\";\nexport default function _includes(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n}","import lift from \"./lift.js\";\nimport not from \"./not.js\";\n/**\n * Takes a function `f` and returns a function `g` such that if called with the same arguments\n * when `f` returns a \"truthy\" value, `g` returns `false` and when `f` returns a \"falsy\" value `g` returns `true`.\n *\n * `R.complement` may be applied to any functor\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> *) -> (*... -> Boolean)\n * @param {Function} f\n * @return {Function}\n * @see R.not\n * @example\n *\n *      const isNotNil = R.complement(R.isNil);\n *      isNil(null); //=> true\n *      isNotNil(null); //=> false\n *      isNil(7); //=> false\n *      isNotNil(7); //=> true\n */\n\nvar complement = /*#__PURE__*/lift(not);\nexport default complement;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns the second argument if it is not `null`, `undefined` or `NaN`;\n * otherwise the first argument is returned.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {a} default The default value.\n * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.\n * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value\n * @example\n *\n *      const defaultTo42 = R.defaultTo(42);\n *\n *      defaultTo42(null);  //=> 42\n *      defaultTo42(undefined);  //=> 42\n *      defaultTo42(false);  //=> false\n *      defaultTo42('Ramda');  //=> 'Ramda'\n *      // parseInt('string') results in NaN\n *      defaultTo42(parseInt('string')); //=> 42\n */\n\nvar defaultTo = /*#__PURE__*/_curry2(function defaultTo(d, v) {\n  return v == null || v !== v ? d : v;\n});\n\nexport default defaultTo;","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar has = require('../internals/has');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!has(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n    if (NATIVE_SYMBOL && has(Symbol, name)) {\n      WellKnownSymbolsStore[name] = Symbol[name];\n    } else {\n      WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n    }\n  } return WellKnownSymbolsStore[name];\n};\n","import _curry1 from \"./internal/_curry1.js\";\nimport _isArguments from \"./internal/_isArguments.js\";\nimport _isArray from \"./internal/_isArray.js\";\nimport _isObject from \"./internal/_isObject.js\";\nimport _isString from \"./internal/_isString.js\";\n/**\n * Returns the empty value of its argument's type. Ramda defines the empty\n * value of Array (`[]`), Object (`{}`), String (`''`), and Arguments. Other\n * types are supported if they define `<Type>.empty`,\n * `<Type>.prototype.empty` or implement the\n * [FantasyLand Monoid spec](https://github.com/fantasyland/fantasy-land#monoid).\n *\n * Dispatches to the `empty` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig a -> a\n * @param {*} x\n * @return {*}\n * @example\n *\n *      R.empty(Just(42));      //=> Nothing()\n *      R.empty([1, 2, 3]);     //=> []\n *      R.empty('unicorns');    //=> ''\n *      R.empty({x: 1, y: 2});  //=> {}\n */\n\nvar empty = /*#__PURE__*/_curry1(function empty(x) {\n  return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {\n    return arguments;\n  }() : void 0 // else\n  ;\n});\n\nexport default empty;","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}","// 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;","var isObject = require('../internals/is-object');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (input, PREFERRED_STRING) {\n  if (!isObject(input)) return input;\n  var fn, val;\n  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","import _has from \"./_has.js\"; // Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n\nfunction _objectAssign(target) {\n  if (target == null) {\n    throw new TypeError('Cannot convert undefined or null to object');\n  }\n\n  var output = Object(target);\n  var idx = 1;\n  var length = arguments.length;\n\n  while (idx < length) {\n    var source = arguments[idx];\n\n    if (source != null) {\n      for (var nextKey in source) {\n        if (_has(nextKey, source)) {\n          output[nextKey] = source[nextKey];\n        }\n      }\n    }\n\n    idx += 1;\n  }\n\n  return output;\n}\n\nexport default typeof Object.assign === 'function' ? Object.assign : _objectAssign;","export default function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}","import _arity from \"./internal/_arity.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _has from \"./internal/_has.js\";\n/**\n * Creates a new function that, when invoked, caches the result of calling `fn`\n * for a given argument set and returns the result. Subsequent calls to the\n * memoized `fn` with the same argument set will not result in an additional\n * call to `fn`; instead, the cached result for that set of arguments will be\n * returned.\n *\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Function\n * @sig (*... -> String) -> (*... -> a) -> (*... -> a)\n * @param {Function} fn The function to generate the cache key.\n * @param {Function} fn The function to memoize.\n * @return {Function} Memoized version of `fn`.\n * @example\n *\n *      let count = 0;\n *      const factorial = R.memoizeWith(R.identity, n => {\n *        count += 1;\n *        return R.product(R.range(1, n + 1));\n *      });\n *      factorial(5); //=> 120\n *      factorial(5); //=> 120\n *      factorial(5); //=> 120\n *      count; //=> 1\n */\n\nvar memoizeWith = /*#__PURE__*/_curry2(function memoizeWith(mFn, fn) {\n  var cache = {};\n  return _arity(fn.length, function () {\n    var key = mFn.apply(this, arguments);\n\n    if (!_has(key, cache)) {\n      cache[key] = fn.apply(this, arguments);\n    }\n\n    return cache[key];\n  });\n});\n\nexport default memoizeWith;","module.exports = false;\n","import _curry3 from \"./internal/_curry3.js\";\n/**\n * Makes an ascending comparator function out of a function that returns a value\n * that can be compared with `<` and `>`.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Function\n * @sig Ord b => (a -> b) -> a -> a -> Number\n * @param {Function} fn A function of arity one that returns a value that can be compared\n * @param {*} a The first item to be compared.\n * @param {*} b The second item to be compared.\n * @return {Number} `-1` if fn(a) < fn(b), `1` if fn(b) < fn(a), otherwise `0`\n * @see R.descend\n * @example\n *\n *      const byAge = R.ascend(R.prop('age'));\n *      const people = [\n *        { name: 'Emma', age: 70 },\n *        { name: 'Peter', age: 78 },\n *        { name: 'Mikhail', age: 62 },\n *      ];\n *      const peopleByYoungestFirst = R.sort(byAge, people);\n *        //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]\n */\n\nvar ascend = /*#__PURE__*/_curry3(function ascend(fn, a, b) {\n  var aa = fn(a);\n  var bb = fn(b);\n  return aa < bb ? -1 : aa > bb ? 1 : 0;\n});\n\nexport default ascend;","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","const plugins = require(`./api-runner-browser-plugins`)\nconst {\n  getResourcesForPathname,\n  getResourcesForPathnameSync,\n  getResourceURLsForPathname,\n  loadPage,\n  loadPageSync,\n} = require(`./loader`).publicLoader\n\nexports.apiRunner = (api, args = {}, defaultReturn, argTransform) => {\n  // Hooks for gatsby-cypress's API handler\n  if (process.env.CYPRESS_SUPPORT) {\n    if (window.___apiHandler) {\n      window.___apiHandler(api)\n    } else if (window.___resolvedAPIs) {\n      window.___resolvedAPIs.push(api)\n    } else {\n      window.___resolvedAPIs = [api]\n    }\n  }\n\n  let results = plugins.map(plugin => {\n    if (!plugin.plugin[api]) {\n      return undefined\n    }\n\n    // Deprecated April 2019. Use `loadPageSync` instead\n    args.getResourcesForPathnameSync = getResourcesForPathnameSync\n    // Deprecated April 2019. Use `loadPage` instead\n    args.getResourcesForPathname = getResourcesForPathname\n    args.getResourceURLsForPathname = getResourceURLsForPathname\n    args.loadPage = loadPage\n    args.loadPageSync = loadPageSync\n\n    const result = plugin.plugin[api](args, plugin.options)\n    if (result && argTransform) {\n      args = argTransform({ args, result, plugin })\n    }\n    return result\n  })\n\n  // Filter out undefined results.\n  results = results.filter(result => typeof result !== `undefined`)\n\n  if (results.length > 0) {\n    return results\n  } else if (defaultReturn) {\n    return [defaultReturn]\n  } else {\n    return []\n  }\n}\n\nexports.apiRunnerAsync = (api, args, defaultReturn) =>\n  plugins.reduce(\n    (previous, next) =>\n      next.plugin[api]\n        ? previous.then(() => next.plugin[api](args, next.options))\n        : previous,\n    Promise.resolve()\n  )\n","import _curry2 from \"./internal/_curry2.js\";\nimport _isFunction from \"./internal/_isFunction.js\";\nimport and from \"./and.js\";\nimport lift from \"./lift.js\";\n/**\n * A function which calls the two provided functions and returns the `&&`\n * of the results.\n * It returns the result of the first function if it is false-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * false-y value.\n *\n * In addition to functions, `R.both` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f A predicate\n * @param {Function} g Another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n * @see R.and\n * @example\n *\n *      const gt10 = R.gt(R.__, 10)\n *      const lt20 = R.lt(R.__, 20)\n *      const f = R.both(gt10, lt20);\n *      f(15); //=> true\n *      f(30); //=> false\n *\n *      R.both(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(false)\n *      R.both([false, false, 'a'], [11]); //=> [false, false, 11]\n */\n\nvar both = /*#__PURE__*/_curry2(function both(f, g) {\n  return _isFunction(f) ? function _both() {\n    return f.apply(this, arguments) && g.apply(this, arguments);\n  } : lift(and)(f, g);\n});\n\nexport default both;","import _curry2 from \"./internal/_curry2.js\";\n/**\n * Returns a copy of the list, sorted according to the comparator function,\n * which should accept two values at a time and return a negative number if the\n * first value is smaller, a positive number if it's larger, and zero if they\n * are equal. Please note that this is a **copy** of the list. It does not\n * modify the original.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, a) -> Number) -> [a] -> [a]\n * @param {Function} comparator A sorting function :: a -> b -> Int\n * @param {Array} list The list to sort\n * @return {Array} a new array with its elements sorted by the comparator function.\n * @example\n *\n *      const diff = function(a, b) { return a - b; };\n *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n */\n\nvar sort = /*#__PURE__*/_curry2(function sort(comparator, list) {\n  return Array.prototype.slice.call(list, 0).sort(comparator);\n});\n\nexport default sort;","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","var has = require('../internals/has');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~indexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","import _curry1 from \"./internal/_curry1.js\";\nimport curryN from \"./curryN.js\";\nimport max from \"./max.js\";\nimport pluck from \"./pluck.js\";\nimport reduce from \"./reduce.js\";\n/**\n * Takes a list of predicates and returns a predicate that returns true for a\n * given list of arguments if every one of the provided predicates is satisfied\n * by those arguments.\n *\n * The function returned is a curried function whose arity matches that of the\n * highest-arity predicate.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Logic\n * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n * @param {Array} predicates An array of predicates to check\n * @return {Function} The combined predicate\n * @see R.anyPass\n * @example\n *\n *      const isQueen = R.propEq('rank', 'Q');\n *      const isSpade = R.propEq('suit', '♠︎');\n *      const isQueenOfSpades = R.allPass([isQueen, isSpade]);\n *\n *      isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false\n *      isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true\n */\n\nvar allPass = /*#__PURE__*/_curry1(function allPass(preds) {\n  return curryN(reduce(max, 0, pluck('length', preds)), function () {\n    var idx = 0;\n    var len = preds.length;\n\n    while (idx < len) {\n      if (!preds[idx].apply(this, arguments)) {\n        return false;\n      }\n\n      idx += 1;\n    }\n\n    return true;\n  });\n});\n\nexport default allPass;","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nmodule.exports = function (key, value) {\n  try {\n    createNonEnumerableProperty(global, key, value);\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","import _cloneRegExp from \"./internal/_cloneRegExp.js\";\nimport _curry2 from \"./internal/_curry2.js\";\nimport _isRegExp from \"./internal/_isRegExp.js\";\nimport toString from \"./toString.js\";\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @see R.match\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\n\nvar test = /*#__PURE__*/_curry2(function test(pattern, str) {\n  if (!_isRegExp(pattern)) {\n    throw new TypeError('‘test’ requires a value of type RegExp as its first argument; received ' + toString(pattern));\n  }\n\n  return _cloneRegExp(pattern).test(str);\n});\n\nexport default test;","export default function _isRegExp(x) {\n  return Object.prototype.toString.call(x) === '[object RegExp]';\n}"],"sourceRoot":""}