{"version":3,"file":"js/7897-af17eab0bf870d463d3a.js","mappings":"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","sources":["webpack://hover-mainsite/./node_modules/ramda/index.js","webpack://hover-mainsite/./node_modules/ramda/src/F.js","webpack://hover-mainsite/./node_modules/ramda/src/T.js","webpack://hover-mainsite/./node_modules/ramda/src/__.js","webpack://hover-mainsite/./node_modules/ramda/src/add.js","webpack://hover-mainsite/./node_modules/ramda/src/addIndex.js","webpack://hover-mainsite/./node_modules/ramda/src/adjust.js","webpack://hover-mainsite/./node_modules/ramda/src/all.js","webpack://hover-mainsite/./node_modules/ramda/src/allPass.js","webpack://hover-mainsite/./node_modules/ramda/src/always.js","webpack://hover-mainsite/./node_modules/ramda/src/and.js","webpack://hover-mainsite/./node_modules/ramda/src/any.js","webpack://hover-mainsite/./node_modules/ramda/src/anyPass.js","webpack://hover-mainsite/./node_modules/ramda/src/ap.js","webpack://hover-mainsite/./node_modules/ramda/src/aperture.js","webpack://hover-mainsite/./node_modules/ramda/src/append.js","webpack://hover-mainsite/./node_modules/ramda/src/apply.js","webpack://hover-mainsite/./node_modules/ramda/src/applySpec.js","webpack://hover-mainsite/./node_modules/ramda/src/ascend.js","webpack://hover-mainsite/./node_modules/ramda/src/assoc.js","webpack://hover-mainsite/./node_modules/ramda/src/assocPath.js","webpack://hover-mainsite/./node_modules/ramda/src/binary.js","webpack://hover-mainsite/./node_modules/ramda/src/bind.js","webpack://hover-mainsite/./node_modules/ramda/src/both.js","webpack://hover-mainsite/./node_modules/ramda/src/call.js","webpack://hover-mainsite/./node_modules/ramda/src/chain.js","webpack://hover-mainsite/./node_modules/ramda/src/clamp.js","webpack://hover-mainsite/./node_modules/ramda/src/clone.js","webpack://hover-mainsite/./node_modules/ramda/src/comparator.js","webpack://hover-mainsite/./node_modules/ramda/src/complement.js","webpack://hover-mainsite/./node_modules/ramda/src/compose.js","webpack://hover-mainsite/./node_modules/ramda/src/composeK.js","webpack://hover-mainsite/./node_modules/ramda/src/composeP.js","webpack://hover-mainsite/./node_modules/ramda/src/concat.js","webpack://hover-mainsite/./node_modules/ramda/src/cond.js","webpack://hover-mainsite/./node_modules/ramda/src/construct.js","webpack://hover-mainsite/./node_modules/ramda/src/constructN.js","webpack://hover-mainsite/./node_modules/ramda/src/contains.js","webpack://hover-mainsite/./node_modules/ramda/src/converge.js","webpack://hover-mainsite/./node_modules/ramda/src/countBy.js","webpack://hover-mainsite/./node_modules/ramda/src/curry.js","webpack://hover-mainsite/./node_modules/ramda/src/curryN.js","webpack://hover-mainsite/./node_modules/ramda/src/dec.js","webpack://hover-mainsite/./node_modules/ramda/src/defaultTo.js","webpack://hover-mainsite/./node_modules/ramda/src/descend.js","webpack://hover-mainsite/./node_modules/ramda/src/difference.js","webpack://hover-mainsite/./node_modules/ramda/src/differenceWith.js","webpack://hover-mainsite/./node_modules/ramda/src/dissoc.js","webpack://hover-mainsite/./node_modules/ramda/src/dissocPath.js","webpack://hover-mainsite/./node_modules/ramda/src/divide.js","webpack://hover-mainsite/./node_modules/ramda/src/drop.js","webpack://hover-mainsite/./node_modules/ramda/src/dropLast.js","webpack://hover-mainsite/./node_modules/ramda/src/dropLastWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/dropRepeats.js","webpack://hover-mainsite/./node_modules/ramda/src/dropRepeatsWith.js","webpack://hover-mainsite/./node_modules/ramda/src/dropWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/either.js","webpack://hover-mainsite/./node_modules/ramda/src/empty.js","webpack://hover-mainsite/./node_modules/ramda/src/endsWith.js","webpack://hover-mainsite/./node_modules/ramda/src/eqBy.js","webpack://hover-mainsite/./node_modules/ramda/src/eqProps.js","webpack://hover-mainsite/./node_modules/ramda/src/equals.js","webpack://hover-mainsite/./node_modules/ramda/src/evolve.js","webpack://hover-mainsite/./node_modules/ramda/src/filter.js","webpack://hover-mainsite/./node_modules/ramda/src/find.js","webpack://hover-mainsite/./node_modules/ramda/src/findIndex.js","webpack://hover-mainsite/./node_modules/ramda/src/findLast.js","webpack://hover-mainsite/./node_modules/ramda/src/findLastIndex.js","webpack://hover-mainsite/./node_modules/ramda/src/flatten.js","webpack://hover-mainsite/./node_modules/ramda/src/flip.js","webpack://hover-mainsite/./node_modules/ramda/src/forEach.js","webpack://hover-mainsite/./node_modules/ramda/src/forEachObjIndexed.js","webpack://hover-mainsite/./node_modules/ramda/src/fromPairs.js","webpack://hover-mainsite/./node_modules/ramda/src/groupBy.js","webpack://hover-mainsite/./node_modules/ramda/src/groupWith.js","webpack://hover-mainsite/./node_modules/ramda/src/gt.js","webpack://hover-mainsite/./node_modules/ramda/src/gte.js","webpack://hover-mainsite/./node_modules/ramda/src/has.js","webpack://hover-mainsite/./node_modules/ramda/src/hasIn.js","webpack://hover-mainsite/./node_modules/ramda/src/head.js","webpack://hover-mainsite/./node_modules/ramda/src/identical.js","webpack://hover-mainsite/./node_modules/ramda/src/identity.js","webpack://hover-mainsite/./node_modules/ramda/src/ifElse.js","webpack://hover-mainsite/./node_modules/ramda/src/inc.js","webpack://hover-mainsite/./node_modules/ramda/src/indexBy.js","webpack://hover-mainsite/./node_modules/ramda/src/indexOf.js","webpack://hover-mainsite/./node_modules/ramda/src/init.js","webpack://hover-mainsite/./node_modules/ramda/src/innerJoin.js","webpack://hover-mainsite/./node_modules/ramda/src/insert.js","webpack://hover-mainsite/./node_modules/ramda/src/insertAll.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_Set.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_aperture.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_arity.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_arrayFromIterator.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_assign.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_checkForMethod.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_clone.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_cloneRegExp.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_complement.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_concat.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_contains.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_containsWith.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_createPartialApplicator.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_curry1.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_curry2.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_curry3.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_curryN.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_dispatchable.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_dropLast.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_dropLastWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_equals.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_filter.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_flatCat.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_forceReduced.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_functionName.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_has.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_identity.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_indexOf.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isArguments.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isArray.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isArrayLike.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isFunction.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isInteger.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isNumber.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isObject.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isPlaceholder.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isRegExp.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isString.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_isTransformer.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_makeFlat.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_map.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_objectAssign.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_of.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_pipe.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_pipeP.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_quote.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_reduce.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_reduced.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_stepCat.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_toISOString.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_toString.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xall.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xany.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xaperture.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xchain.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xdrop.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xdropLast.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xdropLastWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xdropRepeatsWith.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xdropWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xfBase.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xfilter.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xfind.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xfindIndex.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xfindLast.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xfindLastIndex.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xmap.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xreduceBy.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xtake.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xtakeWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/internal/_xwrap.js","webpack://hover-mainsite/./node_modules/ramda/src/intersection.js","webpack://hover-mainsite/./node_modules/ramda/src/intersectionWith.js","webpack://hover-mainsite/./node_modules/ramda/src/intersperse.js","webpack://hover-mainsite/./node_modules/ramda/src/into.js","webpack://hover-mainsite/./node_modules/ramda/src/invert.js","webpack://hover-mainsite/./node_modules/ramda/src/invertObj.js","webpack://hover-mainsite/./node_modules/ramda/src/invoker.js","webpack://hover-mainsite/./node_modules/ramda/src/is.js","webpack://hover-mainsite/./node_modules/ramda/src/isEmpty.js","webpack://hover-mainsite/./node_modules/ramda/src/isNil.js","webpack://hover-mainsite/./node_modules/ramda/src/join.js","webpack://hover-mainsite/./node_modules/ramda/src/juxt.js","webpack://hover-mainsite/./node_modules/ramda/src/keys.js","webpack://hover-mainsite/./node_modules/ramda/src/keysIn.js","webpack://hover-mainsite/./node_modules/ramda/src/last.js","webpack://hover-mainsite/./node_modules/ramda/src/lastIndexOf.js","webpack://hover-mainsite/./node_modules/ramda/src/length.js","webpack://hover-mainsite/./node_modules/ramda/src/lens.js","webpack://hover-mainsite/./node_modules/ramda/src/lensIndex.js","webpack://hover-mainsite/./node_modules/ramda/src/lensPath.js","webpack://hover-mainsite/./node_modules/ramda/src/lensProp.js","webpack://hover-mainsite/./node_modules/ramda/src/lift.js","webpack://hover-mainsite/./node_modules/ramda/src/liftN.js","webpack://hover-mainsite/./node_modules/ramda/src/lt.js","webpack://hover-mainsite/./node_modules/ramda/src/lte.js","webpack://hover-mainsite/./node_modules/ramda/src/map.js","webpack://hover-mainsite/./node_modules/ramda/src/mapAccum.js","webpack://hover-mainsite/./node_modules/ramda/src/mapAccumRight.js","webpack://hover-mainsite/./node_modules/ramda/src/mapObjIndexed.js","webpack://hover-mainsite/./node_modules/ramda/src/match.js","webpack://hover-mainsite/./node_modules/ramda/src/mathMod.js","webpack://hover-mainsite/./node_modules/ramda/src/max.js","webpack://hover-mainsite/./node_modules/ramda/src/maxBy.js","webpack://hover-mainsite/./node_modules/ramda/src/mean.js","webpack://hover-mainsite/./node_modules/ramda/src/median.js","webpack://hover-mainsite/./node_modules/ramda/src/memoize.js","webpack://hover-mainsite/./node_modules/ramda/src/memoizeWith.js","webpack://hover-mainsite/./node_modules/ramda/src/merge.js","webpack://hover-mainsite/./node_modules/ramda/src/mergeAll.js","webpack://hover-mainsite/./node_modules/ramda/src/mergeDeepLeft.js","webpack://hover-mainsite/./node_modules/ramda/src/mergeDeepRight.js","webpack://hover-mainsite/./node_modules/ramda/src/mergeDeepWith.js","webpack://hover-mainsite/./node_modules/ramda/src/mergeDeepWithKey.js","webpack://hover-mainsite/./node_modules/ramda/src/mergeWith.js","webpack://hover-mainsite/./node_modules/ramda/src/mergeWithKey.js","webpack://hover-mainsite/./node_modules/ramda/src/min.js","webpack://hover-mainsite/./node_modules/ramda/src/minBy.js","webpack://hover-mainsite/./node_modules/ramda/src/modulo.js","webpack://hover-mainsite/./node_modules/ramda/src/multiply.js","webpack://hover-mainsite/./node_modules/ramda/src/nAry.js","webpack://hover-mainsite/./node_modules/ramda/src/negate.js","webpack://hover-mainsite/./node_modules/ramda/src/none.js","webpack://hover-mainsite/./node_modules/ramda/src/not.js","webpack://hover-mainsite/./node_modules/ramda/src/nth.js","webpack://hover-mainsite/./node_modules/ramda/src/nthArg.js","webpack://hover-mainsite/./node_modules/ramda/src/o.js","webpack://hover-mainsite/./node_modules/ramda/src/objOf.js","webpack://hover-mainsite/./node_modules/ramda/src/of.js","webpack://hover-mainsite/./node_modules/ramda/src/omit.js","webpack://hover-mainsite/./node_modules/ramda/src/once.js","webpack://hover-mainsite/./node_modules/ramda/src/or.js","webpack://hover-mainsite/./node_modules/ramda/src/over.js","webpack://hover-mainsite/./node_modules/ramda/src/pair.js","webpack://hover-mainsite/./node_modules/ramda/src/partial.js","webpack://hover-mainsite/./node_modules/ramda/src/partialRight.js","webpack://hover-mainsite/./node_modules/ramda/src/partition.js","webpack://hover-mainsite/./node_modules/ramda/src/path.js","webpack://hover-mainsite/./node_modules/ramda/src/pathEq.js","webpack://hover-mainsite/./node_modules/ramda/src/pathOr.js","webpack://hover-mainsite/./node_modules/ramda/src/pathSatisfies.js","webpack://hover-mainsite/./node_modules/ramda/src/pick.js","webpack://hover-mainsite/./node_modules/ramda/src/pickAll.js","webpack://hover-mainsite/./node_modules/ramda/src/pickBy.js","webpack://hover-mainsite/./node_modules/ramda/src/pipe.js","webpack://hover-mainsite/./node_modules/ramda/src/pipeK.js","webpack://hover-mainsite/./node_modules/ramda/src/pipeP.js","webpack://hover-mainsite/./node_modules/ramda/src/pluck.js","webpack://hover-mainsite/./node_modules/ramda/src/prepend.js","webpack://hover-mainsite/./node_modules/ramda/src/product.js","webpack://hover-mainsite/./node_modules/ramda/src/project.js","webpack://hover-mainsite/./node_modules/ramda/src/prop.js","webpack://hover-mainsite/./node_modules/ramda/src/propEq.js","webpack://hover-mainsite/./node_modules/ramda/src/propIs.js","webpack://hover-mainsite/./node_modules/ramda/src/propOr.js","webpack://hover-mainsite/./node_modules/ramda/src/propSatisfies.js","webpack://hover-mainsite/./node_modules/ramda/src/props.js","webpack://hover-mainsite/./node_modules/ramda/src/range.js","webpack://hover-mainsite/./node_modules/ramda/src/reduce.js","webpack://hover-mainsite/./node_modules/ramda/src/reduceBy.js","webpack://hover-mainsite/./node_modules/ramda/src/reduceRight.js","webpack://hover-mainsite/./node_modules/ramda/src/reduceWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/reduced.js","webpack://hover-mainsite/./node_modules/ramda/src/reject.js","webpack://hover-mainsite/./node_modules/ramda/src/remove.js","webpack://hover-mainsite/./node_modules/ramda/src/repeat.js","webpack://hover-mainsite/./node_modules/ramda/src/replace.js","webpack://hover-mainsite/./node_modules/ramda/src/reverse.js","webpack://hover-mainsite/./node_modules/ramda/src/scan.js","webpack://hover-mainsite/./node_modules/ramda/src/sequence.js","webpack://hover-mainsite/./node_modules/ramda/src/set.js","webpack://hover-mainsite/./node_modules/ramda/src/slice.js","webpack://hover-mainsite/./node_modules/ramda/src/sort.js","webpack://hover-mainsite/./node_modules/ramda/src/sortBy.js","webpack://hover-mainsite/./node_modules/ramda/src/sortWith.js","webpack://hover-mainsite/./node_modules/ramda/src/split.js","webpack://hover-mainsite/./node_modules/ramda/src/splitAt.js","webpack://hover-mainsite/./node_modules/ramda/src/splitEvery.js","webpack://hover-mainsite/./node_modules/ramda/src/splitWhen.js","webpack://hover-mainsite/./node_modules/ramda/src/startsWith.js","webpack://hover-mainsite/./node_modules/ramda/src/subtract.js","webpack://hover-mainsite/./node_modules/ramda/src/sum.js","webpack://hover-mainsite/./node_modules/ramda/src/symmetricDifference.js","webpack://hover-mainsite/./node_modules/ramda/src/symmetricDifferenceWith.js","webpack://hover-mainsite/./node_modules/ramda/src/tail.js","webpack://hover-mainsite/./node_modules/ramda/src/take.js","webpack://hover-mainsite/./node_modules/ramda/src/takeLast.js","webpack://hover-mainsite/./node_modules/ramda/src/takeLastWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/takeWhile.js","webpack://hover-mainsite/./node_modules/ramda/src/tap.js","webpack://hover-mainsite/./node_modules/ramda/src/test.js","webpack://hover-mainsite/./node_modules/ramda/src/times.js","webpack://hover-mainsite/./node_modules/ramda/src/toLower.js","webpack://hover-mainsite/./node_modules/ramda/src/toPairs.js","webpack://hover-mainsite/./node_modules/ramda/src/toPairsIn.js","webpack://hover-mainsite/./node_modules/ramda/src/toString.js","webpack://hover-mainsite/./node_modules/ramda/src/toUpper.js","webpack://hover-mainsite/./node_modules/ramda/src/transduce.js","webpack://hover-mainsite/./node_modules/ramda/src/transpose.js","webpack://hover-mainsite/./node_modules/ramda/src/traverse.js","webpack://hover-mainsite/./node_modules/ramda/src/trim.js","webpack://hover-mainsite/./node_modules/ramda/src/tryCatch.js","webpack://hover-mainsite/./node_modules/ramda/src/type.js","webpack://hover-mainsite/./node_modules/ramda/src/unapply.js","webpack://hover-mainsite/./node_modules/ramda/src/unary.js","webpack://hover-mainsite/./node_modules/ramda/src/uncurryN.js","webpack://hover-mainsite/./node_modules/ramda/src/unfold.js","webpack://hover-mainsite/./node_modules/ramda/src/union.js","webpack://hover-mainsite/./node_modules/ramda/src/unionWith.js","webpack://hover-mainsite/./node_modules/ramda/src/uniq.js","webpack://hover-mainsite/./node_modules/ramda/src/uniqBy.js","webpack://hover-mainsite/./node_modules/ramda/src/uniqWith.js","webpack://hover-mainsite/./node_modules/ramda/src/unless.js","webpack://hover-mainsite/./node_modules/ramda/src/unnest.js","webpack://hover-mainsite/./node_modules/ramda/src/until.js","webpack://hover-mainsite/./node_modules/ramda/src/update.js","webpack://hover-mainsite/./node_modules/ramda/src/useWith.js","webpack://hover-mainsite/./node_modules/ramda/src/values.js","webpack://hover-mainsite/./node_modules/ramda/src/valuesIn.js","webpack://hover-mainsite/./node_modules/ramda/src/view.js","webpack://hover-mainsite/./node_modules/ramda/src/when.js","webpack://hover-mainsite/./node_modules/ramda/src/where.js","webpack://hover-mainsite/./node_modules/ramda/src/whereEq.js","webpack://hover-mainsite/./node_modules/ramda/src/without.js","webpack://hover-mainsite/./node_modules/ramda/src/xprod.js","webpack://hover-mainsite/./node_modules/ramda/src/zip.js","webpack://hover-mainsite/./node_modules/ramda/src/zipObj.js","webpack://hover-mainsite/./node_modules/ramda/src/zipWith.js"],"sourcesContent":["module.exports = {\n  F: require('./src/F'),\n  T: require('./src/T'),\n  __: require('./src/__'),\n  add: require('./src/add'),\n  addIndex: require('./src/addIndex'),\n  adjust: require('./src/adjust'),\n  all: require('./src/all'),\n  allPass: require('./src/allPass'),\n  always: require('./src/always'),\n  and: require('./src/and'),\n  any: require('./src/any'),\n  anyPass: require('./src/anyPass'),\n  ap: require('./src/ap'),\n  aperture: require('./src/aperture'),\n  append: require('./src/append'),\n  apply: require('./src/apply'),\n  applySpec: require('./src/applySpec'),\n  ascend: require('./src/ascend'),\n  assoc: require('./src/assoc'),\n  assocPath: require('./src/assocPath'),\n  binary: require('./src/binary'),\n  bind: require('./src/bind'),\n  both: require('./src/both'),\n  call: require('./src/call'),\n  chain: require('./src/chain'),\n  clamp: require('./src/clamp'),\n  clone: require('./src/clone'),\n  comparator: require('./src/comparator'),\n  complement: require('./src/complement'),\n  compose: require('./src/compose'),\n  composeK: require('./src/composeK'),\n  composeP: require('./src/composeP'),\n  concat: require('./src/concat'),\n  cond: require('./src/cond'),\n  construct: require('./src/construct'),\n  constructN: require('./src/constructN'),\n  contains: require('./src/contains'),\n  converge: require('./src/converge'),\n  countBy: require('./src/countBy'),\n  curry: require('./src/curry'),\n  curryN: require('./src/curryN'),\n  dec: require('./src/dec'),\n  defaultTo: require('./src/defaultTo'),\n  descend: require('./src/descend'),\n  difference: require('./src/difference'),\n  differenceWith: require('./src/differenceWith'),\n  dissoc: require('./src/dissoc'),\n  dissocPath: require('./src/dissocPath'),\n  divide: require('./src/divide'),\n  drop: require('./src/drop'),\n  dropLast: require('./src/dropLast'),\n  dropLastWhile: require('./src/dropLastWhile'),\n  dropRepeats: require('./src/dropRepeats'),\n  dropRepeatsWith: require('./src/dropRepeatsWith'),\n  dropWhile: require('./src/dropWhile'),\n  either: require('./src/either'),\n  empty: require('./src/empty'),\n  endsWith: require('./src/endsWith'),\n  eqBy: require('./src/eqBy'),\n  eqProps: require('./src/eqProps'),\n  equals: require('./src/equals'),\n  evolve: require('./src/evolve'),\n  filter: require('./src/filter'),\n  find: require('./src/find'),\n  findIndex: require('./src/findIndex'),\n  findLast: require('./src/findLast'),\n  findLastIndex: require('./src/findLastIndex'),\n  flatten: require('./src/flatten'),\n  flip: require('./src/flip'),\n  forEach: require('./src/forEach'),\n  forEachObjIndexed: require('./src/forEachObjIndexed'),\n  fromPairs: require('./src/fromPairs'),\n  groupBy: require('./src/groupBy'),\n  groupWith: require('./src/groupWith'),\n  gt: require('./src/gt'),\n  gte: require('./src/gte'),\n  has: require('./src/has'),\n  hasIn: require('./src/hasIn'),\n  head: require('./src/head'),\n  identical: require('./src/identical'),\n  identity: require('./src/identity'),\n  ifElse: require('./src/ifElse'),\n  inc: require('./src/inc'),\n  indexBy: require('./src/indexBy'),\n  indexOf: require('./src/indexOf'),\n  init: require('./src/init'),\n  innerJoin: require('./src/innerJoin'),\n  insert: require('./src/insert'),\n  insertAll: require('./src/insertAll'),\n  intersection: require('./src/intersection'),\n  intersectionWith: require('./src/intersectionWith'),\n  intersperse: require('./src/intersperse'),\n  into: require('./src/into'),\n  invert: require('./src/invert'),\n  invertObj: require('./src/invertObj'),\n  invoker: require('./src/invoker'),\n  is: require('./src/is'),\n  isEmpty: require('./src/isEmpty'),\n  isNil: require('./src/isNil'),\n  join: require('./src/join'),\n  juxt: require('./src/juxt'),\n  keys: require('./src/keys'),\n  keysIn: require('./src/keysIn'),\n  last: require('./src/last'),\n  lastIndexOf: require('./src/lastIndexOf'),\n  length: require('./src/length'),\n  lens: require('./src/lens'),\n  lensIndex: require('./src/lensIndex'),\n  lensPath: require('./src/lensPath'),\n  lensProp: require('./src/lensProp'),\n  lift: require('./src/lift'),\n  liftN: require('./src/liftN'),\n  lt: require('./src/lt'),\n  lte: require('./src/lte'),\n  map: require('./src/map'),\n  mapAccum: require('./src/mapAccum'),\n  mapAccumRight: require('./src/mapAccumRight'),\n  mapObjIndexed: require('./src/mapObjIndexed'),\n  match: require('./src/match'),\n  mathMod: require('./src/mathMod'),\n  max: require('./src/max'),\n  maxBy: require('./src/maxBy'),\n  mean: require('./src/mean'),\n  median: require('./src/median'),\n  memoize: require('./src/memoize'),\n  memoizeWith: require('./src/memoizeWith'),\n  merge: require('./src/merge'),\n  mergeAll: require('./src/mergeAll'),\n  mergeDeepLeft: require('./src/mergeDeepLeft'),\n  mergeDeepRight: require('./src/mergeDeepRight'),\n  mergeDeepWith: require('./src/mergeDeepWith'),\n  mergeDeepWithKey: require('./src/mergeDeepWithKey'),\n  mergeWith: require('./src/mergeWith'),\n  mergeWithKey: require('./src/mergeWithKey'),\n  min: require('./src/min'),\n  minBy: require('./src/minBy'),\n  modulo: require('./src/modulo'),\n  multiply: require('./src/multiply'),\n  nAry: require('./src/nAry'),\n  negate: require('./src/negate'),\n  none: require('./src/none'),\n  not: require('./src/not'),\n  nth: require('./src/nth'),\n  nthArg: require('./src/nthArg'),\n  o: require('./src/o'),\n  objOf: require('./src/objOf'),\n  of: require('./src/of'),\n  omit: require('./src/omit'),\n  once: require('./src/once'),\n  or: require('./src/or'),\n  over: require('./src/over'),\n  pair: require('./src/pair'),\n  partial: require('./src/partial'),\n  partialRight: require('./src/partialRight'),\n  partition: require('./src/partition'),\n  path: require('./src/path'),\n  pathEq: require('./src/pathEq'),\n  pathOr: require('./src/pathOr'),\n  pathSatisfies: require('./src/pathSatisfies'),\n  pick: require('./src/pick'),\n  pickAll: require('./src/pickAll'),\n  pickBy: require('./src/pickBy'),\n  pipe: require('./src/pipe'),\n  pipeK: require('./src/pipeK'),\n  pipeP: require('./src/pipeP'),\n  pluck: require('./src/pluck'),\n  prepend: require('./src/prepend'),\n  product: require('./src/product'),\n  project: require('./src/project'),\n  prop: require('./src/prop'),\n  propEq: require('./src/propEq'),\n  propIs: require('./src/propIs'),\n  propOr: require('./src/propOr'),\n  propSatisfies: require('./src/propSatisfies'),\n  props: require('./src/props'),\n  range: require('./src/range'),\n  reduce: require('./src/reduce'),\n  reduceBy: require('./src/reduceBy'),\n  reduceRight: require('./src/reduceRight'),\n  reduceWhile: require('./src/reduceWhile'),\n  reduced: require('./src/reduced'),\n  reject: require('./src/reject'),\n  remove: require('./src/remove'),\n  repeat: require('./src/repeat'),\n  replace: require('./src/replace'),\n  reverse: require('./src/reverse'),\n  scan: require('./src/scan'),\n  sequence: require('./src/sequence'),\n  set: require('./src/set'),\n  slice: require('./src/slice'),\n  sort: require('./src/sort'),\n  sortBy: require('./src/sortBy'),\n  sortWith: require('./src/sortWith'),\n  split: require('./src/split'),\n  splitAt: require('./src/splitAt'),\n  splitEvery: require('./src/splitEvery'),\n  splitWhen: require('./src/splitWhen'),\n  startsWith: require('./src/startsWith'),\n  subtract: require('./src/subtract'),\n  sum: require('./src/sum'),\n  symmetricDifference: require('./src/symmetricDifference'),\n  symmetricDifferenceWith: require('./src/symmetricDifferenceWith'),\n  tail: require('./src/tail'),\n  take: require('./src/take'),\n  takeLast: require('./src/takeLast'),\n  takeLastWhile: require('./src/takeLastWhile'),\n  takeWhile: require('./src/takeWhile'),\n  tap: require('./src/tap'),\n  test: require('./src/test'),\n  times: require('./src/times'),\n  toLower: require('./src/toLower'),\n  toPairs: require('./src/toPairs'),\n  toPairsIn: require('./src/toPairsIn'),\n  toString: require('./src/toString'),\n  toUpper: require('./src/toUpper'),\n  transduce: require('./src/transduce'),\n  transpose: require('./src/transpose'),\n  traverse: require('./src/traverse'),\n  trim: require('./src/trim'),\n  tryCatch: require('./src/tryCatch'),\n  type: require('./src/type'),\n  unapply: require('./src/unapply'),\n  unary: require('./src/unary'),\n  uncurryN: require('./src/uncurryN'),\n  unfold: require('./src/unfold'),\n  union: require('./src/union'),\n  unionWith: require('./src/unionWith'),\n  uniq: require('./src/uniq'),\n  uniqBy: require('./src/uniqBy'),\n  uniqWith: require('./src/uniqWith'),\n  unless: require('./src/unless'),\n  unnest: require('./src/unnest'),\n  until: require('./src/until'),\n  update: require('./src/update'),\n  useWith: require('./src/useWith'),\n  values: require('./src/values'),\n  valuesIn: require('./src/valuesIn'),\n  view: require('./src/view'),\n  when: require('./src/when'),\n  where: require('./src/where'),\n  whereEq: require('./src/whereEq'),\n  without: require('./src/without'),\n  xprod: require('./src/xprod'),\n  zip: require('./src/zip'),\n  zipObj: require('./src/zipObj'),\n  zipWith: require('./src/zipWith')\n};\n","var always = require('./always');\n\n\n/**\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.always, R.T\n * @example\n *\n *      R.F(); //=> false\n */\nmodule.exports = always(false);\n","var always = require('./always');\n\n\n/**\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.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nmodule.exports = always(true);\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 * @constant\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {'@@functional/placeholder': true};\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function add(a, b) {\n  return Number(a) + Number(b);\n});\n","var _concat = require('./internal/_concat');\nvar _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\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 *      var 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 */\nmodule.exports = _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    args[0] = function() {\n      var result = origFn.apply(this, _concat(arguments, [idx, list]));\n      idx += 1;\n      return result;\n    };\n    return fn.apply(this, args);\n  });\n});\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\n\n\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 (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\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(R.add(10), 1, [1, 2, 3]);     //=> [1, 12, 3]\n *      R.adjust(R.add(10))(1)([1, 2, 3]);     //=> [1, 12, 3]\n * @symb R.adjust(f, -1, [a, b]) = [a, f(b)]\n * @symb R.adjust(f, 0, [a, b]) = [f(a), b]\n */\nmodule.exports = _curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xall = require('./internal/_xall');\n\n\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 *      var equals3 = R.equals(3);\n *      R.all(equals3)([3, 3, 3, 3]); //=> true\n *      R.all(equals3)([3, 3, 1, 3]); //=> false\n */\nmodule.exports = _curry2(_dispatchable(['all'], _xall, function all(fn, list) {\n  var idx = 0;\n  while (idx < list.length) {\n    if (!fn(list[idx])) {\n      return false;\n    }\n    idx += 1;\n  }\n  return true;\n}));\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\nvar max = require('./max');\nvar pluck = require('./pluck');\nvar reduce = require('./reduce');\n\n\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 *      var isQueen = R.propEq('rank', 'Q');\n *      var isSpade = R.propEq('suit', '♠︎');\n *      var isQueenOfSpades = R.allPass([isQueen, isSpade]);\n *\n *      isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false\n *      isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true\n */\nmodule.exports = _curry1(function allPass(preds) {\n  return curryN(reduce(max, 0, pluck('length', preds)), function() {\n    var idx = 0;\n    var len = preds.length;\n    while (idx < len) {\n      if (!preds[idx].apply(this, arguments)) {\n        return false;\n      }\n      idx += 1;\n    }\n    return true;\n  });\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nmodule.exports = _curry1(function always(val) {\n  return function() {\n    return val;\n  };\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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\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 */\nmodule.exports = _curry2(function and(a, b) {\n  return a && b;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xany = require('./internal/_xany');\n\n\n/**\n * Returns `true` if at least one of 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 *      var lessThan0 = R.flip(R.lt)(0);\n *      var lessThan2 = R.flip(R.lt)(2);\n *      R.any(lessThan0)([1, 2]); //=> false\n *      R.any(lessThan2)([1, 2]); //=> true\n */\nmodule.exports = _curry2(_dispatchable(['any'], _xany, function any(fn, list) {\n  var idx = 0;\n  while (idx < list.length) {\n    if (fn(list[idx])) {\n      return true;\n    }\n    idx += 1;\n  }\n  return false;\n}));\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\nvar max = require('./max');\nvar pluck = require('./pluck');\nvar reduce = require('./reduce');\n\n\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 *      var isClub = R.propEq('suit', '♣');\n *      var isSpade = R.propEq('suit', '♠');\n *      var 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 */\nmodule.exports = _curry1(function anyPass(preds) {\n  return curryN(reduce(max, 0, pluck('length', preds)), function() {\n    var idx = 0;\n    var len = preds.length;\n    while (idx < len) {\n      if (preds[idx].apply(this, arguments)) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  });\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\nvar _reduce = require('./internal/_reduce');\nvar map = require('./map');\n\n\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 * @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 * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]\n */\nmodule.exports = _curry2(function ap(applyF, applyX) {\n  return (\n    typeof applyX['fantasy-land/ap'] === 'function' ?\n      applyX['fantasy-land/ap'](applyF) :\n    typeof applyF.ap === 'function' ?\n      applyF.ap(applyX) :\n    typeof applyF === 'function' ?\n      function(x) { return applyF(x)(applyX(x)); } :\n    // else\n      _reduce(function(acc, f) { return _concat(acc, map(f, applyX)); }, [], applyF)\n  );\n});\n","var _aperture = require('./internal/_aperture');\nvar _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xaperture = require('./internal/_xaperture');\n\n\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 */\nmodule.exports = _curry2(_dispatchable([], _xaperture, _aperture));\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function apply(fn, args) {\n  return fn.apply(this, args);\n});\n","var _curry1 = require('./internal/_curry1');\nvar apply = require('./apply');\nvar curryN = require('./curryN');\nvar map = require('./map');\nvar max = require('./max');\nvar pluck = require('./pluck');\nvar reduce = require('./reduce');\nvar values = require('./values');\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 *      var 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 */\nmodule.exports = _curry1(function applySpec(spec) {\n  spec = map(function(v) { return typeof v == 'function' ? v : applySpec(v); },\n             spec);\n  return curryN(reduce(max, 0, pluck('length', values(spec))),\n                function() {\n                  var args = arguments;\n                  return map(function(f) { return apply(f, args); }, spec);\n                });\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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 *      var byAge = R.ascend(R.prop('age'));\n *      var people = [\n *        // ...\n *      ];\n *      var peopleByYoungestFirst = R.sort(byAge, people);\n */\nmodule.exports = _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","var _curry3 = require('./internal/_curry3');\n\n\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\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\nmodule.exports = _curry3(function assoc(prop, val, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  result[prop] = val;\n  return result;\n});\n","var _curry3 = require('./internal/_curry3');\nvar _has = require('./internal/_has');\nvar _isArray = require('./internal/_isArray');\nvar _isInteger = require('./internal/_isInteger');\nvar assoc = require('./assoc');\nvar isNil = require('./isNil');\n\n\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 */\nmodule.exports = _curry3(function assocPath(path, val, obj) {\n  if (path.length === 0) {\n    return val;\n  }\n  var idx = path[0];\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  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","var _curry1 = require('./internal/_curry1');\nvar nAry = require('./nAry');\n\n\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 *      var 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 *      var 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 */\nmodule.exports = _curry1(function binary(fn) {\n  return nAry(2, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var _curry2 = require('./internal/_curry2');\nvar _isFunction = require('./internal/_isFunction');\nvar and = require('./and');\nvar lift = require('./lift');\n\n\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 *      var gt10 = R.gt(R.__, 10)\n *      var lt20 = R.lt(R.__, 20)\n *      var f = R.both(gt10, lt20);\n *      f(15); //=> true\n *      f(30); //=> false\n */\nmodule.exports = _curry2(function both(f, g) {\n  return _isFunction(f) ?\n    function _both() {\n      return f.apply(this, arguments) && g.apply(this, arguments);\n    } :\n    lift(and)(f, g);\n});\n","var curry = require('./curry');\n\n\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 *      var indentN = R.pipe(R.times(R.always(' ')),\n *                           R.join(''),\n *                           R.replace(/^(?!$)/gm));\n *\n *      var 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 */\nmodule.exports = curry(function call(fn) {\n  return fn.apply(this, Array.prototype.slice.call(arguments, 1));\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _makeFlat = require('./internal/_makeFlat');\nvar _xchain = require('./internal/_xchain');\nvar map = require('./map');\n\n\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 * @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 *      var 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 */\nmodule.exports = _curry2(_dispatchable(['fantasy-land/chain', 'chain'], _xchain, function chain(fn, monad) {\n  if (typeof monad === 'function') {\n    return function(x) { return fn(monad(x))(x); };\n  }\n  return _makeFlat(false)(map(fn, monad));\n}));\n","var _curry3 = require('./internal/_curry3');\n\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 */\nmodule.exports = _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  return value < min ? min :\n         value > max ? max :\n         value;\n});\n","var _clone = require('./internal/_clone');\nvar _curry1 = require('./internal/_curry1');\n\n\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 *      var objects = [{}, {}, {}];\n *      var objectsClone = R.clone(objects);\n *      objects === objectsClone; //=> false\n *      objects[0] === objectsClone[0]; //=> false\n */\nmodule.exports = _curry1(function clone(value) {\n  return value != null && typeof value.clone === 'function' ?\n    value.clone() :\n    _clone(value, [], [], true);\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 *      var byAge = R.comparator((a, b) => a.age < b.age);\n *      var people = [\n *        // ...\n *      ];\n *      var peopleByIncreasingAge = R.sort(byAge, people);\n */\nmodule.exports = _curry1(function comparator(pred) {\n  return function(a, b) {\n    return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n  };\n});\n","var lift = require('./lift');\nvar not = require('./not');\n\n\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 *      var isNotNil = R.complement(R.isNil);\n *      isNil(null); //=> true\n *      isNotNil(null); //=> false\n *      isNil(7); //=> false\n *      isNotNil(7); //=> true\n */\nmodule.exports = lift(not);\n","var pipe = require('./pipe');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left function composition. The rightmost function may have\n * any arity; the remaining functions 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 *      var classyGreeting = (firstName, lastName) => \"The name's \" + lastName + \", \" + firstName + \" \" + lastName\n *      var 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 */\nmodule.exports = function compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n  return pipe.apply(this, reverse(arguments));\n};\n","var chain = require('./chain');\nvar compose = require('./compose');\nvar map = require('./map');\n\n\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), R.chain(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 * @example\n *\n *       //  get :: String -> Object -> Maybe *\n *       var get = R.curry((propName, obj) => Maybe(obj[propName]))\n *\n *       //  getStateCode :: Maybe String -> Maybe String\n *       var 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 */\nmodule.exports = function composeK() {\n  if (arguments.length === 0) {\n    throw new Error('composeK requires at least one argument');\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};\n","var pipeP = require('./pipeP');\nvar reverse = require('./reverse');\n\n\n/**\n * Performs right-to-left composition of one or more Promise-returning\n * functions. The rightmost function may have any arity; the remaining\n * functions 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 * @example\n *\n *      var 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 *      var lookupUser = (userId) => Promise.resolve(db.users[userId])\n *      var lookupFollowers = (user) => Promise.resolve(user.followers)\n *      lookupUser('JOE').then(lookupFollowers)\n *\n *      //  followersForUser :: String -> Promise [UserId]\n *      var followersForUser = R.composeP(lookupFollowers, lookupUser);\n *      followersForUser('JOE').then(followers => console.log('Followers:', followers))\n *      // Followers: [\"STEVE\",\"SUZY\"]\n */\nmodule.exports = function composeP() {\n  if (arguments.length === 0) {\n    throw new Error('composeP requires at least one argument');\n  }\n  return pipeP.apply(this, reverse(arguments));\n};\n","var _curry2 = require('./internal/_curry2');\nvar _isArray = require('./internal/_isArray');\nvar _isFunction = require('./internal/_isFunction');\nvar _isString = require('./internal/_isString');\nvar toString = require('./toString');\n\n\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 *\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 */\nmodule.exports = _curry2(function concat(a, b) {\n  if (_isArray(a)) {\n    if (_isArray(b)) {\n      return a.concat(b);\n    }\n    throw new TypeError(toString(b) + ' is not an array');\n  }\n  if (_isString(a)) {\n    if (_isString(b)) {\n      return a + b;\n    }\n    throw new TypeError(toString(b) + ' is not a string');\n  }\n  if (a != null && _isFunction(a['fantasy-land/concat'])) {\n    return a['fantasy-land/concat'](b);\n  }\n  if (a != null && _isFunction(a.concat)) {\n    return a.concat(b);\n  }\n  throw new TypeError(toString(a) + ' does not have a method named \"concat\" or \"fantasy-land/concat\"');\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar map = require('./map');\nvar max = require('./max');\nvar reduce = require('./reduce');\n\n\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 * @example\n *\n *      var 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 */\nmodule.exports = _curry1(function cond(pairs) {\n  var arity = reduce(max,\n                     0,\n                     map(function(pair) { return pair[0].length; }, pairs));\n  return _arity(arity, function() {\n    var idx = 0;\n    while (idx < pairs.length) {\n      if (pairs[idx][0].apply(this, arguments)) {\n        return pairs[idx][1].apply(this, arguments);\n      }\n      idx += 1;\n    }\n  });\n});\n","var _curry1 = require('./internal/_curry1');\nvar constructN = require('./constructN');\n\n\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 *      var AnimalConstructor = R.construct(Animal)\n *\n *      // Notice we no longer need the 'new' keyword:\n *      AnimalConstructor('Pig'); //=> {\"kind\": \"Pig\", \"sighting\": function (){...}};\n *\n *      var animalTypes = [\"Lion\", \"Tiger\", \"Bear\"];\n *      var animalSighting = R.invoker(0, 'sighting');\n *      var sightNewAnimal = R.compose(animalSighting, AnimalConstructor);\n *      R.map(sightNewAnimal, animalTypes); //=> [\"It's a Lion!\", \"It's a Tiger!\", \"It's a Bear!\"]\n */\nmodule.exports = _curry1(function construct(Fn) {\n  return constructN(Fn.length, Fn);\n});\n","var _curry2 = require('./internal/_curry2');\nvar curry = require('./curry');\nvar nAry = require('./nAry');\n\n\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 *      Salad.prototype.recipe = function() {\n *        var instructions = R.map((ingredient) => (\n *          'Add a whollop of ' + ingredient, this.ingredients)\n *        )\n *        return R.join('\\n', instructions)\n *      }\n *\n *      var ThreeLayerSalad = R.constructN(3, Salad)\n *\n *      // Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments.\n *      var salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup')\n *      console.log(salad.recipe());\n *      // Add a whollop of Mayonnaise\n *      // Add a whollop of Potato Chips\n *      // Add a whollop of Potato Ketchup\n */\nmodule.exports = _curry2(function constructN(n, Fn) {\n  if (n > 10) {\n    throw new Error('Constructor with greater than ten arguments');\n  }\n  if (n === 0) {\n    return function() { return new Fn(); };\n  }\n  return curry(nAry(n, function($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n    switch (arguments.length) {\n      case  1: return new Fn($0);\n      case  2: return new Fn($0, $1);\n      case  3: return new Fn($0, $1, $2);\n      case  4: return new Fn($0, $1, $2, $3);\n      case  5: return new Fn($0, $1, $2, $3, $4);\n      case  6: return new Fn($0, $1, $2, $3, $4, $5);\n      case  7: return new Fn($0, $1, $2, $3, $4, $5, $6);\n      case  8: return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n      case  9: return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n      case 10: return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n    }\n  }));\n});\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\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 *\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.any\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 */\nmodule.exports = _curry2(_contains);\n","var _curry2 = require('./internal/_curry2');\nvar _map = require('./internal/_map');\nvar curryN = require('./curryN');\nvar max = require('./max');\nvar pluck = require('./pluck');\nvar reduce = require('./reduce');\n\n\n/**\n * Accepts a converging function and a list of branching functions and returns\n * a new function. When invoked, this new function is applied to some\n * arguments, each branching function is applied to those same arguments. The\n * results of each branching function are passed as arguments to the converging\n * 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 *      var average = R.converge(R.divide, [R.sum, R.length])\n *      average([1, 2, 3, 4, 5, 6, 7]) //=> 4\n *\n *      var 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 */\nmodule.exports = _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","var reduceBy = require('./reduceBy');\n\n\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 *      var 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 *      var letters = ['a', 'b', 'A', 'a', 'B', 'c'];\n *      R.countBy(R.toLower)(letters);   //=> {'a': 3, 'b': 2, 'c': 1}\n */\nmodule.exports = reduceBy(function(acc, elem) { return acc + 1; }, 0);\n","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\n\n\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\n * @example\n *\n *      var addFourNumbers = (a, b, c, d) => a + b + c + d;\n *\n *      var curriedAddFourNumbers = R.curry(addFourNumbers);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\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 *      var sumArgs = (...args) => R.sum(args);\n *\n *      var curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var add = require('./add');\n\n\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 */\nmodule.exports = add(-1);\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var defaultTo42 = R.defaultTo(42);\n *\n *      defaultTo42(null);  //=> 42\n *      defaultTo42(undefined);  //=> 42\n *      defaultTo42('Ramda');  //=> 'Ramda'\n *      // parseInt('string') results in NaN\n *      defaultTo42(parseInt('string')); //=> 42\n */\nmodule.exports = _curry2(function defaultTo(d, v) {\n  return v == null || v !== v ? d : v;\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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 *      var byAge = R.descend(R.prop('age'));\n *      var people = [\n *        // ...\n *      ];\n *      var peopleByOldestFirst = R.sort(byAge, people);\n */\nmodule.exports = _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","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function difference(first, second) {\n  var out = [];\n  var idx = 0;\n  var firstLen = first.length;\n  while (idx < firstLen) {\n    if (!_contains(first[idx], second) && !_contains(first[idx], out)) {\n      out[out.length] = first[idx];\n    }\n    idx += 1;\n  }\n  return out;\n});\n","var _containsWith = require('./internal/_containsWith');\nvar _curry3 = require('./internal/_curry3');\n\n\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 *      var cmp = (x, y) => x.a === y.a;\n *      var l1 = [{a: 1}, {a: 2}, {a: 3}];\n *      var l2 = [{a: 3}, {a: 4}];\n *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n */\nmodule.exports = _curry3(function differenceWith(pred, first, second) {\n  var out = [];\n  var idx = 0;\n  var firstLen = first.length;\n  while (idx < firstLen) {\n    if (!_containsWith(pred, first[idx], second) &&\n        !_containsWith(pred, first[idx], out)) {\n      out.push(first[idx]);\n    }\n    idx += 1;\n  }\n  return out;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\nmodule.exports = _curry2(function dissoc(prop, obj) {\n  var result = {};\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n  delete result[prop];\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _isInteger = require('./internal/_isInteger');\nvar assoc = require('./assoc');\nvar dissoc = require('./dissoc');\nvar remove = require('./remove');\nvar update = require('./update');\n\n\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 */\nmodule.exports = _curry2(function dissocPath(path, obj) {\n  switch (path.length) {\n    case 0:\n      return obj;\n    case 1:\n      return _isInteger(path[0]) ? remove(path[0], 1, obj) : dissoc(path[0], obj);\n    default:\n      var head = path[0];\n      var tail = Array.prototype.slice.call(path, 1);\n      if (obj[head] == null) {\n        return obj;\n      } else if (_isInteger(path[0])) {\n        return update(head, dissocPath(tail, obj[head]), obj);\n      } else {\n        return assoc(head, dissocPath(tail, obj[head]), obj);\n      }\n  }\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var half = R.divide(R.__, 2);\n *      half(42); //=> 21\n *\n *      var reciprocal = R.divide(1);\n *      reciprocal(4);   //=> 0.25\n */\nmodule.exports = _curry2(function divide(a, b) { return a / b; });\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xdrop = require('./internal/_xdrop');\nvar slice = require('./slice');\n\n\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 */\nmodule.exports = _curry2(_dispatchable(['drop'], _xdrop, function drop(n, xs) {\n  return slice(Math.max(0, n), Infinity, xs);\n}));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _dropLast = require('./internal/_dropLast');\nvar _xdropLast = require('./internal/_xdropLast');\n\n\n/**\n * Returns a list containing all but the last `n` elements of the given `list`.\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 */\nmodule.exports = _curry2(_dispatchable([], _xdropLast, _dropLast));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _dropLastWhile = require('./internal/_dropLastWhile');\nvar _xdropLastWhile = require('./internal/_xdropLastWhile');\n\n\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 * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @param {Function} predicate The function to be called on each element\n * @param {Array} list 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 *      var lteThree = x => x <= 3;\n *\n *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]\n */\nmodule.exports = _curry2(_dispatchable([], _xdropLastWhile, _dropLastWhile));\n","var _curry1 = require('./internal/_curry1');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xdropRepeatsWith = require('./internal/_xdropRepeatsWith');\nvar dropRepeatsWith = require('./dropRepeatsWith');\nvar equals = require('./equals');\n\n\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 */\nmodule.exports = _curry1(_dispatchable([], _xdropRepeatsWith(equals), dropRepeatsWith(equals)));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xdropRepeatsWith = require('./internal/_xdropRepeatsWith');\nvar last = require('./last');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_dispatchable([], _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n  var result = [];\n  var idx = 1;\n  var len = list.length;\n  if (len !== 0) {\n    result[0] = list[0];\n    while (idx < len) {\n      if (!pred(last(result), list[idx])) {\n        result[result.length] = list[idx];\n      }\n      idx += 1;\n    }\n  }\n  return result;\n}));\n\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xdropWhile = require('./internal/_xdropWhile');\n\n\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 * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} A new array.\n * @see R.takeWhile, R.transduce, R.addIndex\n * @example\n *\n *      var lteTwo = x => x <= 2;\n *\n *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n */\nmodule.exports = _curry2(_dispatchable(['dropWhile'], _xdropWhile, function dropWhile(pred, list) {\n  var idx = 0;\n  var len = list.length;\n  while (idx < len && pred(list[idx])) {\n    idx += 1;\n  }\n  return Array.prototype.slice.call(list, idx);\n}));\n","var _curry2 = require('./internal/_curry2');\nvar _isFunction = require('./internal/_isFunction');\nvar lift = require('./lift');\nvar or = require('./or');\n\n\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 *      var gt10 = x => x > 10;\n *      var even = x => x % 2 === 0;\n *      var f = R.either(gt10, even);\n *      f(101); //=> true\n *      f(8); //=> true\n */\nmodule.exports = _curry2(function either(f, g) {\n  return _isFunction(f) ?\n    function _either() {\n      return f.apply(this, arguments) || g.apply(this, arguments);\n    } :\n    lift(or)(f, g);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArguments = require('./internal/_isArguments');\nvar _isArray = require('./internal/_isArray');\nvar _isObject = require('./internal/_isObject');\nvar _isString = require('./internal/_isString');\n\n\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` and/or\n * `<Type>.prototype.empty`.\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 */\nmodule.exports = _curry1(function empty(x) {\n  return (\n    (x != null && typeof x['fantasy-land/empty'] === 'function') ?\n      x['fantasy-land/empty']() :\n    (x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function') ?\n      x.constructor['fantasy-land/empty']() :\n    (x != null && typeof x.empty === 'function') ?\n      x.empty() :\n    (x != null && x.constructor != null && typeof x.constructor.empty === 'function') ?\n      x.constructor.empty() :\n    _isArray(x) ?\n      [] :\n    _isString(x) ?\n      '' :\n    _isObject(x) ?\n      {} :\n    _isArguments(x) ?\n      (function() { return arguments; }()) :\n    // else\n      void 0\n  );\n});\n","var _curry2 = require('./internal/_curry2');\nvar equals = require('./equals');\nvar takeLast = require('./takeLast');\n\n/**\n * Checks if a list ends with the provided values\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> Boolean\n * @sig String -> Boolean\n * @param {*} suffix\n * @param {*} list\n * @return {Boolean}\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 */\nmodule.exports = _curry2(function(suffix, list) {\n  return equals(takeLast(suffix.length, list), suffix);\n});\n","var _curry3 = require('./internal/_curry3');\nvar equals = require('./equals');\n\n\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 */\nmodule.exports = _curry3(function eqBy(f, x, y) {\n  return equals(f(x), f(y));\n});\n","var _curry3 = require('./internal/_curry3');\nvar equals = require('./equals');\n\n\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 *      var o1 = { a: 1, b: 2, c: 3, d: 4 };\n *      var o2 = { a: 10, b: 20, c: 3, d: 40 };\n *      R.eqProps('a', o1, o2); //=> false\n *      R.eqProps('c', o1, o2); //=> true\n */\nmodule.exports = _curry3(function eqProps(prop, obj1, obj2) {\n  return equals(obj1[prop], obj2[prop]);\n});\n","var _curry2 = require('./internal/_curry2');\nvar _equals = require('./internal/_equals');\n\n\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 *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nmodule.exports = _curry2(function equals(a, b) {\n  return _equals(a, b, [], []);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var tomato  = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      var 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 */\nmodule.exports = _curry2(function evolve(transformations, object) {\n  var result = {};\n  var transformation, key, type;\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function'                 ? transformation(object[key])\n                : transformation && type === 'object' ? evolve(transformation, object[key])\n                                                      : object[key];\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _isObject = require('./internal/_isObject');\nvar _reduce = require('./internal/_reduce');\nvar _xfilter = require('./internal/_xfilter');\nvar keys = require('./keys');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_dispatchable(['filter'], _xfilter, function(pred, filterable) {\n  return (\n    _isObject(filterable) ?\n      _reduce(function(acc, key) {\n        if (pred(filterable[key])) {\n          acc[key] = filterable[key];\n        }\n        return acc;\n      }, {}, keys(filterable)) :\n    // else\n      _filter(pred, filterable)\n  );\n}));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xfind = require('./internal/_xfind');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_dispatchable(['find'], _xfind, function find(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  while (idx < len) {\n    if (fn(list[idx])) {\n      return list[idx];\n    }\n    idx += 1;\n  }\n}));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xfindIndex = require('./internal/_xfindIndex');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_dispatchable([], _xfindIndex, function findIndex(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  while (idx < len) {\n    if (fn(list[idx])) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n}));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xfindLast = require('./internal/_xfindLast');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_dispatchable([], _xfindLast, function findLast(fn, list) {\n  var idx = list.length - 1;\n  while (idx >= 0) {\n    if (fn(list[idx])) {\n      return list[idx];\n    }\n    idx -= 1;\n  }\n}));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xfindLastIndex = require('./internal/_xfindLastIndex');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_dispatchable([], _xfindLastIndex, function findLastIndex(fn, list) {\n  var idx = list.length - 1;\n  while (idx >= 0) {\n    if (fn(list[idx])) {\n      return idx;\n    }\n    idx -= 1;\n  }\n  return -1;\n}));\n","var _curry1 = require('./internal/_curry1');\nvar _makeFlat = require('./internal/_makeFlat');\n\n\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 */\nmodule.exports = _curry1(_makeFlat(true));\n","var _curry1 = require('./internal/_curry1');\nvar curry = require('./curry');\n\n\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 *      var 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 */\nmodule.exports = _curry1(function flip(fn) {\n  return curry(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","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry2 = require('./internal/_curry2');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_checkForMethod('forEach', function forEach(fn, list) {\n  var len = list.length;\n  var idx = 0;\n  while (idx < len) {\n    fn(list[idx]);\n    idx += 1;\n  }\n  return list;\n}));\n","var _curry2 = require('./internal/_curry2');\nvar keys = require('./keys');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function forEachObjIndexed(fn, obj) {\n  var keyList = keys(obj);\n  var idx = 0;\n  while (idx < keyList.length) {\n    var key = keyList[idx];\n    fn(obj[key], key, obj);\n    idx += 1;\n  }\n  return obj;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function fromPairs(pairs) {\n  var result = {};\n  var idx = 0;\n  while (idx < pairs.length) {\n    result[pairs[idx][0]] = pairs[idx][1];\n    idx += 1;\n  }\n  return result;\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry2 = require('./internal/_curry2');\nvar reduceBy = require('./reduceBy');\n\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.transduce\n * @example\n *\n *      var byGrade = R.groupBy(function(student) {\n *        var score = student.score;\n *        return score < 65 ? 'F' :\n *               score < 70 ? 'D' :\n *               score < 80 ? 'C' :\n *               score < 90 ? 'B' : 'A';\n *      });\n *      var 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 */\nmodule.exports = _curry2(_checkForMethod('groupBy', reduceBy(function(acc, item) {\n  if (acc == null) {\n    acc = [];\n  }\n  acc.push(item);\n  return acc;\n}, null)));\n","var _curry2 = require('./internal/_curry2');\n\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 */\nmodule.exports = _curry2(function(fn, list) {\n  var res = [];\n  var idx = 0;\n  var len = list.length;\n  while (idx < len) {\n    var nextidx = idx + 1;\n    while (nextidx < len && fn(list[nextidx - 1], list[nextidx])) {\n      nextidx += 1;\n    }\n    res.push(list.slice(idx, nextidx));\n    idx = nextidx;\n  }\n  return res;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function gt(a, b) { return a > b; });\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function gte(a, b) { return a >= b; });\n","var _curry2 = require('./internal/_curry2');\nvar _has = require('./internal/_has');\n\n\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 *      var hasName = R.has('name');\n *      hasName({name: 'alice'});   //=> true\n *      hasName({name: 'bob'});     //=> true\n *      hasName({});                //=> false\n *\n *      var point = {x: 0, y: 0};\n *      var pointHas = R.has(R.__, point);\n *      pointHas('x');  //=> true\n *      pointHas('y');  //=> true\n *      pointHas('z');  //=> false\n */\nmodule.exports = _curry2(_has);\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var square = new Rectangle(2, 2);\n *      R.hasIn('width', square);  //=> true\n *      R.hasIn('area', square);  //=> true\n */\nmodule.exports = _curry2(function hasIn(prop, obj) {\n  return prop in obj;\n});\n","var nth = require('./nth');\n\n\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 */\nmodule.exports = nth(0);\n","var _curry2 = require('./internal/_curry2');\n\n\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 * @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 *      var 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 */\nmodule.exports = _curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) { // 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","var _curry1 = require('./internal/_curry1');\nvar _identity = require('./internal/_identity');\n\n\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 *      var obj = {};\n *      R.identity(obj) === obj; //=> true\n * @symb R.identity(a) = a\n */\nmodule.exports = _curry1(_identity);\n","var _curry3 = require('./internal/_curry3');\nvar curryN = require('./curryN');\n\n\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 unary 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\n * @example\n *\n *      var 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 */\nmodule.exports = _curry3(function ifElse(condition, onTrue, onFalse) {\n  return curryN(Math.max(condition.length, onTrue.length, onFalse.length),\n    function _ifElse() {\n      return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n    }\n  );\n});\n","var add = require('./add');\n\n\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 */\nmodule.exports = add(1);\n","var reduceBy = require('./reduceBy');\n\n\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 *      var 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 */\nmodule.exports = reduceBy(function(acc, elem) { return elem; }, null);\n","var _curry2 = require('./internal/_curry2');\nvar _indexOf = require('./internal/_indexOf');\nvar _isArray = require('./internal/_isArray');\n\n\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 */\nmodule.exports = _curry2(function indexOf(target, xs) {\n  return typeof xs.indexOf === 'function' && !_isArray(xs) ?\n    xs.indexOf(target) :\n    _indexOf(xs, target, 0);\n});\n","var slice = require('./slice');\n\n\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 */\nmodule.exports = slice(0, -1);\n","var _containsWith = require('./internal/_containsWith');\nvar _curry3 = require('./internal/_curry3');\nvar _filter = require('./internal/_filter');\n\n\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 */\nmodule.exports = _curry3(function innerJoin(pred, xs, ys) {\n  return _filter(function(x) { return _containsWith(pred, x, ys); }, xs);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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 */\nmodule.exports = _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","var _curry3 = require('./internal/_curry3');\n\n\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 */\nmodule.exports = _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),\n                   elts,\n                   Array.prototype.slice.call(list, idx));\n});\n","var _contains = require('./_contains');\n\n\n// A simple Set type that honours R.equals semantics\nmodule.exports = (function() {\n  function _Set() {\n    /* globals Set */\n    this._nativeSet = typeof Set === 'function' ? new Set() : null;\n    this._items = {};\n  }\n\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  _Set.prototype.add = function(item) {\n    return !hasOrAdd(item, true, this);\n  };\n\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  _Set.prototype.has = function(item) {\n    return hasOrAdd(item, false, this);\n  };\n\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  function hasOrAdd(item, shouldAdd, set) {\n    var type = typeof item;\n    var prevSize, newSize;\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            return false;\n          }\n        }\n        // these types can all utilise the native Set\n        if (set._nativeSet !== null) {\n          if (shouldAdd) {\n            prevSize = set._nativeSet.size;\n            set._nativeSet.add(item);\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            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            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          if (set._items[type][bIdx]) {\n            return true;\n          } else {\n            if (shouldAdd) {\n              set._items[type][bIdx] = true;\n            }\n            return false;\n          }\n        } else {\n          if (shouldAdd) {\n            set._items[type] = item ? [false, true] : [true, false];\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            set._nativeSet.add(item);\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            return false;\n          }\n          if (!_contains(item, set._items[type])) {\n            if (shouldAdd) {\n              set._items[type].push(item);\n            }\n            return false;\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          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            return false;\n          }\n          return true;\n        }\n      /* falls through */\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        if (!(type in set._items)) {\n          if (shouldAdd) {\n            set._items[type] = [item];\n          }\n          return false;\n        }\n        // scan through all previously applied items\n        if (!_contains(item, set._items[type])) {\n          if (shouldAdd) {\n            set._items[type].push(item);\n          }\n          return false;\n        }\n        return true;\n    }\n  }\n  return _Set;\n}());\n","module.exports = 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  while (idx < limit) {\n    acc[idx] = Array.prototype.slice.call(list, idx, idx + n);\n    idx += 1;\n  }\n  return acc;\n};\n","module.exports = function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","module.exports = function _arrayFromIterator(iter) {\n  var list = [];\n  var next;\n  while (!(next = iter.next()).done) {\n    list.push(next.value);\n  }\n  return list;\n};\n","var _objectAssign = require('./_objectAssign');\n\nmodule.exports =\n  typeof Object.assign === 'function' ? Object.assign : _objectAssign;\n","var _isArray = require('./_isArray');\n\n\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 */\nmodule.exports = function _checkForMethod(methodname, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return (_isArray(obj) || typeof obj[methodname] !== 'function') ?\n      fn.apply(this, arguments) :\n      obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));\n  };\n};\n","var _cloneRegExp = require('./_cloneRegExp');\nvar type = require('../type');\n\n\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 */\nmodule.exports = function _clone(value, refFrom, refTo, deep) {\n  var copy = function copy(copiedValue) {\n    var len = refFrom.length;\n    var idx = 0;\n    while (idx < len) {\n      if (value === refFrom[idx]) {\n        return refTo[idx];\n      }\n      idx += 1;\n    }\n    refFrom[idx + 1] = value;\n    refTo[idx + 1] = copiedValue;\n    for (var key in value) {\n      copiedValue[key] = deep ?\n        _clone(value[key], refFrom, refTo, true) : value[key];\n    }\n    return copiedValue;\n  };\n  switch (type(value)) {\n    case 'Object':  return copy({});\n    case 'Array':   return copy([]);\n    case 'Date':    return new Date(value.valueOf());\n    case 'RegExp':  return _cloneRegExp(value);\n    default:        return value;\n  }\n};\n","module.exports = function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global     ? 'g' : '') +\n                                    (pattern.ignoreCase ? 'i' : '') +\n                                    (pattern.multiline  ? 'm' : '') +\n                                    (pattern.sticky     ? 'y' : '') +\n                                    (pattern.unicode    ? 'u' : ''));\n};\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\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 */\nmodule.exports = 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\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _indexOf = require('./_indexOf');\n\n\nmodule.exports = function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n};\n","module.exports = function _containsWith(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    idx += 1;\n  }\n  return false;\n};\n","var _arity = require('./_arity');\nvar _curry2 = require('./_curry2');\n\n\nmodule.exports = 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};\n","var _isPlaceholder = require('./_isPlaceholder');\n\n\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 */\nmodule.exports = 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};\n","var _curry1 = require('./_curry1');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\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 */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n      case 1:\n        return _isPlaceholder(a) ? f2\n             : _curry1(function(_b) { return fn(a, _b); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })\n             : fn(a, b);\n    }\n  };\n};\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\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 */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    switch (arguments.length) {\n      case 0:\n        return f3;\n      case 1:\n        return _isPlaceholder(a) ? f3\n             : _curry2(function(_b, _c) { return fn(a, _b, _c); });\n      case 2:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f3\n             : _isPlaceholder(a) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })\n             : _isPlaceholder(b) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })\n             : _curry1(function(_c) { return fn(a, b, _c); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3\n             : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) { return fn(_a, _b, c); })\n             : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })\n             : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b, c); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b, c); })\n             : _isPlaceholder(c) ? _curry1(function(_c) { return fn(a, b, _c); })\n             : fn(a, b, c);\n    }\n  };\n};\n","var _arity = require('./_arity');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\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 */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (!_isPlaceholder(received[combinedIdx]) ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined)\n                     : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\n\n\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 */\nmodule.exports = function _dispatchable(methodNames, xf, fn) {\n  return function() {\n    if (arguments.length === 0) {\n      return fn();\n    }\n    var args = Array.prototype.slice.call(arguments, 0);\n    var obj = args.pop();\n    if (!_isArray(obj)) {\n      var idx = 0;\n      while (idx < methodNames.length) {\n        if (typeof obj[methodNames[idx]] === 'function') {\n          return obj[methodNames[idx]].apply(obj, args);\n        }\n        idx += 1;\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","var take = require('../take');\n\nmodule.exports = function dropLast(n, xs) {\n  return take(n < xs.length ? xs.length - n : 0, xs);\n};\n","module.exports = function dropLastWhile(pred, list) {\n  var idx = list.length - 1;\n  while (idx >= 0 && pred(list[idx])) {\n    idx -= 1;\n  }\n  return Array.prototype.slice.call(list, 0, idx + 1);\n};\n","var _arrayFromIterator = require('./_arrayFromIterator');\nvar _functionName = require('./_functionName');\nvar _has = require('./_has');\nvar identical = require('../identical');\nvar keys = require('../keys');\nvar type = require('../type');\n\n\nmodule.exports = function _equals(a, b, stackA, stackB) {\n  if (identical(a, b)) {\n    return true;\n  }\n\n  if (type(a) !== 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) &&\n           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) &&\n           typeof b.equals === 'function' && b.equals(a);\n  }\n\n  switch (type(a)) {\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n      if (typeof a.constructor === 'function' &&\n          _functionName(a.constructor) === 'Promise') {\n        return a === b;\n      }\n      break;\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n      if (!(typeof a === typeof b && identical(a.valueOf(), b.valueOf()))) {\n        return false;\n      }\n      break;\n    case 'Date':\n      if (!identical(a.valueOf(), b.valueOf())) {\n        return false;\n      }\n      break;\n    case 'Error':\n      return a.name === b.name && a.message === b.message;\n    case 'RegExp':\n      if (!(a.source === b.source &&\n            a.global === b.global &&\n            a.ignoreCase === b.ignoreCase &&\n            a.multiline === b.multiline &&\n            a.sticky === b.sticky &&\n            a.unicode === b.unicode)) {\n        return false;\n      }\n      break;\n    case 'Map':\n    case 'Set':\n      if (!_equals(_arrayFromIterator(a.entries()), _arrayFromIterator(b.entries()), stackA, stackB)) {\n        return false;\n      }\n      break;\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      break;\n    case 'ArrayBuffer':\n      break;\n    default:\n      // Values of other types are only equal if identical.\n      return false;\n  }\n\n  var keysA = keys(a);\n  if (keysA.length !== keys(b).length) {\n    return false;\n  }\n\n  var idx = stackA.length - 1;\n  while (idx >= 0) {\n    if (stackA[idx] === a) {\n      return stackB[idx] === b;\n    }\n    idx -= 1;\n  }\n\n  stackA.push(a);\n  stackB.push(b);\n  idx = keysA.length - 1;\n  while (idx >= 0) {\n    var key = keysA[idx];\n    if (!(_has(key, b) && _equals(b[key], a[key], stackA, stackB))) {\n      return false;\n    }\n    idx -= 1;\n  }\n  stackA.pop();\n  stackB.pop();\n  return true;\n};\n","module.exports = 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    idx += 1;\n  }\n  return result;\n};\n","var _forceReduced = require('./_forceReduced');\nvar _isArrayLike = require('./_isArrayLike');\nvar _reduce = require('./_reduce');\nvar _xfBase = require('./_xfBase');\n\nmodule.exports = (function() {\n  var 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\n  return 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}());\n","module.exports = function _forceReduced(x) {\n  return {\n    '@@transducer/value': x,\n    '@@transducer/reduced': true\n  };\n};\n","module.exports = 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};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","module.exports = function _identity(x) { return x; };\n","var equals = require('../equals');\n\n\nmodule.exports = function _indexOf(list, a, idx) {\n  var inf, item;\n  // Array.prototype.indexOf doesn't exist below IE9\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          while (idx < list.length) {\n            item = list[idx];\n            if (item === 0 && 1 / item === inf) {\n              return idx;\n            }\n            idx += 1;\n          }\n          return -1;\n        } else if (a !== a) {\n          // NaN\n          while (idx < list.length) {\n            item = list[idx];\n            if (typeof item === 'number' && item !== item) {\n              return idx;\n            }\n            idx += 1;\n          }\n          return -1;\n        }\n        // non-zero numbers can utilise Set\n        return list.indexOf(a, idx);\n\n      // all these types can utilise Set\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  while (idx < list.length) {\n    if (equals(list[idx], a)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n};\n","var _has = require('./_has');\n\n\nmodule.exports = (function() {\n  var toString = Object.prototype.toString;\n  return toString.call(arguments) === '[object Arguments]' ?\n    function _isArguments(x) { return toString.call(x) === '[object Arguments]'; } :\n    function _isArguments(x) { return _has('callee', x); };\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 */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","var _curry1 = require('./_curry1');\nvar _isArray = require('./_isArray');\nvar _isString = require('./_isString');\n\n\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 */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (_isString(x)) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","module.exports = function _isFunction(x) {\n  return Object.prototype.toString.call(x) === '[object Function]';\n};\n","/**\n * Determine if the passed argument is an integer.\n *\n * @private\n * @param {*} n\n * @category Type\n * @return {Boolean}\n */\nmodule.exports = Number.isInteger || function _isInteger(n) {\n  return (n << 0) === n;\n};\n","module.exports = function _isNumber(x) {\n  return Object.prototype.toString.call(x) === '[object Number]';\n};\n","module.exports = function _isObject(x) {\n  return Object.prototype.toString.call(x) === '[object Object]';\n};\n","module.exports = function _isPlaceholder(a) {\n  return a != null &&\n         typeof a === 'object' &&\n         a['@@functional/placeholder'] === true;\n};\n","module.exports = function _isRegExp(x) {\n  return Object.prototype.toString.call(x) === '[object RegExp]';\n};\n","module.exports = function _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n};\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","var _isArrayLike = require('./_isArrayLike');\n\n\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 */\nmodule.exports = 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        while (j < jlen) {\n          result[result.length] = value[j];\n          j += 1;\n        }\n      } else {\n        result[result.length] = list[idx];\n      }\n      idx += 1;\n    }\n    return result;\n  };\n};\n","module.exports = function _map(fn, functor) {\n  var idx = 0;\n  var len = functor.length;\n  var result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(functor[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","var _has = require('./_has');\n\n// Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\nmodule.exports = function _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  while (idx < length) {\n    var source = arguments[idx];\n    if (source != null) {\n      for (var nextKey in source) {\n        if (_has(nextKey, source)) {\n          output[nextKey] = source[nextKey];\n        }\n      }\n    }\n    idx += 1;\n  }\n  return output;\n};\n","module.exports = function _of(x) { return [x]; };\n","module.exports = function _pipe(f, g) {\n  return function() {\n    return g.call(this, f.apply(this, arguments));\n  };\n};\n","module.exports = 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};\n","module.exports = function _quote(s) {\n  var escaped = s\n    .replace(/\\\\/g, '\\\\\\\\')\n    .replace(/[\\b]/g, '\\\\b')  // \\b matches word boundary; [\\b] matches backspace\n    .replace(/\\f/g, '\\\\f')\n    .replace(/\\n/g, '\\\\n')\n    .replace(/\\r/g, '\\\\r')\n    .replace(/\\t/g, '\\\\t')\n    .replace(/\\v/g, '\\\\v')\n    .replace(/\\0/g, '\\\\0');\n\n  return '\"' + escaped.replace(/\"/g, '\\\\\"') + '\"';\n};\n","var _isArrayLike = require('./_isArrayLike');\nvar _xwrap = require('./_xwrap');\nvar bind = require('../bind');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0;\n    var len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj, methodName) {\n    return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (_isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list['fantasy-land/reduce'] === 'function') {\n      return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\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  };\n}());\n","module.exports = function _reduced(x) {\n  return x && x['@@transducer/reduced'] ? x :\n    {\n      '@@transducer/value': x,\n      '@@transducer/reduced': true\n    };\n};\n","var _assign = require('./_assign');\nvar _identity = require('./_identity');\nvar _isArrayLike = require('./_isArrayLike');\nvar _isTransformer = require('./_isTransformer');\nvar objOf = require('../objOf');\n\n\nmodule.exports = (function() {\n  var _stepCatArray = {\n    '@@transducer/init': Array,\n    '@@transducer/step': function(xs, x) {\n      xs.push(x);\n      return xs;\n    },\n    '@@transducer/result': _identity\n  };\n  var _stepCatString = {\n    '@@transducer/init': String,\n    '@@transducer/step': function(a, b) { return a + b; },\n    '@@transducer/result': _identity\n  };\n  var _stepCatObject = {\n    '@@transducer/init': Object,\n    '@@transducer/step': function(result, input) {\n      return _assign(\n        result,\n        _isArrayLike(input) ? objOf(input[0], input[1]) : input\n      );\n    },\n    '@@transducer/result': _identity\n  };\n\n  return function _stepCat(obj) {\n    if (_isTransformer(obj)) {\n      return obj;\n    }\n    if (_isArrayLike(obj)) {\n      return _stepCatArray;\n    }\n    if (typeof obj === 'string') {\n      return _stepCatString;\n    }\n    if (typeof obj === 'object') {\n      return _stepCatObject;\n    }\n    throw new Error('Cannot create transformer for ' + obj);\n  };\n}());\n","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nmodule.exports = (function() {\n  var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };\n\n  return typeof Date.prototype.toISOString === 'function' ?\n    function _toISOString(d) {\n      return d.toISOString();\n    } :\n    function _toISOString(d) {\n      return (\n        d.getUTCFullYear() + '-' +\n        pad(d.getUTCMonth() + 1) + '-' +\n        pad(d.getUTCDate()) + 'T' +\n        pad(d.getUTCHours()) + ':' +\n        pad(d.getUTCMinutes()) + ':' +\n        pad(d.getUTCSeconds()) + '.' +\n        (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'\n      );\n    };\n}());\n","var _contains = require('./_contains');\nvar _map = require('./_map');\nvar _quote = require('./_quote');\nvar _toISOString = require('./_toISOString');\nvar keys = require('../keys');\nvar reject = require('../reject');\n\n\nmodule.exports = function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function(obj, keys) {\n    return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, 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    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(function(k) { return /^\\d+$/.test(k); }, keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      if (typeof x.toString === 'function') {\n        var repr = x.toString();\n        if (repr !== '[object Object]') {\n          return repr;\n        }\n      }\n      return '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XAll(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.all = true;\n  }\n  XAll.prototype['@@transducer/init'] = _xfBase.init;\n  XAll.prototype['@@transducer/result'] = function(result) {\n    if (this.all) {\n      result = this.xf['@@transducer/step'](result, true);\n    }\n    return this.xf['@@transducer/result'](result);\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    return result;\n  };\n\n  return _curry2(function _xall(f, xf) { return new XAll(f, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XAny(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.any = false;\n  }\n  XAny.prototype['@@transducer/init'] = _xfBase.init;\n  XAny.prototype['@@transducer/result'] = function(result) {\n    if (!this.any) {\n      result = this.xf['@@transducer/step'](result, false);\n    }\n    return this.xf['@@transducer/result'](result);\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    return result;\n  };\n\n  return _curry2(function _xany(f, xf) { return new XAny(f, xf); });\n}());\n","var _concat = require('./_concat');\nvar _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (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  XAperture.prototype['@@transducer/init'] = _xfBase.init;\n  XAperture.prototype['@@transducer/result'] = function(result) {\n    this.acc = null;\n    return this.xf['@@transducer/result'](result);\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  XAperture.prototype.store = function(input) {\n    this.acc[this.pos] = input;\n    this.pos += 1;\n    if (this.pos === this.acc.length) {\n      this.pos = 0;\n      this.full = true;\n    }\n  };\n  XAperture.prototype.getCopy = function() {\n    return _concat(Array.prototype.slice.call(this.acc, this.pos),\n                   Array.prototype.slice.call(this.acc, 0, this.pos));\n  };\n\n  return _curry2(function _xaperture(n, xf) { return new XAperture(n, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _flatCat = require('./_flatCat');\nvar map = require('../map');\n\n\nmodule.exports = _curry2(function _xchain(f, xf) {\n  return map(f, _flatCat(xf));\n});\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XDrop(n, xf) {\n    this.xf = xf;\n    this.n = n;\n  }\n  XDrop.prototype['@@transducer/init'] = _xfBase.init;\n  XDrop.prototype['@@transducer/result'] = _xfBase.result;\n  XDrop.prototype['@@transducer/step'] = function(result, input) {\n    if (this.n > 0) {\n      this.n -= 1;\n      return result;\n    }\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return _curry2(function _xdrop(n, xf) { return new XDrop(n, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (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  XDropLast.prototype['@@transducer/init'] = _xfBase.init;\n  XDropLast.prototype['@@transducer/result'] =  function(result) {\n    this.acc = null;\n    return this.xf['@@transducer/result'](result);\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    this.store(input);\n    return result;\n  };\n  XDropLast.prototype.store = function(input) {\n    this.acc[this.pos] = input;\n    this.pos += 1;\n    if (this.pos === this.acc.length) {\n      this.pos = 0;\n      this.full = true;\n    }\n  };\n\n  return _curry2(function _xdropLast(n, xf) { return new XDropLast(n, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _reduce = require('./_reduce');\nvar _xfBase = require('./_xfBase');\n\nmodule.exports = (function() {\n  function XDropLastWhile(fn, xf) {\n    this.f = fn;\n    this.retained = [];\n    this.xf = xf;\n  }\n  XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XDropLastWhile.prototype['@@transducer/result'] = function(result) {\n    this.retained = null;\n    return this.xf['@@transducer/result'](result);\n  };\n  XDropLastWhile.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.retain(result, input)\n                         : this.flush(result, input);\n  };\n  XDropLastWhile.prototype.flush = function(result, input) {\n    result = _reduce(\n      this.xf['@@transducer/step'],\n      result,\n      this.retained\n    );\n    this.retained = [];\n    return this.xf['@@transducer/step'](result, input);\n  };\n  XDropLastWhile.prototype.retain = function(result, input) {\n    this.retained.push(input);\n    return result;\n  };\n\n  return _curry2(function _xdropLastWhile(fn, xf) { return new XDropLastWhile(fn, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (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  XDropRepeatsWith.prototype['@@transducer/step'] = function(result, input) {\n    var sameAsLast = false;\n    if (!this.seenFirstValue) {\n      this.seenFirstValue = true;\n    } else if (this.pred(this.lastValue, input)) {\n      sameAsLast = true;\n    }\n    this.lastValue = input;\n    return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n  };\n\n  return _curry2(function _xdropRepeatsWith(pred, xf) { return new XDropRepeatsWith(pred, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XDropWhile(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n  XDropWhile.prototype['@@transducer/step'] = function(result, input) {\n    if (this.f) {\n      if (this.f(input)) {\n        return result;\n      }\n      this.f = null;\n    }\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return _curry2(function _xdropWhile(f, xf) { return new XDropWhile(f, xf); });\n}());\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFind(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.found = false;\n  }\n  XFind.prototype['@@transducer/init'] = _xfBase.init;\n  XFind.prototype['@@transducer/result'] = function(result) {\n    if (!this.found) {\n      result = this.xf['@@transducer/step'](result, void 0);\n    }\n    return this.xf['@@transducer/result'](result);\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    return result;\n  };\n\n  return _curry2(function _xfind(f, xf) { return new XFind(f, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFindIndex(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.idx = -1;\n    this.found = false;\n  }\n  XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n  XFindIndex.prototype['@@transducer/result'] = function(result) {\n    if (!this.found) {\n      result = this.xf['@@transducer/step'](result, -1);\n    }\n    return this.xf['@@transducer/result'](result);\n  };\n  XFindIndex.prototype['@@transducer/step'] = function(result, input) {\n    this.idx += 1;\n    if (this.f(input)) {\n      this.found = true;\n      result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n    }\n    return result;\n  };\n\n  return _curry2(function _xfindIndex(f, xf) { return new XFindIndex(f, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFindLast(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n  XFindLast.prototype['@@transducer/result'] = function(result) {\n    return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n  };\n  XFindLast.prototype['@@transducer/step'] = function(result, input) {\n    if (this.f(input)) {\n      this.last = input;\n    }\n    return result;\n  };\n\n  return _curry2(function _xfindLast(f, xf) { return new XFindLast(f, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFindLastIndex(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.idx = -1;\n    this.lastIdx = -1;\n  }\n  XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n  XFindLastIndex.prototype['@@transducer/result'] = function(result) {\n    return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n  };\n  XFindLastIndex.prototype['@@transducer/step'] = function(result, input) {\n    this.idx += 1;\n    if (this.f(input)) {\n      this.lastIdx = this.idx;\n    }\n    return result;\n  };\n\n  return _curry2(function _xfindLastIndex(f, xf) { return new XFindLastIndex(f, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n}());\n","var _curryN = require('./_curryN');\nvar _has = require('./_has');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (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  XReduceBy.prototype['@@transducer/init'] = _xfBase.init;\n  XReduceBy.prototype['@@transducer/result'] = function(result) {\n    var key;\n    for (key in this.inputs) {\n      if (_has(key, this.inputs)) {\n        result = this.xf['@@transducer/step'](result, this.inputs[key]);\n        if (result['@@transducer/reduced']) {\n          result = result['@@transducer/value'];\n          break;\n        }\n      }\n    }\n    this.inputs = null;\n    return this.xf['@@transducer/result'](result);\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 _curryN(4, [],\n                 function _xreduceBy(valueFn, valueAcc, keyFn, xf) {\n                   return new XReduceBy(valueFn, valueAcc, keyFn, xf);\n                 });\n}());\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\nmodule.exports = (function() {\n  function XTake(n, xf) {\n    this.xf = xf;\n    this.n = n;\n    this.i = 0;\n  }\n  XTake.prototype['@@transducer/init'] = _xfBase.init;\n  XTake.prototype['@@transducer/result'] = _xfBase.result;\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 _curry2(function _xtake(n, xf) { return new XTake(n, xf); });\n}());\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XTakeWhile(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\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 _curry2(function _xtakeWhile(f, xf) { return new XTakeWhile(f, xf); });\n}());\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\nvar _filter = require('./internal/_filter');\nvar flip = require('./flip');\nvar uniq = require('./uniq');\n\n\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 */\nmodule.exports = _curry2(function intersection(list1, list2) {\n  var lookupList, filteredList;\n  if (list1.length > list2.length) {\n    lookupList = list1;\n    filteredList = list2;\n  } else {\n    lookupList = list2;\n    filteredList = list1;\n  }\n  return uniq(_filter(flip(_contains)(lookupList), filteredList));\n});\n","var _containsWith = require('./internal/_containsWith');\nvar _curry3 = require('./internal/_curry3');\nvar uniqWith = require('./uniqWith');\n\n\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of those\n * elements common to both lists. 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 function that determines whether\n *        the two supplied elements are equal.\n * @param {Array} list1 One list of items to compare\n * @param {Array} list2 A second list of items to compare\n * @return {Array} A new list containing those elements common to both lists.\n * @see R.innerJoin\n * @deprecated since v0.24.0\n * @example\n *\n *      var buffaloSpringfield = [\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 *      ];\n *      var csny = [\n *        {id: 204, name: 'David Crosby'},\n *        {id: 456, name: 'Stephen Stills'},\n *        {id: 539, name: 'Graham Nash'},\n *        {id: 177, name: 'Neil Young'}\n *      ];\n *\n *      R.intersectionWith(R.eqBy(R.prop('id')), buffaloSpringfield, csny);\n *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n */\nmodule.exports = _curry3(function intersectionWith(pred, list1, list2) {\n  var lookupList, filteredList;\n  if (list1.length > list2.length) {\n    lookupList = list1;\n    filteredList = list2;\n  } else {\n    lookupList = list2;\n    filteredList = list1;\n  }\n  var results = [];\n  var idx = 0;\n  while (idx < filteredList.length) {\n    if (_containsWith(pred, filteredList[idx], lookupList)) {\n      results[results.length] = filteredList[idx];\n    }\n    idx += 1;\n  }\n  return uniqWith(pred, results);\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry2 = require('./internal/_curry2');\n\n\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('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']\n */\nmodule.exports = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {\n  var out = [];\n  var idx = 0;\n  var length = list.length;\n  while (idx < length) {\n    if (idx === length - 1) {\n      out.push(list[idx]);\n    } else {\n      out.push(list[idx], separator);\n    }\n    idx += 1;\n  }\n  return out;\n}));\n","var _clone = require('./internal/_clone');\nvar _curry3 = require('./internal/_curry3');\nvar _isTransformer = require('./internal/_isTransformer');\nvar _reduce = require('./internal/_reduce');\nvar _stepCat = require('./internal/_stepCat');\n\n\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 * @example\n *\n *      var numbers = [1, 2, 3, 4];\n *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n *\n *      R.into([], transducer, numbers); //=> [2, 3]\n *\n *      var intoArray = R.into([]);\n *      intoArray(transducer, numbers); //=> [2, 3]\n */\nmodule.exports = _curry3(function into(acc, xf, list) {\n  return _isTransformer(acc) ?\n    _reduce(xf(acc), acc['@@transducer/init'](), list) :\n    _reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\nvar keys = require('./keys');\n\n\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 *      var raceResultsByFirstName = {\n *        first: 'alice',\n *        second: 'jake',\n *        third: 'alice',\n *      };\n *      R.invert(raceResultsByFirstName);\n *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n */\nmodule.exports = _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  return out;\n});\n","var _curry1 = require('./internal/_curry1');\nvar keys = require('./keys');\n\n\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 *      var raceResults = {\n *        first: 'alice',\n *        second: 'jake'\n *      };\n *      R.invertObj(raceResults);\n *      //=> { 'alice': 'first', 'jake':'second' }\n *\n *      // Alternatively:\n *      var raceResults = ['alice', 'jake'];\n *      R.invertObj(raceResults);\n *      //=> { 'alice': '0', 'jake':'1' }\n */\nmodule.exports = _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  return out;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _isFunction = require('./internal/_isFunction');\nvar curryN = require('./curryN');\nvar toString = require('./toString');\n\n\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 the method to call.\n * @return {Function} A new curried function.\n * @see R.construct\n * @example\n *\n *      var sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      var sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\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 */\nmodule.exports = _curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function() {\n    var target = arguments[arity];\n    if (target != null && _isFunction(target[method])) {\n      return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));\n    }\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function is(Ctor, val) {\n  return val != null && val.constructor === Ctor || val instanceof Ctor;\n});\n","var _curry1 = require('./internal/_curry1');\nvar empty = require('./empty');\nvar equals = require('./equals');\n\n\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 */\nmodule.exports = _curry1(function isEmpty(x) {\n  return x != null && equals(x, empty(x));\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function isNil(x) { return x == null; });\n","var invoker = require('./invoker');\n\n\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 *      var spacer = R.join(' ');\n *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n */\nmodule.exports = invoker(1, 'join');\n","var _curry1 = require('./internal/_curry1');\nvar converge = require('./converge');\n\n\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 *      var 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 */\nmodule.exports = _curry1(function juxt(fns) {\n  return converge(function() { return Array.prototype.slice.call(arguments, 0); }, fns);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\nvar _isArguments = require('./internal/_isArguments');\n\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 */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n  // Safari bug\n  var hasArgsEnumBug = (function() {\n    'use strict';\n    return arguments.propertyIsEnumerable('length');\n  }());\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' && !hasArgsEnumBug ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, nIdx;\n      var ks = [];\n      var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n      for (prop in obj) {\n        if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _curry1 = require('./internal/_curry1');\n\n\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 *      var F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      var f = new F();\n *      R.keysIn(f); //=> ['x', 'y']\n */\nmodule.exports = _curry1(function keysIn(obj) {\n  var prop;\n  var ks = [];\n  for (prop in obj) {\n    ks[ks.length] = prop;\n  }\n  return ks;\n});\n","var nth = require('./nth');\n\n\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 */\nmodule.exports = nth(-1);\n","var _curry2 = require('./internal/_curry2');\nvar _isArray = require('./internal/_isArray');\nvar equals = require('./equals');\n\n\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 */\nmodule.exports = _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    while (idx >= 0) {\n      if (equals(xs[idx], target)) {\n        return idx;\n      }\n      idx -= 1;\n    }\n    return -1;\n  }\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isNumber = require('./internal/_isNumber');\n\n\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 */\nmodule.exports = _curry1(function length(list) {\n  return list != null && _isNumber(list.length) ? list.length : NaN;\n});\n","var _curry2 = require('./internal/_curry2');\nvar map = require('./map');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function lens(getter, setter) {\n  return function(toFunctorFn) {\n    return function(target) {\n      return map(\n        function(focus) {\n          return setter(focus, target);\n        },\n        toFunctorFn(getter(target))\n      );\n    };\n  };\n});\n","var _curry1 = require('./internal/_curry1');\nvar lens = require('./lens');\nvar nth = require('./nth');\nvar update = require('./update');\n\n\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\n * @example\n *\n *      var 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 */\nmodule.exports = _curry1(function lensIndex(n) {\n  return lens(nth(n), update(n));\n});\n","var _curry1 = require('./internal/_curry1');\nvar assocPath = require('./assocPath');\nvar lens = require('./lens');\nvar path = require('./path');\n\n\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 *      var 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 */\nmodule.exports = _curry1(function lensPath(p) {\n  return lens(path(p), assocPath(p));\n});\n","var _curry1 = require('./internal/_curry1');\nvar assoc = require('./assoc');\nvar lens = require('./lens');\nvar prop = require('./prop');\n\n\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 *      var 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 */\nmodule.exports = _curry1(function lensProp(k) {\n  return lens(prop(k), assoc(k));\n});\n","var _curry1 = require('./internal/_curry1');\nvar liftN = require('./liftN');\n\n\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 *      var 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 *      var 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 */\nmodule.exports = _curry1(function lift(fn) {\n  return liftN(fn.length, fn);\n});\n","var _curry2 = require('./internal/_curry2');\nvar _reduce = require('./internal/_reduce');\nvar ap = require('./ap');\nvar curryN = require('./curryN');\nvar map = require('./map');\n\n\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 *      var 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 */\nmodule.exports = _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","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function lt(a, b) { return a < b; });\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function lte(a, b) { return a <= b; });\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _reduce = require('./internal/_reduce');\nvar _xmap = require('./internal/_xmap');\nvar curryN = require('./curryN');\nvar keys = require('./keys');\n\n\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 *      var 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 */\nmodule.exports = _curry2(_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    case '[object Object]':\n      return _reduce(function(acc, key) {\n        acc[key] = fn(functor[key]);\n        return acc;\n      }, {}, keys(functor));\n    default:\n      return _map(fn, functor);\n  }\n}));\n","var _curry3 = require('./internal/_curry3');\n\n\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.addIndex, R.mapAccumRight\n * @example\n *\n *      var digits = ['1', '2', '3', '4'];\n *      var 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 */\nmodule.exports = _curry3(function mapAccum(fn, acc, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n  var tuple = [acc];\n  while (idx < len) {\n    tuple = fn(tuple[0], list[idx]);\n    result[idx] = tuple[1];\n    idx += 1;\n  }\n  return [tuple[0], result];\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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, *value* and *acc*, and should\n * return a tuple *[value, acc]*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig (x-> acc -> (y, acc)) -> acc -> [x] -> ([y], acc)\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 *      var digits = ['1', '2', '3', '4'];\n *      var append = (a, b) => [a + b, a + b];\n *\n *      R.mapAccumRight(append, 5, digits); //=> [['12345', '2345', '345', '45'], '12345']\n * @symb R.mapAccumRight(f, a, [b, c, d]) = [\n *   [\n *     f(b, f(c, f(d, a)[0])[0])[1],\n *     f(c, f(d, a)[0])[1],\n *     f(d, a)[1],\n *   ]\n *   f(b, f(c, f(d, a)[0])[0])[0],\n * ]\n */\nmodule.exports = _curry3(function mapAccumRight(fn, acc, list) {\n  var idx = list.length - 1;\n  var result = [];\n  var tuple = [acc];\n  while (idx >= 0) {\n    tuple = fn(list[idx], tuple[0]);\n    result[idx] = tuple[1];\n    idx -= 1;\n  }\n  return [result, tuple[0]];\n});\n","var _curry2 = require('./internal/_curry2');\nvar _reduce = require('./internal/_reduce');\nvar keys = require('./keys');\n\n\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 *      var values = { x: 1, y: 2, z: 3 };\n *      var prependKeyAndDouble = (num, key, obj) => key + (num * 2);\n *\n *      R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }\n */\nmodule.exports = _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","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function match(rx, str) {\n  return str.match(rx) || [];\n});\n","var _curry2 = require('./internal/_curry2');\nvar _isInteger = require('./internal/_isInteger');\n\n\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 *      var clock = R.mathMod(R.__, 12);\n *      clock(15); //=> 3\n *      clock(24); //=> 0\n *\n *      var seventeenMod = R.mathMod(17);\n *      seventeenMod(3);  //=> 2\n *      seventeenMod(4);  //=> 1\n *      seventeenMod(10); //=> 7\n */\nmodule.exports = _curry2(function mathMod(m, p) {\n  if (!_isInteger(m)) { return NaN; }\n  if (!_isInteger(p) || p < 1) { return NaN; }\n  return ((m % p) + p) % p;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function max(a, b) { return b > a ? b : a; });\n","var _curry3 = require('./internal/_curry3');\n\n\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 *      var 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 */\nmodule.exports = _curry3(function maxBy(f, a, b) {\n  return f(b) > f(a) ? b : a;\n});\n","var _curry1 = require('./internal/_curry1');\nvar sum = require('./sum');\n\n\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 */\nmodule.exports = _curry1(function mean(list) {\n  return sum(list) / list.length;\n});\n","var _curry1 = require('./internal/_curry1');\nvar mean = require('./mean');\n\n\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 */\nmodule.exports = _curry1(function median(list) {\n  var len = list.length;\n  if (len === 0) {\n    return NaN;\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","var memoizeWith = require('./memoizeWith');\nvar toString = require('./toString');\n\n\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 * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (*... -> a) -> (*... -> a)\n * @param {Function} fn The function to memoize.\n * @return {Function} Memoized version of `fn`.\n * @see R.memoizeWith\n * @example\n *\n *      let count = 0;\n *      const factorial = R.memoize(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 */\nmodule.exports = memoizeWith(function() {\n  return toString(arguments);\n});\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\nvar _has = require('./internal/_has');\n\n\n/**\n * A customisable version of [`R.memoize`](#memoize). `memoizeWith` takes an\n * additional function that will be applied to a given argument set and used to\n * create the cache key under which the results of the function to be memoized\n * will be stored. Care must be taken when implementing key generation to avoid\n * clashes that may overwrite previous entries erroneously.\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 * @see R.memoize\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 */\nmodule.exports = _curry2(function memoizeWith(mFn, fn) {\n  var cache = {};\n  return _arity(fn.length, function() {\n    var key = mFn.apply(this, arguments);\n    if (!_has(key, cache)) {\n      cache[key] = fn.apply(this, arguments);\n    }\n    return cache[key];\n  });\n});\n","var _assign = require('./internal/_assign');\nvar _curry2 = require('./internal/_curry2');\n\n\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.mergeDeepRight, R.mergeWith, R.mergeWithKey\n * @example\n *\n *      R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      var resetToDefault = R.merge(R.__, {x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n * @symb R.merge({ x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: 5, z: 3 }\n */\nmodule.exports = _curry2(function merge(l, r) {\n  return _assign({}, l, r);\n});\n","var _assign = require('./internal/_assign');\nvar _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function mergeAll(list) {\n  return _assign.apply(null, [{}].concat(list));\n});\n","var _curry2 = require('./internal/_curry2');\nvar mergeDeepWithKey = require('./mergeDeepWithKey');\n\n\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 */\nmodule.exports = _curry2(function mergeDeepLeft(lObj, rObj) {\n  return mergeDeepWithKey(function(k, lVal, rVal) {\n    return lVal;\n  }, lObj, rObj);\n});\n","var _curry2 = require('./internal/_curry2');\nvar mergeDeepWithKey = require('./mergeDeepWithKey');\n\n\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 */\nmodule.exports = _curry2(function mergeDeepRight(lObj, rObj) {\n  return mergeDeepWithKey(function(k, lVal, rVal) {\n    return rVal;\n  }, lObj, rObj);\n});\n","var _curry3 = require('./internal/_curry3');\nvar mergeDeepWithKey = require('./mergeDeepWithKey');\n\n\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.mergeDeep, 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 */\nmodule.exports = _curry3(function mergeDeepWith(fn, lObj, rObj) {\n  return mergeDeepWithKey(function(k, lVal, rVal) {\n    return fn(lVal, rVal);\n  }, lObj, rObj);\n});\n","var _curry3 = require('./internal/_curry3');\nvar _isObject = require('./internal/_isObject');\nvar mergeWithKey = require('./mergeWithKey');\n\n\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.mergeDeep, 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 */\nmodule.exports = _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","var _curry3 = require('./internal/_curry3');\nvar mergeWithKey = require('./mergeWithKey');\n\n\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 */\nmodule.exports = _curry3(function mergeWith(fn, l, r) {\n  return mergeWithKey(function(_, _l, _r) {\n    return fn(_l, _r);\n  }, l, r);\n});\n","var _curry3 = require('./internal/_curry3');\nvar _has = require('./internal/_has');\n\n\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 */\nmodule.exports = _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","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function min(a, b) { return b < a ? b : a; });\n","var _curry3 = require('./internal/_curry3');\n\n\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 *      var 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 */\nmodule.exports = _curry3(function minBy(f, a, b) {\n  return f(b) < f(a) ? b : a;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var isOdd = R.modulo(R.__, 2);\n *      isOdd(42); //=> 0\n *      isOdd(21); //=> 1\n */\nmodule.exports = _curry2(function modulo(a, b) { return a % b; });\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var double = R.multiply(2);\n *      var triple = R.multiply(3);\n *      double(3);       //=>  6\n *      triple(4);       //=> 12\n *      R.multiply(2, 5);  //=> 10\n */\nmodule.exports = _curry2(function multiply(a, b) { return a * b; });\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var takesTwoArgs = (a, b) => [a, b];\n *\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var 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 */\nmodule.exports = _curry2(function nAry(n, fn) {\n  switch (n) {\n    case 0: return function() {return fn.call(this);};\n    case 1: return function(a0) {return fn.call(this, a0);};\n    case 2: return function(a0, a1) {return fn.call(this, a0, a1);};\n    case 3: return function(a0, a1, a2) {return fn.call(this, a0, a1, a2);};\n    case 4: return function(a0, a1, a2, a3) {return fn.call(this, a0, a1, a2, a3);};\n    case 5: return function(a0, a1, a2, a3, a4) {return fn.call(this, a0, a1, a2, a3, a4);};\n    case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.call(this, a0, a1, a2, a3, a4, a5);};\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6);};\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);};\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);};\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);};\n    default: throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n  }\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function negate(n) { return -n; });\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xany = require('./internal/_xany');\nvar any = require('./any');\n\n\n/**\n * Returns `true` if no elements of the list match the predicate, `false`\n * otherwise.\n *\n * Dispatches to the `any` method of the second argument, if present.\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 *      var isEven = n => n % 2 === 0;\n *\n *      R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true\n *      R.none(isEven, [1, 3, 5, 7, 8, 11]); //=> false\n */\nmodule.exports = _curry2(_complement(_dispatchable(['any'], _xany, any)));\n","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function not(a) {\n  return !a;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _isString = require('./internal/_isString');\n\n\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 *      var 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 */\nmodule.exports = _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","var _curry1 = require('./internal/_curry1');\nvar curryN = require('./curryN');\nvar nth = require('./nth');\n\n\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 */\nmodule.exports = _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","var _curry3 = require('./internal/_curry3');\n\n\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.\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 *      var classyGreeting = name => \"The name's \" + name.last + \", \" + name.first + \" \" + lastName\n *      var 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 */\nmodule.exports = _curry3(function o(f, g, x) {\n  return f(g(x));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function objOf(key, val) {\n  var obj = {};\n  obj[key] = val;\n  return obj;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _of = require('./internal/_of');\n\n\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 */\nmodule.exports = _curry1(_of);\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function omit(names, obj) {\n  var result = {};\n  for (var prop in obj) {\n    if (!_contains(prop, names)) {\n      result[prop] = obj[prop];\n    }\n  }\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\n\n\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 *      var addOneOnce = R.once(x => x + 1);\n *      addOneOnce(10); //=> 11\n *      addOneOnce(addOneOnce(50)); //=> 11\n */\nmodule.exports = _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    called = true;\n    result = fn.apply(this, arguments);\n    return result;\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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\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 */\nmodule.exports = _curry2(function or(a, b) {\n  return a || b;\n});\n","var _curry3 = require('./internal/_curry3');\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 *      var headLens = R.lensIndex(0);\n *\n *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n */\nmodule.exports = (function() {\n  // `Identity` is a functor that holds a single value, where `map` simply\n  // transforms the held value with the provided function.\n  var Identity = function(x) {\n    return {value: x, map: function(f) { return Identity(f(x)); }};\n  };\n\n  return _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) { return Identity(f(y)); })(x).value;\n  });\n}());\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function pair(fst, snd) { return [fst, snd]; });\n","var _concat = require('./internal/_concat');\nvar _createPartialApplicator = require('./internal/_createPartialApplicator');\n\n\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\n * @example\n *\n *      var multiply2 = (a, b) => a * b;\n *      var double = R.partial(multiply2, [2]);\n *      double(2); //=> 4\n *\n *      var greet = (salutation, title, firstName, lastName) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      var sayHello = R.partial(greet, ['Hello']);\n *      var 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 */\nmodule.exports = _createPartialApplicator(_concat);\n","var _concat = require('./internal/_concat');\nvar _createPartialApplicator = require('./internal/_createPartialApplicator');\nvar flip = require('./flip');\n\n\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 *      var greet = (salutation, title, firstName, lastName) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      var 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 */\nmodule.exports = _createPartialApplicator(flip(_concat));\n","var filter = require('./filter');\nvar juxt = require('./juxt');\nvar reject = require('./reject');\n\n\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.contains('s'), ['sss', 'ttt', 'foo', 'bars']);\n *      // => [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n *\n *      R.partition(R.contains('s'), { a: 'sss', b: 'ttt', foo: 'bars' });\n *      // => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' }  ]\n */\nmodule.exports = juxt([filter, reject]);\n","var _curry2 = require('./internal/_curry2');\n\n\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\n * @example\n *\n *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n */\nmodule.exports = _curry2(function path(paths, obj) {\n  var val = obj;\n  var idx = 0;\n  while (idx < paths.length) {\n    if (val == null) {\n      return;\n    }\n    val = val[paths[idx]];\n    idx += 1;\n  }\n  return val;\n});\n","var _curry3 = require('./internal/_curry3');\nvar equals = require('./equals');\nvar path = require('./path');\n\n\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 *      var user1 = { address: { zipCode: 90210 } };\n *      var user2 = { address: { zipCode: 55555 } };\n *      var user3 = { name: 'Bob' };\n *      var users = [ user1, user2, user3 ];\n *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n *      R.filter(isFamous, users); //=> [ user1 ]\n */\nmodule.exports = _curry3(function pathEq(_path, val, obj) {\n  return equals(path(_path, obj), val);\n});\n","var _curry3 = require('./internal/_curry3');\nvar defaultTo = require('./defaultTo');\nvar path = require('./path');\n\n\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 */\nmodule.exports = _curry3(function pathOr(d, p, obj) {\n  return defaultTo(d, path(p, obj));\n});\n","var _curry3 = require('./internal/_curry3');\nvar path = require('./path');\n\n\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 */\nmodule.exports = _curry3(function pathSatisfies(pred, propPath, obj) {\n  return propPath.length > 0 && pred(path(propPath, obj));\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function pick(names, obj) {\n  var result = {};\n  var idx = 0;\n  while (idx < names.length) {\n    if (names[idx] in obj) {\n      result[names[idx]] = obj[names[idx]];\n    }\n    idx += 1;\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function pickAll(names, obj) {\n  var result = {};\n  var idx = 0;\n  var len = names.length;\n  while (idx < len) {\n    var name = names[idx];\n    result[name] = obj[name];\n    idx += 1;\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var isUpperCase = (val, key) => key.toUpperCase() === key;\n *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n */\nmodule.exports = _curry2(function pickBy(test, obj) {\n  var result = {};\n  for (var prop in obj) {\n    if (test(obj[prop], prop, obj)) {\n      result[prop] = obj[prop];\n    }\n  }\n  return result;\n});\n","var _arity = require('./internal/_arity');\nvar _pipe = require('./internal/_pipe');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions 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 *      var 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 */\nmodule.exports = function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return _arity(arguments[0].length,\n                reduce(_pipe, arguments[0], tail(arguments)));\n};\n","var composeK = require('./composeK');\nvar reverse = require('./reverse');\n\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(R.chain(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 * @example\n *\n *      //  parseJson :: String -> Maybe *\n *      //  get :: String -> Object -> Maybe *\n *\n *      //  getStateCode :: Maybe String -> Maybe String\n *      var 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 */\nmodule.exports = function pipeK() {\n  if (arguments.length === 0) {\n    throw new Error('pipeK requires at least one argument');\n  }\n  return composeK.apply(this, reverse(arguments));\n};\n","var _arity = require('./internal/_arity');\nvar _pipeP = require('./internal/_pipeP');\nvar reduce = require('./reduce');\nvar tail = require('./tail');\n\n\n/**\n * Performs left-to-right composition of one or more Promise-returning\n * functions. The leftmost function may have any arity; the remaining functions\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 * @example\n *\n *      //  followersForUser :: String -> Promise [User]\n *      var followersForUser = R.pipeP(db.getUserById, db.getFollowers);\n */\nmodule.exports = function pipeP() {\n  if (arguments.length === 0) {\n    throw new Error('pipeP requires at least one argument');\n  }\n  return _arity(arguments[0].length,\n                reduce(_pipeP, arguments[0], tail(arguments)));\n};\n","var _curry2 = require('./internal/_curry2');\nvar map = require('./map');\nvar prop = require('./prop');\n\n\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 *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\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 */\nmodule.exports = _curry2(function pluck(p, list) {\n  return map(prop(p), list);\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function prepend(el, list) {\n  return _concat([el], list);\n});\n","var multiply = require('./multiply');\nvar reduce = require('./reduce');\n\n\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 */\nmodule.exports = reduce(multiply, 1);\n","var _map = require('./internal/_map');\nvar identity = require('./identity');\nvar pickAll = require('./pickAll');\nvar useWith = require('./useWith');\n\n\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 *      var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n *      var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n *      var kids = [abby, fred];\n *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n */\nmodule.exports = useWith(_map, [pickAll, identity]); // passing `identity` gives correct arity\n","var _curry2 = require('./internal/_curry2');\n\n\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 * @sig s -> {s: a} -> a | Undefined\n * @param {String} p The property name\n * @param {Object} obj The object to query\n * @return {*} The value at `obj.p`.\n * @see R.path\n * @example\n *\n *      R.prop('x', {x: 100}); //=> 100\n *      R.prop('x', {}); //=> undefined\n */\nmodule.exports = _curry2(function prop(p, obj) { return obj[p]; });\n","var _curry3 = require('./internal/_curry3');\nvar equals = require('./equals');\n\n\n/**\n * Returns `true` if the specified object property is equal, in\n * [`R.equals`](#equals) terms, to the given value; `false` otherwise.\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.equals, R.propSatisfies\n * @example\n *\n *      var abby = {name: 'Abby', age: 7, hair: 'blond'};\n *      var fred = {name: 'Fred', age: 12, hair: 'brown'};\n *      var rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n *      var alois = {name: 'Alois', age: 15, disposition: 'surly'};\n *      var kids = [abby, fred, rusty, alois];\n *      var hasBrownHair = R.propEq('hair', 'brown');\n *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n */\nmodule.exports = _curry3(function propEq(name, val, obj) {\n  return equals(val, obj[name]);\n});\n","var _curry3 = require('./internal/_curry3');\nvar is = require('./is');\n\n\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 */\nmodule.exports = _curry3(function propIs(type, name, obj) {\n  return is(type, obj[name]);\n});\n","var _curry3 = require('./internal/_curry3');\nvar _has = require('./internal/_has');\n\n\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 *      var alice = {\n *        name: 'ALICE',\n *        age: 101\n *      };\n *      var favorite = R.prop('favoriteLibrary');\n *      var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n *\n *      favorite(alice);  //=> undefined\n *      favoriteWithDefault(alice);  //=> 'Ramda'\n */\nmodule.exports = _curry3(function propOr(val, p, obj) {\n  return (obj != null && _has(p, obj)) ? obj[p] : val;\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Returns `true` if the specified object property satisfies the given\n * predicate; `false` otherwise.\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.propEq, R.propIs\n * @example\n *\n *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n */\nmodule.exports = _curry3(function propSatisfies(pred, name, obj) {\n  return pred(obj[name]);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n */\nmodule.exports = _curry2(function props(ps, obj) {\n  var len = ps.length;\n  var out = [];\n  var idx = 0;\n\n  while (idx < len) {\n    out[idx] = obj[ps[idx]];\n    idx += 1;\n  }\n\n  return out;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _isNumber = require('./internal/_isNumber');\n\n\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 tthe set `[a, b)`.\n * @example\n *\n *      R.range(1, 5);    //=> [1, 2, 3, 4]\n *      R.range(50, 53);  //=> [50, 51, 52]\n */\nmodule.exports = _curry2(function range(from, to) {\n  if (!(_isNumber(from) && _isNumber(to))) {\n    throw new TypeError('Both arguments to range must be numbers');\n  }\n  var result = [];\n  var n = from;\n  while (n < to) {\n    result.push(n);\n    n += 1;\n  }\n  return result;\n});\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\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 */\nmodule.exports = _curry3(_reduce);\n","var _curryN = require('./internal/_curryN');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _has = require('./internal/_has');\nvar _reduce = require('./internal/_reduce');\nvar _xreduceBy = require('./internal/_xreduceBy');\n\n\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 *      var reduceToNamesBy = R.reduceBy((acc, student) => acc.concat(student.name), []);\n *      var namesByGrade = reduceToNamesBy(function(student) {\n *        var score = student.score;\n *        return score < 65 ? 'F' :\n *               score < 70 ? 'D' :\n *               score < 80 ? 'C' :\n *               score < 90 ? 'B' : 'A';\n *      });\n *      var students = [{name: 'Lucy', score: 92},\n *                      {name: 'Drew', score: 85},\n *                      // ...\n *                      {name: 'Bart', score: 62}];\n *      namesByGrade(students);\n *      // {\n *      //   'A': ['Lucy'],\n *      //   'B': ['Drew']\n *      //   // ...,\n *      //   'F': ['Bart']\n *      // }\n */\nmodule.exports = _curryN(4, [], _dispatchable([], _xreduceBy,\n  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] : valueAcc, elt);\n      return acc;\n    }, {}, list);\n  }));\n","var _curry3 = require('./internal/_curry3');\n\n\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 */\nmodule.exports = _curry3(function reduceRight(fn, acc, list) {\n  var idx = list.length - 1;\n  while (idx >= 0) {\n    acc = fn(list[idx], acc);\n    idx -= 1;\n  }\n  return acc;\n});\n","var _curryN = require('./internal/_curryN');\nvar _reduce = require('./internal/_reduce');\nvar _reduced = require('./internal/_reduced');\n\n\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 *      var isOdd = (acc, x) => x % 2 === 1;\n *      var xs = [1, 3, 5, 60, 777, 800];\n *      R.reduceWhile(isOdd, R.add, 0, xs); //=> 9\n *\n *      var ys = [2, 4, 6]\n *      R.reduceWhile(isOdd, R.add, 111, ys); //=> 111\n */\nmodule.exports = _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","var _curry1 = require('./internal/_curry1');\nvar _reduced = require('./internal/_reduced');\n\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 unavailable to functions not explicitly listed\n * above. For instance, it is not currently supported by\n * [`reduceRight`](#reduceRight).\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.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\nmodule.exports = _curry1(_reduced);\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function reject(pred, filterable) {\n  return filter(_complement(pred), filterable);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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 * @example\n *\n *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n */\nmodule.exports = _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","var _curry2 = require('./internal/_curry2');\nvar always = require('./always');\nvar times = require('./times');\n\n\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 *      var obj = {};\n *      var 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 */\nmodule.exports = _curry2(function repeat(value, n) {\n  return times(always(value), n);\n});\n","var _curry3 = require('./internal/_curry3');\n\n\n/**\n * Replace a substring or regex match in a string with a replacement.\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 */\nmodule.exports = _curry3(function replace(regex, replacement, str) {\n  return str.replace(regex, replacement);\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isString = require('./internal/_isString');\n\n\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 */\nmodule.exports = _curry1(function reverse(list) {\n  return _isString(list) ? list.split('').reverse().join('') :\n                           Array.prototype.slice.call(list, 0).reverse();\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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\n * @example\n *\n *      var numbers = [1, 2, 3, 4];\n *      var 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 */\nmodule.exports = _curry3(function scan(fn, acc, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [acc];\n  while (idx < len) {\n    acc = fn(acc, list[idx]);\n    result[idx + 1] = acc;\n    idx += 1;\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\nvar ap = require('./ap');\nvar map = require('./map');\nvar prepend = require('./prepend');\nvar reduceRight = require('./reduceRight');\n\n\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 */\nmodule.exports = _curry2(function sequence(of, traversable) {\n  return typeof traversable.sequence === 'function' ?\n    traversable.sequence(of) :\n    reduceRight(function(x, acc) { return ap(map(prepend, x), acc); },\n                of([]),\n                traversable);\n});\n","var _curry3 = require('./internal/_curry3');\nvar always = require('./always');\nvar over = require('./over');\n\n\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 *      var 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 */\nmodule.exports = _curry3(function set(lens, v, x) {\n  return over(lens, always(v), x);\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry3 = require('./internal/_curry3');\n\n\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 */\nmodule.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var diff = function(a, b) { return a - b; };\n *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n */\nmodule.exports = _curry2(function sort(comparator, list) {\n  return Array.prototype.slice.call(list, 0).sort(comparator);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var sortByFirstItem = R.sortBy(R.prop(0));\n *      var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n *      var pairs = [[-1, 1], [-2, 2], [-3, 3]];\n *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n *      var alice = {\n *        name: 'ALICE',\n *        age: 101\n *      };\n *      var bob = {\n *        name: 'Bob',\n *        age: -10\n *      };\n *      var clara = {\n *        name: 'clara',\n *        age: 314.159\n *      };\n *      var people = [clara, bob, alice];\n *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n */\nmodule.exports = _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","var _curry2 = require('./internal/_curry2');\n\n\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 *      var alice = {\n *        name: 'alice',\n *        age: 40\n *      };\n *      var bob = {\n *        name: 'bob',\n *        age: 30\n *      };\n *      var clara = {\n *        name: 'clara',\n *        age: 40\n *      };\n *      var people = [clara, bob, alice];\n *      var ageNameSort = R.sortWith([\n *        R.descend(R.prop('age')),\n *        R.ascend(R.prop('name'))\n *      ]);\n *      ageNameSort(people); //=> [alice, clara, bob]\n */\nmodule.exports = _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    while (result === 0 && i < fns.length) {\n      result = fns[i](a, b);\n      i += 1;\n    }\n    return result;\n  });\n});\n","var invoker = require('./invoker');\n\n\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 `str`.\n * @see R.join\n * @example\n *\n *      var 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 */\nmodule.exports = invoker(1, 'split');\n","var _curry2 = require('./internal/_curry2');\nvar length = require('./length');\nvar slice = require('./slice');\n\n\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 */\nmodule.exports = _curry2(function splitAt(index, array) {\n  return [slice(0, index, array), slice(index, length(array), array)];\n});\n","var _curry2 = require('./internal/_curry2');\nvar slice = require('./slice');\n\n\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 */\nmodule.exports = _curry2(function splitEvery(n, list) {\n  if (n <= 0) {\n    throw new Error('First argument to splitEvery must be a positive integer');\n  }\n  var result = [];\n  var idx = 0;\n  while (idx < list.length) {\n    result.push(slice(idx, idx += n, list));\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _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","var _curry2 = require('./internal/_curry2');\nvar equals = require('./equals');\nvar take = require('./take');\n\n/**\n * Checks if a list starts with the provided values\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> Boolean\n * @sig String -> Boolean\n * @param {*} prefix\n * @param {*} list\n * @return {Boolean}\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 */\nmodule.exports = _curry2(function(prefix, list) {\n  return equals(take(prefix.length, list), prefix);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var minus5 = R.subtract(R.__, 5);\n *      minus5(17); //=> 12\n *\n *      var complementaryAngle = R.subtract(90);\n *      complementaryAngle(30); //=> 60\n *      complementaryAngle(72); //=> 18\n */\nmodule.exports = _curry2(function subtract(a, b) {\n  return Number(a) - Number(b);\n});\n","var add = require('./add');\nvar reduce = require('./reduce');\n\n\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 */\nmodule.exports = reduce(add, 0);\n","var _curry2 = require('./internal/_curry2');\nvar concat = require('./concat');\nvar difference = require('./difference');\n\n\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 */\nmodule.exports = _curry2(function symmetricDifference(list1, list2) {\n  return concat(difference(list1, list2), difference(list2, list1));\n});\n","var _curry3 = require('./internal/_curry3');\nvar concat = require('./concat');\nvar differenceWith = require('./differenceWith');\n\n\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 *      var eqA = R.eqBy(R.prop('a'));\n *      var l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];\n *      var l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];\n *      R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]\n */\nmodule.exports = _curry3(function symmetricDifferenceWith(pred, list1, list2) {\n  return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1));\n});\n","var _checkForMethod = require('./internal/_checkForMethod');\nvar _curry1 = require('./internal/_curry1');\nvar slice = require('./slice');\n\n\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 */\nmodule.exports = _curry1(_checkForMethod('tail', slice(1, Infinity)));\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xtake = require('./internal/_xtake');\nvar slice = require('./slice');\n\n\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 *      var 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 *      var 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 */\nmodule.exports = _curry2(_dispatchable(['take'], _xtake, function take(n, xs) {\n  return slice(0, n < 0 ? Infinity : n, xs);\n}));\n","var _curry2 = require('./internal/_curry2');\nvar drop = require('./drop');\n\n\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 */\nmodule.exports = _curry2(function takeLast(n, xs) {\n  return drop(n >= 0 ? xs.length - n : 0, xs);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropLastWhile, R.addIndex\n * @example\n *\n *      var isNotOne = x => x !== 1;\n *\n *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n */\nmodule.exports = _curry2(function takeLastWhile(fn, list) {\n  var idx = list.length - 1;\n  while (idx >= 0 && fn(list[idx])) {\n    idx -= 1;\n  }\n  return Array.prototype.slice.call(list, idx + 1);\n});\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xtakeWhile = require('./internal/_xtakeWhile');\n\n\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 * @param {Function} fn The function called per iteration.\n * @param {Array} list The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropWhile, R.transduce, R.addIndex\n * @example\n *\n *      var isNotFour = x => x !== 4;\n *\n *      R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]\n */\nmodule.exports = _curry2(_dispatchable(['takeWhile'], _xtakeWhile, function takeWhile(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  while (idx < len && fn(list[idx])) {\n    idx += 1;\n  }\n  return Array.prototype.slice.call(list, 0, idx);\n}));\n","var _curry2 = require('./internal/_curry2');\n\n\n/**\n * Runs the given function with the supplied object, then returns the object.\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 *      var 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 */\nmodule.exports = _curry2(function tap(fn, x) {\n  fn(x);\n  return x;\n});\n","var _cloneRegExp = require('./internal/_cloneRegExp');\nvar _curry2 = require('./internal/_curry2');\nvar _isRegExp = require('./internal/_isRegExp');\nvar toString = require('./toString');\n\n\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 */\nmodule.exports = _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  return _cloneRegExp(pattern).test(str);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _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  list = new Array(len);\n  while (idx < len) {\n    list[idx] = fn(idx);\n    idx += 1;\n  }\n  return list;\n});\n","var invoker = require('./invoker');\n\n\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 */\nmodule.exports = invoker(0, 'toLowerCase');\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\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 */\nmodule.exports = _curry1(function toPairs(obj) {\n  var pairs = [];\n  for (var prop in obj) {\n    if (_has(prop, obj)) {\n      pairs[pairs.length] = [prop, obj[prop]];\n    }\n  }\n  return pairs;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 *      var F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      var f = new F();\n *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n */\nmodule.exports = _curry1(function toPairsIn(obj) {\n  var pairs = [];\n  for (var prop in obj) {\n    pairs[pairs.length] = [prop, obj[prop]];\n  }\n  return pairs;\n});\n","var _curry1 = require('./internal/_curry1');\nvar _toString = require('./internal/_toString');\n\n\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 */\nmodule.exports = _curry1(function toString(val) { return _toString(val, []); });\n","var invoker = require('./invoker');\n\n\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 */\nmodule.exports = invoker(0, 'toUpperCase');\n","var _reduce = require('./internal/_reduce');\nvar _xwrap = require('./internal/_xwrap');\nvar curryN = require('./curryN');\n\n\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 *      var numbers = [1, 2, 3, 4];\n *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n *\n *      var isOdd = (x) => x % 2 === 1;\n *      var firstOddTransducer = R.compose(R.filter(isOdd), R.take(1));\n *      R.transduce(firstOddTransducer, R.flip(R.append), [], R.range(0, 100)); //=> [1]\n */\nmodule.exports = curryN(4, function transduce(xf, fn, acc, list) {\n  return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function transpose(outerlist) {\n  var i = 0;\n  var result = [];\n  while (i < outerlist.length) {\n    var innerlist = outerlist[i];\n    var j = 0;\n    while (j < innerlist.length) {\n      if (typeof result[j] === 'undefined') {\n        result[j] = [];\n      }\n      result[j].push(innerlist[j]);\n      j += 1;\n    }\n    i += 1;\n  }\n  return result;\n});\n","var _curry3 = require('./internal/_curry3');\nvar map = require('./map');\nvar sequence = require('./sequence');\n\n\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 `sequence` 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 `Nothing` if the given divisor is `0`\n *      safeDiv = n => d => d === 0 ? Nothing() : Just(n / d)\n *\n *      R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Just([5, 2.5, 2])\n *      R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Nothing\n */\nmodule.exports = _curry3(function traverse(of, f, traversable) {\n  return typeof traversable['fantasy-land/traverse'] === 'function' ?\n    traversable['fantasy-land/traverse'](f, of) :\n    sequence(of, map(f, traversable));\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = (function() {\n  var ws = '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' +\n           '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' +\n           '\\u2029\\uFEFF';\n  var zeroWidth = '\\u200b';\n  var hasProtoTrim = (typeof String.prototype.trim === 'function');\n  if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {\n    return _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    });\n  } else {\n    return _curry1(function trim(str) {\n      return str.trim();\n    });\n  }\n}());\n","var _arity = require('./internal/_arity');\nvar _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\n\n\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(R.prop('x'), R.F)(null);      //=> false\n */\nmodule.exports = _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","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function type(val) {\n  return val === null      ? 'Null'      :\n         val === undefined ? 'Undefined' :\n         Object.prototype.toString.call(val).slice(8, -1);\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 */\nmodule.exports = _curry1(function unapply(fn) {\n  return function() {\n    return fn(Array.prototype.slice.call(arguments, 0));\n  };\n});\n","var _curry1 = require('./internal/_curry1');\nvar nAry = require('./nAry');\n\n\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 *      var takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      var 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 */\nmodule.exports = _curry1(function unary(fn) {\n  return nAry(1, fn);\n});\n","var _curry2 = require('./internal/_curry2');\nvar curryN = require('./curryN');\n\n\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 *      var addFour = a => b => c => d => a + b + c + d;\n *\n *      var uncurriedAddFour = R.uncurryN(4, addFour);\n *      uncurriedAddFour(1, 2, 3, 4); //=> 10\n */\nmodule.exports = _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    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    return value;\n  });\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function unfold(fn, seed) {\n  var pair = fn(seed);\n  var result = [];\n  while (pair && pair.length) {\n    result[result.length] = pair[0];\n    pair = fn(pair[1]);\n  }\n  return result;\n});\n","var _concat = require('./internal/_concat');\nvar _curry2 = require('./internal/_curry2');\nvar compose = require('./compose');\nvar uniq = require('./uniq');\n\n\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 */\nmodule.exports = _curry2(compose(uniq, _concat));\n","var _concat = require('./internal/_concat');\nvar _curry3 = require('./internal/_curry3');\nvar uniqWith = require('./uniqWith');\n\n\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 *      var l1 = [{a: 1}, {a: 2}];\n *      var l2 = [{a: 1}, {a: 4}];\n *      R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n */\nmodule.exports = _curry3(function unionWith(pred, list1, list2) {\n  return uniqWith(pred, _concat(list1, list2));\n});\n","var identity = require('./identity');\nvar uniqBy = require('./uniqBy');\n\n\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 */\nmodule.exports = uniqBy(identity);\n","var _Set = require('./internal/_Set');\nvar _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _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    if (set.add(appliedItem)) {\n      result.push(item);\n    }\n    idx += 1;\n  }\n  return result;\n});\n","var _containsWith = require('./internal/_containsWith');\nvar _curry2 = require('./internal/_curry2');\n\n\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 *      var 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 */\nmodule.exports = _curry2(function uniqWith(pred, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n  var item;\n  while (idx < len) {\n    item = list[idx];\n    if (!_containsWith(pred, item, result)) {\n      result[result.length] = item;\n    }\n    idx += 1;\n  }\n  return result;\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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\n * @example\n *\n *      let safeInc = R.unless(R.isNil, R.inc);\n *      safeInc(null); //=> null\n *      safeInc(1); //=> 2\n */\nmodule.exports = _curry3(function unless(pred, whenFalseFn, x) {\n  return pred(x) ? x : whenFalseFn(x);\n});\n","var _identity = require('./internal/_identity');\nvar chain = require('./chain');\n\n\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 */\nmodule.exports = chain(_identity);\n","var _curry3 = require('./internal/_curry3');\n\n\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 */\nmodule.exports = _curry3(function until(pred, fn, init) {\n  var val = init;\n  while (!pred(val)) {\n    val = fn(val);\n  }\n  return val;\n});\n","var _curry3 = require('./internal/_curry3');\nvar adjust = require('./adjust');\nvar always = require('./always');\n\n\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, 11, [0, 1, 2]);     //=> [0, 11, 2]\n *      R.update(1)(11)([0, 1, 2]);     //=> [0, 11, 2]\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 */\nmodule.exports = _curry3(function update(idx, x, list) {\n  return adjust(always(x), idx, list);\n});\n","var _curry2 = require('./internal/_curry2');\nvar curryN = require('./curryN');\n\n\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 */\nmodule.exports = _curry2(function useWith(fn, transformers) {\n  return curryN(transformers.length, function() {\n    var args = [];\n    var idx = 0;\n    while (idx < transformers.length) {\n      args.push(transformers[idx].call(this, arguments[idx]));\n      idx += 1;\n    }\n    return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length)));\n  });\n});\n","var _curry1 = require('./internal/_curry1');\nvar keys = require('./keys');\n\n\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 */\nmodule.exports = _curry1(function values(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var vals = [];\n  var idx = 0;\n  while (idx < len) {\n    vals[idx] = obj[props[idx]];\n    idx += 1;\n  }\n  return vals;\n});\n","var _curry1 = require('./internal/_curry1');\n\n\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 *      var F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      var f = new F();\n *      R.valuesIn(f); //=> ['X', 'Y']\n */\nmodule.exports = _curry1(function valuesIn(obj) {\n  var prop;\n  var vs = [];\n  for (prop in obj) {\n    vs[vs.length] = obj[prop];\n  }\n  return vs;\n});\n","var _curry2 = require('./internal/_curry2');\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 *      var xLens = R.lensProp('x');\n *\n *      R.view(xLens, {x: 1, y: 2});  //=> 1\n *      R.view(xLens, {x: 4, y: 2});  //=> 4\n */\nmodule.exports = (function() {\n  // `Const` is a functor that effectively ignores the function given to `map`.\n  var Const = function(x) {\n    return {value: x, 'fantasy-land/map': function() { return this; }};\n  };\n\n  return _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}());\n","var _curry3 = require('./internal/_curry3');\n\n\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\n * @example\n *\n *      // truncate :: String -> String\n *      var 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 */\nmodule.exports = _curry3(function when(pred, whenTrueFn, x) {\n  return pred(x) ? whenTrueFn(x) : x;\n});\n","var _curry2 = require('./internal/_curry2');\nvar _has = require('./internal/_has');\n\n\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 * @example\n *\n *      // pred :: Object -> Boolean\n *      var 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 */\nmodule.exports = _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  return true;\n});\n","var _curry2 = require('./internal/_curry2');\nvar equals = require('./equals');\nvar map = require('./map');\nvar where = require('./where');\n\n\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.where\n * @example\n *\n *      // pred :: Object -> Boolean\n *      var 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 */\nmodule.exports = _curry2(function whereEq(spec, testObj) {\n  return where(map(equals, spec), testObj);\n});\n","var _contains = require('./internal/_contains');\nvar _curry2 = require('./internal/_curry2');\nvar flip = require('./flip');\nvar reject = require('./reject');\n\n\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\n * @example\n *\n *      R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]\n */\nmodule.exports = _curry2(function(xs, list) {\n  return reject(flip(_contains)(xs), list);\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function xprod(a, b) { // = 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  while (idx < ilen) {\n    j = 0;\n    while (j < jlen) {\n      result[result.length] = [a[idx], b[j]];\n      j += 1;\n    }\n    idx += 1;\n  }\n  return result;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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 */\nmodule.exports = _curry2(function zip(a, b) {\n  var rv = [];\n  var idx = 0;\n  var len = Math.min(a.length, b.length);\n  while (idx < len) {\n    rv[idx] = [a[idx], b[idx]];\n    idx += 1;\n  }\n  return rv;\n});\n","var _curry2 = require('./internal/_curry2');\n\n\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(zipWith(pair), 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 */\nmodule.exports = _curry2(function zipObj(keys, values) {\n  var idx = 0;\n  var len = Math.min(keys.length, values.length);\n  var out = {};\n  while (idx < len) {\n    out[keys[idx]] = values[idx];\n    idx += 1;\n  }\n  return out;\n});\n","var _curry3 = require('./internal/_curry3');\n\n\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 *      var 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 */\nmodule.exports = _curry3(function zipWith(fn, a, b) {\n  var rv = [];\n  var idx = 0;\n  var len = Math.min(a.length, b.length);\n  while (idx < len) {\n    rv[idx] = fn(a[idx], b[idx]);\n    idx += 1;\n  }\n  return rv;\n});\n"],"names":["module","exports","F","T","__","add","addIndex","adjust","all","allPass","always","and","any","anyPass","ap","aperture","append","apply","applySpec","ascend","assoc","assocPath","binary","bind","both","call","chain","clamp","clone","comparator","complement","compose","composeK","composeP","concat","cond","construct","constructN","contains","converge","countBy","curry","curryN","dec","defaultTo","descend","difference","differenceWith","dissoc","dissocPath","divide","drop","dropLast","dropLastWhile","dropRepeats","dropRepeatsWith","dropWhile","either","empty","endsWith","eqBy","eqProps","equals","evolve","filter","find","findIndex","findLast","findLastIndex","flatten","flip","forEach","forEachObjIndexed","fromPairs","groupBy","groupWith","gt","gte","has","hasIn","head","identical","identity","ifElse","inc","indexBy","indexOf","init","innerJoin","insert","insertAll","intersection","intersectionWith","intersperse","into","invert","invertObj","invoker","is","isEmpty","isNil","join","juxt","keys","keysIn","last","lastIndexOf","length","lens","lensIndex","lensPath","lensProp","lift","liftN","lt","lte","map","mapAccum","mapAccumRight","mapObjIndexed","match","mathMod","max","maxBy","mean","median","memoize","memoizeWith","merge","mergeAll","mergeDeepLeft","mergeDeepRight","mergeDeepWith","mergeDeepWithKey","mergeWith","mergeWithKey","min","minBy","modulo","multiply","nAry","negate","none","not","nth","nthArg","o","objOf","of","omit","once","or","over","pair","partial","partialRight","partition","path","pathEq","pathOr","pathSatisfies","pick","pickAll","pickBy","pipe","pipeK","pipeP","pluck","prepend","product","project","prop","propEq","propIs","propOr","propSatisfies","props","range","reduce","reduceBy","reduceRight","reduceWhile","reduced","reject","remove","repeat","replace","reverse","scan","sequence","set","slice","sort","sortBy","sortWith","split","splitAt","splitEvery","splitWhen","startsWith","subtract","sum","symmetricDifference","symmetricDifferenceWith","tail","take","takeLast","takeLastWhile","takeWhile","tap","test","times","toLower","toPairs","toPairsIn","toString","toUpper","transduce","transpose","traverse","trim","tryCatch","type","unapply","unary","uncurryN","unfold","union","unionWith","uniq","uniqBy","uniqWith","unless","unnest","until","update","useWith","values","valuesIn","view","when","where","whereEq","without","xprod","zip","zipObj","zipWith","_curry2","a","b","Number","_concat","_curry1","fn","idx","origFn","arguments","list","args","Array","prototype","result","this","_curry3","_idx","_list","_dispatchable","_xall","preds","len","val","_xany","_reduce","applyF","applyX","x","acc","f","_aperture","_xaperture","el","spec","v","aa","bb","obj","p","_has","_isArray","_isInteger","nextObj","arr","_arity","thisObj","_isFunction","g","_makeFlat","_xchain","monad","value","Error","_clone","pred","pop","_isString","TypeError","pairs","arity","Fn","n","$0","$1","$2","$3","$4","$5","$6","$7","$8","$9","_contains","_map","after","fns","context","elem","_curryN","d","first","second","out","firstLen","_containsWith","push","_xdrop","xs","Math","Infinity","_dropLast","_xdropLast","_dropLastWhile","_xdropLastWhile","_xdropRepeatsWith","_xdropWhile","_isArguments","_isObject","constructor","suffix","y","obj1","obj2","_equals","transformations","object","transformation","key","_filter","_xfilter","filterable","_xfind","_xfindIndex","_xfindLast","_xfindLastIndex","_checkForMethod","keyList","item","res","nextidx","_identity","condition","onTrue","onFalse","_indexOf","target","ys","elt","splice","elts","_Set","_nativeSet","Set","_items","hasOrAdd","shouldAdd","prevSize","size","bIdx","Object","limit","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","iter","next","done","_objectAssign","assign","methodname","_cloneRegExp","refFrom","refTo","deep","copy","copiedValue","Date","valueOf","pattern","RegExp","source","global","ignoreCase","multiline","sticky","unicode","set1","set2","len1","len2","_isPlaceholder","f1","f2","_b","_a","f3","c","_c","received","combined","argsIdx","left","combinedIdx","_isTransformer","methodNames","xf","transducer","_arrayFromIterator","_functionName","stackA","stackB","name","message","entries","keysA","_forceReduced","_isArrayLike","_xfBase","rxf","input","ret","preservingReduced","String","hasOwnProperty","inf","isArray","nodeType","isInteger","recursive","flatt","jlen","j","ilen","functor","output","nextKey","ctx","then","s","_xwrap","_iterableReduce","step","_methodReduce","methodName","symIterator","Symbol","iterator","_arrayReduce","_stepCatArray","_stepCatString","_stepCatObject","_assign","pad","toISOString","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","toFixed","_quote","_toISOString","_toString","seen","recur","mapPairs","k","isNaN","NaN","repr","_reduced","XAll","XAny","XAperture","pos","full","store","getCopy","_flatCat","XDrop","XDropLast","XDropLastWhile","retained","retain","flush","XDropRepeatsWith","lastValue","undefined","seenFirstValue","sameAsLast","XDropWhile","XFilter","XFind","found","XFindIndex","XFindLast","XFindLastIndex","lastIdx","XMap","XReduceBy","valueFn","valueAcc","keyFn","inputs","XTake","i","XTakeWhile","XWrap","list1","list2","lookupList","filteredList","results","separator","_stepCat","method","Ctor","hasEnumBug","nonEnumerableProps","hasArgsEnumBug","propertyIsEnumerable","nIdx","ks","checkArgsLength","_isNumber","getter","setter","toFunctorFn","focus","lifted","_xmap","tuple","rx","str","m","width","mFn","cache","l","r","lObj","rObj","lVal","rVal","_","_l","_r","_complement","offset","charAt","_of","names","called","Identity","fst","snd","_createPartialApplicator","paths","_path","propPath","_pipe","_pipeP","ps","from","to","_xreduceBy","start","count","regex","replacement","traversable","fromIndex","toIndex","index","array","prefix","_xtake","_xtakeWhile","_isRegExp","RangeError","outerlist","innerlist","ws","beginRx","endRx","tryer","catcher","e","depth","endIdx","currentDepth","seed","appliedItem","whenFalseFn","transformers","vals","vs","Const","whenTrueFn","testObj","rv"],"sourceRoot":""}