{"version":3,"file":"884.bundle.js","mappings":"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","sources":["webpack:///../node_modules/@paypalcorp/fpti/dist/fpti.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/MessagingLogger.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/api/chatApi.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/index.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/types/InboxStringSet.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/types/Logger.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/types/SSEClientInstance.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/types/SSETypes.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/types/conversation.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/types/index.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/utils/TimerUtils.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/utils/apiUtils.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/utils/createMasker.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/utils/global-data.js","webpack:///../node_modules/@paypalcorp/msgcommon-data/dist/utils/utils.js","webpack:///../node_modules/@paypalcorp/pp-react-auto-suggest/dist/@paypalcorp/pp-react-auto-suggest.esm.js","webpack:///../node_modules/@paypalcorp/pp-react-contextual-alert/dist/@paypalcorp/pp-react-contextual-alert.esm.js","webpack:///../node_modules/beaver-logger/dist/beaver-logger.js","webpack:///../node_modules/cssfilter/lib/css.js","webpack:///../node_modules/cssfilter/lib/default.js","webpack:///../node_modules/cssfilter/lib/index.js","webpack:///../node_modules/cssfilter/lib/parser.js","webpack:///../node_modules/cssfilter/lib/util.js","webpack:///../node_modules/ramda/src/F.js","webpack:///../node_modules/ramda/src/T.js","webpack:///../node_modules/ramda/src/__.js","webpack:///../node_modules/ramda/src/add.js","webpack:///../node_modules/ramda/src/addIndex.js","webpack:///../node_modules/ramda/src/adjust.js","webpack:///../node_modules/ramda/src/all.js","webpack:///../node_modules/ramda/src/allPass.js","webpack:///../node_modules/ramda/src/always.js","webpack:///../node_modules/ramda/src/and.js","webpack:///../node_modules/ramda/src/andThen.js","webpack:///../node_modules/ramda/src/any.js","webpack:///../node_modules/ramda/src/anyPass.js","webpack:///../node_modules/ramda/src/ap.js","webpack:///../node_modules/ramda/src/aperture.js","webpack:///../node_modules/ramda/src/append.js","webpack:///../node_modules/ramda/src/apply.js","webpack:///../node_modules/ramda/src/applySpec.js","webpack:///../node_modules/ramda/src/applyTo.js","webpack:///../node_modules/ramda/src/ascend.js","webpack:///../node_modules/ramda/src/assoc.js","webpack:///../node_modules/ramda/src/assocPath.js","webpack:///../node_modules/ramda/src/binary.js","webpack:///../node_modules/ramda/src/bind.js","webpack:///../node_modules/ramda/src/both.js","webpack:///../node_modules/ramda/src/call.js","webpack:///../node_modules/ramda/src/chain.js","webpack:///../node_modules/ramda/src/clamp.js","webpack:///../node_modules/ramda/src/clone.js","webpack:///../node_modules/ramda/src/collectBy.js","webpack:///../node_modules/ramda/src/comparator.js","webpack:///../node_modules/ramda/src/complement.js","webpack:///../node_modules/ramda/src/compose.js","webpack:///../node_modules/ramda/src/composeWith.js","webpack:///../node_modules/ramda/src/concat.js","webpack:///../node_modules/ramda/src/cond.js","webpack:///../node_modules/ramda/src/construct.js","webpack:///../node_modules/ramda/src/constructN.js","webpack:///../node_modules/ramda/src/converge.js","webpack:///../node_modules/ramda/src/count.js","webpack:///../node_modules/ramda/src/countBy.js","webpack:///../node_modules/ramda/src/curry.js","webpack:///../node_modules/ramda/src/curryN.js","webpack:///../node_modules/ramda/src/dec.js","webpack:///../node_modules/ramda/src/defaultTo.js","webpack:///../node_modules/ramda/src/descend.js","webpack:///../node_modules/ramda/src/difference.js","webpack:///../node_modules/ramda/src/differenceWith.js","webpack:///../node_modules/ramda/src/dissoc.js","webpack:///../node_modules/ramda/src/dissocPath.js","webpack:///../node_modules/ramda/src/divide.js","webpack:///../node_modules/ramda/src/drop.js","webpack:///../node_modules/ramda/src/dropLast.js","webpack:///../node_modules/ramda/src/dropLastWhile.js","webpack:///../node_modules/ramda/src/dropRepeats.js","webpack:///../node_modules/ramda/src/dropRepeatsWith.js","webpack:///../node_modules/ramda/src/dropWhile.js","webpack:///../node_modules/ramda/src/either.js","webpack:///../node_modules/ramda/src/empty.js","webpack:///../node_modules/ramda/src/endsWith.js","webpack:///../node_modules/ramda/src/eqBy.js","webpack:///../node_modules/ramda/src/eqProps.js","webpack:///../node_modules/ramda/src/equals.js","webpack:///../node_modules/ramda/src/evolve.js","webpack:///../node_modules/ramda/src/filter.js","webpack:///../node_modules/ramda/src/find.js","webpack:///../node_modules/ramda/src/findIndex.js","webpack:///../node_modules/ramda/src/findLast.js","webpack:///../node_modules/ramda/src/findLastIndex.js","webpack:///../node_modules/ramda/src/flatten.js","webpack:///../node_modules/ramda/src/flip.js","webpack:///../node_modules/ramda/src/forEach.js","webpack:///../node_modules/ramda/src/forEachObjIndexed.js","webpack:///../node_modules/ramda/src/fromPairs.js","webpack:///../node_modules/ramda/src/groupBy.js","webpack:///../node_modules/ramda/src/groupWith.js","webpack:///../node_modules/ramda/src/gt.js","webpack:///../node_modules/ramda/src/gte.js","webpack:///../node_modules/ramda/src/has.js","webpack:///../node_modules/ramda/src/hasIn.js","webpack:///../node_modules/ramda/src/hasPath.js","webpack:///../node_modules/ramda/src/head.js","webpack:///../node_modules/ramda/src/identical.js","webpack:///../node_modules/ramda/src/identity.js","webpack:///../node_modules/ramda/src/ifElse.js","webpack:///../node_modules/ramda/src/inc.js","webpack:///../node_modules/ramda/src/includes.js","webpack:///../node_modules/ramda/src/index.js","webpack:///../node_modules/ramda/src/indexBy.js","webpack:///../node_modules/ramda/src/indexOf.js","webpack:///../node_modules/ramda/src/init.js","webpack:///../node_modules/ramda/src/innerJoin.js","webpack:///../node_modules/ramda/src/insert.js","webpack:///../node_modules/ramda/src/insertAll.js","webpack:///../node_modules/ramda/src/internal/_Set.js","webpack:///../node_modules/ramda/src/internal/_aperture.js","webpack:///../node_modules/ramda/src/internal/_arity.js","webpack:///../node_modules/ramda/src/internal/_arrayFromIterator.js","webpack:///../node_modules/ramda/src/internal/_assertPromise.js","webpack:///../node_modules/ramda/src/internal/_assoc.js","webpack:///../node_modules/ramda/src/internal/_checkForMethod.js","webpack:///../node_modules/ramda/src/internal/_clone.js","webpack:///../node_modules/ramda/src/internal/_cloneRegExp.js","webpack:///../node_modules/ramda/src/internal/_complement.js","webpack:///../node_modules/ramda/src/internal/_concat.js","webpack:///../node_modules/ramda/src/internal/_createPartialApplicator.js","webpack:///../node_modules/ramda/src/internal/_curry1.js","webpack:///../node_modules/ramda/src/internal/_curry2.js","webpack:///../node_modules/ramda/src/internal/_curry3.js","webpack:///../node_modules/ramda/src/internal/_curryN.js","webpack:///../node_modules/ramda/src/internal/_dispatchable.js","webpack:///../node_modules/ramda/src/internal/_dissoc.js","webpack:///../node_modules/ramda/src/internal/_dropLast.js","webpack:///../node_modules/ramda/src/internal/_dropLastWhile.js","webpack:///../node_modules/ramda/src/internal/_equals.js","webpack:///../node_modules/ramda/src/internal/_filter.js","webpack:///../node_modules/ramda/src/internal/_flatCat.js","webpack:///../node_modules/ramda/src/internal/_forceReduced.js","webpack:///../node_modules/ramda/src/internal/_functionName.js","webpack:///../node_modules/ramda/src/internal/_has.js","webpack:///../node_modules/ramda/src/internal/_identity.js","webpack:///../node_modules/ramda/src/internal/_includes.js","webpack:///../node_modules/ramda/src/internal/_includesWith.js","webpack:///../node_modules/ramda/src/internal/_indexOf.js","webpack:///../node_modules/ramda/src/internal/_isArguments.js","webpack:///../node_modules/ramda/src/internal/_isArray.js","webpack:///../node_modules/ramda/src/internal/_isArrayLike.js","webpack:///../node_modules/ramda/src/internal/_isFunction.js","webpack:///../node_modules/ramda/src/internal/_isInteger.js","webpack:///../node_modules/ramda/src/internal/_isNumber.js","webpack:///../node_modules/ramda/src/internal/_isObject.js","webpack:///../node_modules/ramda/src/internal/_isPlaceholder.js","webpack:///../node_modules/ramda/src/internal/_isRegExp.js","webpack:///../node_modules/ramda/src/internal/_isString.js","webpack:///../node_modules/ramda/src/internal/_isTransformer.js","webpack:///../node_modules/ramda/src/internal/_isTypedArray.js","webpack:///../node_modules/ramda/src/internal/_makeFlat.js","webpack:///../node_modules/ramda/src/internal/_map.js","webpack:///../node_modules/ramda/src/internal/_modify.js","webpack:///../node_modules/ramda/src/internal/_objectAssign.js","webpack:///../node_modules/ramda/src/internal/_objectIs.js","webpack:///../node_modules/ramda/src/internal/_of.js","webpack:///../node_modules/ramda/src/internal/_pipe.js","webpack:///../node_modules/ramda/src/internal/_promap.js","webpack:///../node_modules/ramda/src/internal/_quote.js","webpack:///../node_modules/ramda/src/internal/_reduce.js","webpack:///../node_modules/ramda/src/internal/_reduced.js","webpack:///../node_modules/ramda/src/internal/_stepCat.js","webpack:///../node_modules/ramda/src/internal/_toISOString.js","webpack:///../node_modules/ramda/src/internal/_toString.js","webpack:///../node_modules/ramda/src/internal/_xall.js","webpack:///../node_modules/ramda/src/internal/_xany.js","webpack:///../node_modules/ramda/src/internal/_xaperture.js","webpack:///../node_modules/ramda/src/internal/_xchain.js","webpack:///../node_modules/ramda/src/internal/_xdrop.js","webpack:///../node_modules/ramda/src/internal/_xdropLast.js","webpack:///../node_modules/ramda/src/internal/_xdropLastWhile.js","webpack:///../node_modules/ramda/src/internal/_xdropRepeatsWith.js","webpack:///../node_modules/ramda/src/internal/_xdropWhile.js","webpack:///../node_modules/ramda/src/internal/_xfBase.js","webpack:///../node_modules/ramda/src/internal/_xfilter.js","webpack:///../node_modules/ramda/src/internal/_xfind.js","webpack:///../node_modules/ramda/src/internal/_xfindIndex.js","webpack:///../node_modules/ramda/src/internal/_xfindLast.js","webpack:///../node_modules/ramda/src/internal/_xfindLastIndex.js","webpack:///../node_modules/ramda/src/internal/_xmap.js","webpack:///../node_modules/ramda/src/internal/_xpromap.js","webpack:///../node_modules/ramda/src/internal/_xreduceBy.js","webpack:///../node_modules/ramda/src/internal/_xtake.js","webpack:///../node_modules/ramda/src/internal/_xtakeWhile.js","webpack:///../node_modules/ramda/src/internal/_xtap.js","webpack:///../node_modules/ramda/src/internal/_xuniqBy.js","webpack:///../node_modules/ramda/src/internal/_xuniqWith.js","webpack:///../node_modules/ramda/src/internal/_xwrap.js","webpack:///../node_modules/ramda/src/intersection.js","webpack:///../node_modules/ramda/src/intersperse.js","webpack:///../node_modules/ramda/src/into.js","webpack:///../node_modules/ramda/src/invert.js","webpack:///../node_modules/ramda/src/invertObj.js","webpack:///../node_modules/ramda/src/invoker.js","webpack:///../node_modules/ramda/src/is.js","webpack:///../node_modules/ramda/src/isEmpty.js","webpack:///../node_modules/ramda/src/isNil.js","webpack:///../node_modules/ramda/src/join.js","webpack:///../node_modules/ramda/src/juxt.js","webpack:///../node_modules/ramda/src/keys.js","webpack:///../node_modules/ramda/src/keysIn.js","webpack:///../node_modules/ramda/src/last.js","webpack:///../node_modules/ramda/src/lastIndexOf.js","webpack:///../node_modules/ramda/src/length.js","webpack:///../node_modules/ramda/src/lens.js","webpack:///../node_modules/ramda/src/lensIndex.js","webpack:///../node_modules/ramda/src/lensPath.js","webpack:///../node_modules/ramda/src/lensProp.js","webpack:///../node_modules/ramda/src/lift.js","webpack:///../node_modules/ramda/src/liftN.js","webpack:///../node_modules/ramda/src/lt.js","webpack:///../node_modules/ramda/src/lte.js","webpack:///../node_modules/ramda/src/map.js","webpack:///../node_modules/ramda/src/mapAccum.js","webpack:///../node_modules/ramda/src/mapAccumRight.js","webpack:///../node_modules/ramda/src/mapObjIndexed.js","webpack:///../node_modules/ramda/src/match.js","webpack:///../node_modules/ramda/src/mathMod.js","webpack:///../node_modules/ramda/src/max.js","webpack:///../node_modules/ramda/src/maxBy.js","webpack:///../node_modules/ramda/src/mean.js","webpack:///../node_modules/ramda/src/median.js","webpack:///../node_modules/ramda/src/memoizeWith.js","webpack:///../node_modules/ramda/src/mergeAll.js","webpack:///../node_modules/ramda/src/mergeDeepLeft.js","webpack:///../node_modules/ramda/src/mergeDeepRight.js","webpack:///../node_modules/ramda/src/mergeDeepWith.js","webpack:///../node_modules/ramda/src/mergeDeepWithKey.js","webpack:///../node_modules/ramda/src/mergeLeft.js","webpack:///../node_modules/ramda/src/mergeRight.js","webpack:///../node_modules/ramda/src/mergeWith.js","webpack:///../node_modules/ramda/src/mergeWithKey.js","webpack:///../node_modules/ramda/src/min.js","webpack:///../node_modules/ramda/src/minBy.js","webpack:///../node_modules/ramda/src/modify.js","webpack:///../node_modules/ramda/src/modifyPath.js","webpack:///../node_modules/ramda/src/modulo.js","webpack:///../node_modules/ramda/src/move.js","webpack:///../node_modules/ramda/src/multiply.js","webpack:///../node_modules/ramda/src/nAry.js","webpack:///../node_modules/ramda/src/negate.js","webpack:///../node_modules/ramda/src/none.js","webpack:///../node_modules/ramda/src/not.js","webpack:///../node_modules/ramda/src/nth.js","webpack:///../node_modules/ramda/src/nthArg.js","webpack:///../node_modules/ramda/src/o.js","webpack:///../node_modules/ramda/src/objOf.js","webpack:///../node_modules/ramda/src/of.js","webpack:///../node_modules/ramda/src/omit.js","webpack:///../node_modules/ramda/src/on.js","webpack:///../node_modules/ramda/src/once.js","webpack:///../node_modules/ramda/src/or.js","webpack:///../node_modules/ramda/src/otherwise.js","webpack:///../node_modules/ramda/src/over.js","webpack:///../node_modules/ramda/src/pair.js","webpack:///../node_modules/ramda/src/partial.js","webpack:///../node_modules/ramda/src/partialObject.js","webpack:///../node_modules/ramda/src/partialRight.js","webpack:///../node_modules/ramda/src/partition.js","webpack:///../node_modules/ramda/src/path.js","webpack:///../node_modules/ramda/src/pathEq.js","webpack:///../node_modules/ramda/src/pathOr.js","webpack:///../node_modules/ramda/src/pathSatisfies.js","webpack:///../node_modules/ramda/src/paths.js","webpack:///../node_modules/ramda/src/pick.js","webpack:///../node_modules/ramda/src/pickAll.js","webpack:///../node_modules/ramda/src/pickBy.js","webpack:///../node_modules/ramda/src/pipe.js","webpack:///../node_modules/ramda/src/pipeWith.js","webpack:///../node_modules/ramda/src/pluck.js","webpack:///../node_modules/ramda/src/prepend.js","webpack:///../node_modules/ramda/src/product.js","webpack:///../node_modules/ramda/src/project.js","webpack:///../node_modules/ramda/src/promap.js","webpack:///../node_modules/ramda/src/prop.js","webpack:///../node_modules/ramda/src/propEq.js","webpack:///../node_modules/ramda/src/propIs.js","webpack:///../node_modules/ramda/src/propOr.js","webpack:///../node_modules/ramda/src/propSatisfies.js","webpack:///../node_modules/ramda/src/props.js","webpack:///../node_modules/ramda/src/range.js","webpack:///../node_modules/ramda/src/reduce.js","webpack:///../node_modules/ramda/src/reduceBy.js","webpack:///../node_modules/ramda/src/reduceRight.js","webpack:///../node_modules/ramda/src/reduceWhile.js","webpack:///../node_modules/ramda/src/reduced.js","webpack:///../node_modules/ramda/src/reject.js","webpack:///../node_modules/ramda/src/remove.js","webpack:///../node_modules/ramda/src/repeat.js","webpack:///../node_modules/ramda/src/replace.js","webpack:///../node_modules/ramda/src/reverse.js","webpack:///../node_modules/ramda/src/scan.js","webpack:///../node_modules/ramda/src/sequence.js","webpack:///../node_modules/ramda/src/set.js","webpack:///../node_modules/ramda/src/slice.js","webpack:///../node_modules/ramda/src/sort.js","webpack:///../node_modules/ramda/src/sortBy.js","webpack:///../node_modules/ramda/src/sortWith.js","webpack:///../node_modules/ramda/src/split.js","webpack:///../node_modules/ramda/src/splitAt.js","webpack:///../node_modules/ramda/src/splitEvery.js","webpack:///../node_modules/ramda/src/splitWhen.js","webpack:///../node_modules/ramda/src/splitWhenever.js","webpack:///../node_modules/ramda/src/startsWith.js","webpack:///../node_modules/ramda/src/subtract.js","webpack:///../node_modules/ramda/src/sum.js","webpack:///../node_modules/ramda/src/symmetricDifference.js","webpack:///../node_modules/ramda/src/symmetricDifferenceWith.js","webpack:///../node_modules/ramda/src/tail.js","webpack:///../node_modules/ramda/src/take.js","webpack:///../node_modules/ramda/src/takeLast.js","webpack:///../node_modules/ramda/src/takeLastWhile.js","webpack:///../node_modules/ramda/src/takeWhile.js","webpack:///../node_modules/ramda/src/tap.js","webpack:///../node_modules/ramda/src/test.js","webpack:///../node_modules/ramda/src/thunkify.js","webpack:///../node_modules/ramda/src/times.js","webpack:///../node_modules/ramda/src/toLower.js","webpack:///../node_modules/ramda/src/toPairs.js","webpack:///../node_modules/ramda/src/toPairsIn.js","webpack:///../node_modules/ramda/src/toString.js","webpack:///../node_modules/ramda/src/toUpper.js","webpack:///../node_modules/ramda/src/transduce.js","webpack:///../node_modules/ramda/src/transpose.js","webpack:///../node_modules/ramda/src/traverse.js","webpack:///../node_modules/ramda/src/trim.js","webpack:///../node_modules/ramda/src/tryCatch.js","webpack:///../node_modules/ramda/src/type.js","webpack:///../node_modules/ramda/src/unapply.js","webpack:///../node_modules/ramda/src/unary.js","webpack:///../node_modules/ramda/src/uncurryN.js","webpack:///../node_modules/ramda/src/unfold.js","webpack:///../node_modules/ramda/src/union.js","webpack:///../node_modules/ramda/src/unionWith.js","webpack:///../node_modules/ramda/src/uniq.js","webpack:///../node_modules/ramda/src/uniqBy.js","webpack:///../node_modules/ramda/src/uniqWith.js","webpack:///../node_modules/ramda/src/unless.js","webpack:///../node_modules/ramda/src/unnest.js","webpack:///../node_modules/ramda/src/until.js","webpack:///../node_modules/ramda/src/unwind.js","webpack:///../node_modules/ramda/src/update.js","webpack:///../node_modules/ramda/src/useWith.js","webpack:///../node_modules/ramda/src/values.js","webpack:///../node_modules/ramda/src/valuesIn.js","webpack:///../node_modules/ramda/src/view.js","webpack:///../node_modules/ramda/src/when.js","webpack:///../node_modules/ramda/src/where.js","webpack:///../node_modules/ramda/src/whereAny.js","webpack:///../node_modules/ramda/src/whereEq.js","webpack:///../node_modules/ramda/src/without.js","webpack:///../node_modules/ramda/src/xor.js","webpack:///../node_modules/ramda/src/xprod.js","webpack:///../node_modules/ramda/src/zip.js","webpack:///../node_modules/ramda/src/zipObj.js","webpack:///../node_modules/ramda/src/zipWith.js","webpack:///../node_modules/xss/lib/default.js","webpack:///../node_modules/xss/lib/index.js","webpack:///../node_modules/xss/lib/parser.js","webpack:///../node_modules/xss/lib/util.js","webpack:///../node_modules/xss/lib/xss.js","webpack:///../node_modules/classnames/index.js"],"sourcesContent":["'use strict';\n\n/**\n * gets current timestamp in epoch seconds\n * @returns {Number} times in epoch seconds\n */\nfunction getTimestamp() {\n  return new Date().getTime();\n}\n/**\n * gets current GMT offset\n * @returns {Number} offset is mins\n */\n\n\nfunction getGmtOffset() {\n  return new Date().getTimezoneOffset();\n}\n/**\n * Round off numbers(int/string/float) to int\n * Invalid input returns 0\n *\n * @example\n * getNearestInt(100)  // 100\n * getNearestInt(100.49)  // 100\n * getNearestInt(100.50)  // 101\n * getNearestInt('100.50')  // 101\n * getNearestInt('test')  // 0\n *\n *\n * @param {Number|String} num number or number in string\n * @returns {Number} rounded integer\n */\n\n\nfunction getNearestInt(num) {\n  return Math.round(parseFloat(num)) || 0;\n}\n/**\n * Extend base object with key-vals from other object with optional override.\n *\n * @example\n * extend({}, { a: 1 });                      // { a: 1 }\n * extend({ a: 1 }, { b: 1 });                // { a: 1, b: 1 }\n * extend({ a: 1 }, { a: 2, b: 2 });          // { a: 2, b: 2 }\n * extend({ a: 1 }, { a: 2, b: 2 }, false);   // { a: 1, b: 2 }\n *\n * @param {Object} base Base source object, which will be updated\n * @param {Object} obj Source object\n * @param {Boolean} shouldOverride default is true\n * @returns {Object} Returns updated base object\n */\n\n\nfunction extend(base, obj, shouldOverride) {\n  if (typeof shouldOverride === 'undefined') {\n    shouldOverride = true;\n  }\n\n  base = base || {};\n  obj = obj || {};\n\n  for (var key in obj) {\n    if (typeof obj[key] !== 'undefined' && (shouldOverride || !shouldOverride && typeof base[key] === 'undefined')) {\n      base[key] = obj[key];\n    }\n  }\n\n  return base;\n}\n/**\n * uuid generator. Generates a unique ID\n */\n\n\nfunction uuid() {\n  var cryptoObj = window.crypto || window.msCrypto; // for IE 11\n\n  var random32ByteNumber = function random32ByteNumber() {\n    var randomNumber;\n    var max32ByteNumber = 0x7fffffff;\n\n    try {\n      var rnds32 = new Uint32Array(1);\n      cryptoObj.getRandomValues(rnds32);\n      randomNumber = rnds32[0] & max32ByteNumber;\n    } catch (e) {\n      randomNumber = Math.round(max32ByteNumber * Math.random());\n    }\n\n    return randomNumber.toString(16);\n  };\n\n  return random32ByteNumber() + random32ByteNumber();\n}\n\n/**\n * sets client only cookie key/value pair\n * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies\n *\n * @example\n * setCookie ('key', 'value')\n *\n * @param {String} key cookie key\n * @param {String|Integer} value cookie value\n * @param {Object} options optional cookie options\n */\n\nvar storages = {\n  s: 'sessionStorage',\n  l: 'localStorage'\n};\n/***\n * localStorage: data stored has no expiration time\n * sessionStorage: data stored gets cleared when the page session ends(page is closed)\n **/\n\nfunction getStorage(s) {\n  var store;\n\n  try {\n    store = window[storages[s]];\n  } catch (e) {\n    store = null;\n  }\n\n  return store;\n}\n\nfunction _getItem(store, key) {\n  var value;\n\n  if (store) {\n    value = store.getItem(key);\n  }\n\n  return value;\n}\n\nfunction _setItem(storage, key, item) {\n  if (!storage || !item) {\n    return;\n  }\n\n  try {\n    storage.setItem(key, item);\n  } catch (e) {// Do Nothing\n  }\n}\n/**\n * Fetch an item from the local Store, given its key\n *\n * @param key Key of the item to be fetched\n * @returns {*} Item from the local Store\n */\n\n\nfunction getLocalItem(key) {\n  return _getItem(getStorage('l'), key);\n}\n/**\n * Store an item, given its key to local Store\n *\n * @param key Key used to uniquely identify item in the local Store\n * @param item Item to be stored\n */\n\n\nfunction setLocalItem(key, item) {\n  _setItem(getStorage('l'), key, item);\n}\n/**\n * checks if localStorage is available\n * @return {Boolean}\n */\n\n\nfunction hasLocalStorage() {\n  return !!getStorage('l');\n}\n\nvar visitorIdExpiry = 30 * 60 * 1000;\nvar fptiExpiry = 3 * 365 * 24 * 60 * 60 * 1000;\nvar fpti3pKey = 'fpti_3p';\n/**\n * Get/Create 3rd party FPTI Ids. Uses Local Storage for persistence.\n * Addresses some concerns of identity with ITP 2.2\n * @see used by {@link recordImpression}\n */\n\nfunction get3pStorage() {\n  var fpti_3p = null;\n\n  if (!hasLocalStorage()) {\n    return;\n  }\n\n  try {\n    fpti_3p = getLocalItem(fpti3pKey);\n    var vid = null;\n    var vid_exp = null;\n    var fpti = null;\n    var fpti_exp = null;\n    var now = Date.now();\n\n    if (fpti_3p) {\n      // We have data in LS, we need to update the expiry & generate new Ids if expired\n      fpti_3p = JSON.parse(fpti_3p); // check if visitor Id has expired\n\n      if (fpti_3p.vid && fpti_3p.vid_exp > now) {\n        vid = fpti_3p.vid;\n      } else {\n        vid = uuid();\n      } // check if fpti Id has expired\n\n\n      if (fpti_3p.fpti && fpti_3p.fpti_exp > now) {\n        fpti = fpti_3p.fpti;\n      } else {\n        fpti = uuid();\n      } // Updating expiries\n\n\n      vid_exp = now + visitorIdExpiry;\n      fpti_exp = now + fptiExpiry;\n    } else {\n      // We dont have data in LS, we need to generate Ids & place them in LS\n      vid = uuid();\n      vid_exp = now + visitorIdExpiry;\n      fpti = uuid();\n      fpti_exp = now + fptiExpiry;\n    } // Set updated data back to LS\n\n\n    fpti_3p = {\n      vid: vid,\n      vid_exp: vid_exp,\n      fpti: fpti,\n      fpti_exp: fpti_exp\n    };\n    setLocalItem(fpti3pKey, JSON.stringify(fpti_3p));\n  } catch (e) {// Do nothing\n  }\n\n  return fpti_3p;\n}\n\n/**\n * adds a new data to the query string of a url\n *\n * @example\n * appendDataToURL('https://www.example.com', {x: 'y'});      // https://www.example.com?x=y\n * appendDataToURL('https://www.example.com?a=b', {x: 'y'});  // https://www.example.com?a=b&x=y\n *\n * @param {String} url\n * @param {Object} data JSON Object\n * @returns {String} Updated url\n */\n\nfunction appendDataToURL(url, data) {\n  for (var key in data) {\n    if (key && typeof data[key] !== 'undefined' && data[key] !== '') {\n      url = appendQueryStringData(url, key, data[key]);\n    }\n  }\n\n  return url;\n}\n/**\n * adds a new piece of data to the query string of a url\n *\n * @example\n * appendQueryStringData('https://www.example.com', 'x', 'y');      // https://www.example.com?x=y\n * appendQueryStringData('https://www.example.com?a=b', 'x', 'y');  // https://www.example.com?a=b&x=y\n *\n * @param {String} url\n * @param {String} key\n * @param {String|Number} value\n * @returns {String} Updated url\n */\n\n\nfunction appendQueryStringData(url, key, value) {\n  if (key && (value || value === 0 || value === false)) {\n    if (typeof value === 'object') {\n      try {\n        value = JSON.stringify(value);\n      } catch (e) {\n        value = '_err_'; // Log error value to track\n      }\n    }\n\n    if (url.indexOf('?') === -1) {\n      url += '?';\n    }\n\n    if (url.charAt(url.length - 1) !== '?') {\n      url += '&';\n    }\n\n    url += key + '=' + encodeURIComponent(value);\n  }\n\n  return url;\n}\n/**\n * gets browser dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\n\nfunction getBrowserDimensions() {\n  var elem = window;\n  var a = 'inner';\n\n  if (!('innerWidth' in window)) {\n    a = 'client';\n    elem = document.documentElement || document.body;\n  }\n\n  return {\n    width: elem[a + 'Width'],\n    height: elem[a + 'Height']\n  };\n}\n/**\n * gets device dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\n\nfunction getDeviceDimensions() {\n  var screen = window.screen || {};\n  var ratio = window.devicePixelRatio || 1;\n  var w = getNearestInt(screen.width * ratio);\n  var h = getNearestInt(screen.height * ratio);\n\n  if (Math.abs(window.orientation) === 90) {\n    // landscape mode w/h are exchanged\n    var temp = w;\n    w = h;\n    h = temp;\n  }\n\n  return {\n    width: w,\n    height: h\n  };\n}\n/**\n * gets screen dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\n\nfunction getScreenDimensions() {\n  var screen = window.screen || {};\n  return {\n    width: screen.width,\n    height: screen.height\n  };\n}\n/**\n * gets screen color depth\n * @returns {Number}\n */\n\n\nfunction getScreenColorDepth() {\n  return window.screen.colorDepth;\n} // gets boolean for cookies enabled\n\n\nfunction isCookiesEnabled() {\n  var enabled = navigator.cookieEnabled ? 1 : 0;\n  return enabled;\n}\n/**\n * Creates an image pixel\n * @param {String} src\n */\n\n\nfunction fireImagePixel(src) {\n  if (!src || !(typeof window !== 'undefined' && window.Image)) {\n    return;\n  }\n\n  var t = new window.Image(0, 0);\n  t.src = src;\n\n  if (shouldUpdateReferrerPolicy()) {\n    t.referrerPolicy = 'no-referrer-when-downgrade';\n  }\n}\n\nfunction shouldUpdateReferrerPolicy() {\n  var navigator = window.navigator;\n  var ua = navigator.userAgent;\n  var isIE = /MSIE|Trident/i.test(ua);\n  var isIOSSafari = (/iPad/i.test(ua) || /iPhone/i.test(ua)) && /WebKit/i.test(ua) && /CriOS/i.test(ua);\n\n  if (isIE || isIOSSafari) {\n    return false;\n  }\n\n  return true;\n}\n\nvar HOST_PP = 'paypal.com';\nvar VERSION = '1.0.0';\nvar FPTI_BASE_URL = 'https://t.paypal.com/ts';\nvar impressionKeys = {\n  cookiesEnabled: 'ce',\n  pageTitle: 'pt',\n  referrer: 'ru',\n  screenColorDepth: 'cd',\n  screenWidth: 'sw',\n  screenHeight: 'sh',\n  deviceWidth: 'dw',\n  deviceHeight: 'dh',\n  browserWidth: 'bw',\n  browserHeight: 'bh'\n};\n/**\n * Normalize the 2 flavors of options to record API\n * option: { data: {} } and data: {}\n * to option: { data: {} }\n * @param {*} dataObject\n */\n\nfunction normalizeData(dataObject) {\n  var opts;\n\n  if (dataObject && dataObject.data) {\n    opts = dataObject;\n  } else {\n    opts = {\n      data: dataObject || {}\n    };\n  }\n\n  return opts;\n} // generates a beacon url given request options\n\n\nfunction generateBeaconUrl(options, data) {\n  var url = options.url || typeof window !== 'undefined' && window.fptiserverurl || FPTI_BASE_URL;\n  var parts = url.split('?');\n  url = parts[0]; // remove existing query string\n  // if url begins with '//' then we automatically add the current protocol\n\n  if (url.match(/^\\/\\//)) {\n    url = (typeof location !== 'undefined' && location.protocol || '') + url;\n  } // add query string delimiter\n\n\n  url += '?'; // re-append existing query string\n\n  if (parts[1]) {\n    url += parts[1] + '&';\n  }\n\n  url += 'v=' + encodeURIComponent(options.version || VERSION); // version\n\n  var basePayLoad = {\n    t: getTimestamp(),\n    // timestamp\n    g: getGmtOffset() // gmt offset\n\n  }; // if starts time exists provide delta\n\n  if (data.start) {\n    var end = data.end || basePayLoad.t;\n    data.view = data.view || {};\n    data.view.t11 = end - data.start;\n    data.start = data.end = undefined;\n  }\n\n  url = appendDataToURL(url, basePayLoad);\n  url = appendDataToURL(url, data);\n  return url;\n}\n\nfunction createTrackingPayload(options, data) {\n  var beaconURL;\n  var onBeaconCreate = options.onBeaconCreate;\n\n  var _tenantName = window.fpti && window.fpti.tenant_name || HOST_PP; // Use 3p_ variables from local storage only when it is 3rd party\n\n\n  if (typeof window.location !== 'undefined' && window.location.hostname.indexOf('.' + _tenantName) === -1) {\n    var fpti3pIds = get3pStorage();\n\n    if (fpti3pIds) {\n      extend(data, {\n        '3p_vid': fpti3pIds.vid,\n        '3p_fpti': fpti3pIds.fpti\n      });\n    }\n  }\n\n  if (!onBeaconCreate || typeof onBeaconCreate === 'function' && onBeaconCreate() !== false) {\n    // beacon.src throw an exception you access it in IE if url is bigger than 4k\n    beaconURL = generateBeaconUrl(options, data);\n  }\n\n  fireImagePixel(beaconURL);\n  return beaconURL;\n}\n/**\n * Record any payload as FPTI event\n *\n * @example\n * record({page: 'test', pgrp: 'test', e: 'im'});\n * record({ data: {page: 'test', pgrp: 'test', e: 'im'}, url: '//t.paypal.com/ts' });\n *\n * @param {Object} inputData\n * @returns {Object} {data: {...}, url: '<beacon_URL>'}\n */\n\n\nfunction record(inputData) {\n  var options = normalizeData(inputData);\n  var beaconUrl = createTrackingPayload(options, options.data);\n  return {\n    data: options.data,\n    url: beaconUrl\n  };\n}\n/**\n * Record a FPTI impression.\n * Adds default browser aware impression key/values automatically like referrer, page title, browser width-height...\n *\n * @example\n * recordImpression({page: 'test', pgrp: 'test'});\n *\n * @param {Object} inputData\n * @param {Function} preRecordCallback\n */\n\n\nfunction recordImpression(inputData, preRecordCallback) {\n  var options = normalizeData(inputData);\n  var data = options.data; // page title\n\n  data[impressionKeys.pageTitle] = document.title; // referrer url\n\n  data[impressionKeys.referrer] = document.referrer; // screen color depth\n\n  data[impressionKeys.screenColorDepth] = getScreenColorDepth(); // screen dimensions\n\n  var screenDimensions = getScreenDimensions();\n  data[impressionKeys.screenWidth] = screenDimensions.width;\n  data[impressionKeys.screenHeight] = screenDimensions.height; // device dimensions\n\n  var deviceDimensions = getDeviceDimensions();\n  data[impressionKeys.deviceWidth] = deviceDimensions.width;\n  data[impressionKeys.deviceHeight] = deviceDimensions.height; // browser dimensions\n\n  var browserDimensions = getBrowserDimensions();\n  data[impressionKeys.browserWidth] = browserDimensions.width;\n  data[impressionKeys.browserHeight] = browserDimensions.height; // cookies enabled\n\n  data[impressionKeys.cookiesEnabled] = isCookiesEnabled();\n  var res = {\n    data: options.data,\n    url: ''\n  };\n\n  if (typeof preRecordCallback === 'function') {\n    preRecordCallback(function () {\n      res.url = createTrackingPayload(options, data);\n      return res;\n    });\n  } else {\n    res.url = createTrackingPayload(options, data);\n  }\n\n  return res;\n}\n/**\n * Record any payload as FPTI event in React-native.\n * Instead of Image pixel using fetch (AJAX) call.\n *\n * @example\n * recordWithFetch({page: 'test', pgrp: 'test', e: 'im'});\n * recordWithFetch({ data: {page: 'test', pgrp: 'test', e: 'im'}, url: 'https://t.paypal.com/ts' });\n *\n * @param {Object} inputData\n * @returns {Object} {data: {...}, url: '<beacon_URL>'}\n */\n\n\nfunction recordWithFetch(inputData) {\n  var result = record(inputData);\n\n  if (typeof fetch !== 'undefined') {\n    fetch(result.url);\n  }\n\n  return result;\n}\n\nexports.createTrackingPayload = createTrackingPayload;\nexports.generateBeaconUrl = generateBeaconUrl;\nexports.normalizeData = normalizeData;\nexports.record = record;\nexports.recordImpression = recordImpression;\nexports.recordWithFetch = recordWithFetch;\n","\"use strict\";\nexports.__esModule = true;\nexports.MessagingLogger = void 0;\nvar beaver_logger_1 = require(\"beaver-logger\");\nvar ramda_1 = require(\"ramda\");\nvar global_data_1 = require(\"./utils/global-data\");\nvar fpti_1 = require(\"@paypalcorp/fpti\");\n/**\n * Default logger implementation.\n */\nvar MessagingLogger = /** @class */ (function () {\n    function MessagingLogger() {\n        this.getPayloadString = function (payload) {\n            if (!payload) {\n                return '';\n            }\n            return typeof payload !== 'string' ? JSON.stringify(payload) : payload;\n        };\n        // eslint-disable-next-line new-cap\n        this.logger = (0, beaver_logger_1.Logger)({\n            url: '/messaging/api/log',\n            prefix: 'MSG:CLI:',\n            flushInterval: 10 * 1000,\n            logLevel: 'info'\n        });\n        this.logger.addMetaBuilder(function () {\n            return {\n                current_page: window.location.href || ''\n            };\n        });\n    }\n    /**\n     * Logs an informational event to the PayPal logging system.\n     * @param event the event to be logged.\n     * @param payload the payload data to be logged with the event.\n     */\n    MessagingLogger.prototype.logInfo = function (event, payload) {\n        this.logger.info(event, { payload: this.getPayloadString(payload) });\n    };\n    /**\n       * Logs an error event to the PayPal logging system\n       * @param event the error event to be logged.\n       * @param payload the error payload to be logged.\n       */\n    MessagingLogger.prototype.logError = function (event, payload) {\n        this.logger.error(event, { errorPayload: this.getPayloadString(payload) });\n    };\n    /**\n       * Adds analytics instrumentation to the paypay analytics\n       * @param payload the payload to be logged\n       */\n    MessagingLogger.prototype.logFPTIEvent = function (eventName, eventType, payload) {\n        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {\n            window.fptiserverurl = 'https://www.msmaster.qa.paypal.com/webapps/tracking/ts';\n        }\n        var gData = (0, global_data_1.globalData)();\n        var fptiPayload = payload || {};\n        var fptiValue = (0, ramda_1.mergeDeepRight)(window.fpti, fptiPayload);\n        fptiValue.e = eventType ? eventType : 'ac';\n        fptiValue.event_name = eventName;\n        fptiValue.product = 'messagingsdk';\n        fptiValue.platform = 'Web';\n        fptiValue.comp = gData.experience === 'inbox' ? 'msghub-web-data' : 'msg-web-data';\n        fptiValue.experience = gData.experience;\n        fptiValue.tenant = gData.tenant;\n        (0, fpti_1.record)({ data: fptiValue });\n    };\n    return MessagingLogger;\n}());\nexports.MessagingLogger = MessagingLogger;\n","\"use strict\";\nexports.__esModule = true;\nexports.getCSRFToken = void 0;\nvar apiUtils_1 = require(\"../utils/apiUtils\");\nvar getCSRFToken = function (basePath, locale) {\n    return (0, apiUtils_1.doGet)(\"\".concat(basePath, \"/api/token?locale=\").concat(locale));\n};\nexports.getCSRFToken = getCSRFToken;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nexports.__esModule = true;\nexports.Timer = exports.getPageNamesForInstrumentation = exports.getCSRFToken = exports.doPost = exports.doGet = exports.MessagingLogger = exports.globalData = exports.createMasker = void 0;\nvar globalData = __importStar(require(\"./utils/global-data\"));\nexports.globalData = globalData;\nvar MessagingLogger_1 = require(\"./MessagingLogger\");\nexports.MessagingLogger = MessagingLogger_1.MessagingLogger;\nvar apiUtils_1 = require(\"./utils/apiUtils\");\nexports.doGet = apiUtils_1.doGet;\nexports.doPost = apiUtils_1.doPost;\nvar chatApi_1 = require(\"./api/chatApi\");\nexports.getCSRFToken = chatApi_1.getCSRFToken;\nvar createMasker_1 = __importDefault(require(\"./utils/createMasker\"));\nexports.createMasker = createMasker_1[\"default\"];\nvar utils_1 = require(\"./utils/utils\");\nexports.getPageNamesForInstrumentation = utils_1.getPageNamesForInstrumentation;\nvar TimerUtils_1 = __importDefault(require(\"./utils/TimerUtils\"));\nexports.Timer = TimerUtils_1[\"default\"];\n__exportStar(require(\"./types/index\"), exports);\n","\"use strict\";\nexports.__esModule = true;\n","\"use strict\";\nexports.__esModule = true;\n","\"use strict\";\nexports.__esModule = true;\n","\"use strict\";\nexports.__esModule = true;\n","\"use strict\";\nexports.__esModule = true;\nexports.ConversationType = void 0;\nvar ConversationType;\n(function (ConversationType) {\n    ConversationType[ConversationType[\"CHAT\"] = 0] = \"CHAT\";\n    ConversationType[ConversationType[\"EMAIL\"] = 1] = \"EMAIL\";\n})(ConversationType = exports.ConversationType || (exports.ConversationType = {}));\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nexports.__esModule = true;\n__exportStar(require(\"./SSEClientInstance\"), exports);\n__exportStar(require(\"./conversation\"), exports);\n__exportStar(require(\"./Logger\"), exports);\n__exportStar(require(\"./InboxStringSet\"), exports);\n__exportStar(require(\"./SSETypes\"), exports);\n","\"use strict\";\nexports.__esModule = true;\n/**\n * Simple Timer class which supports starting, stopping and getting the clock duration\n */\nvar Timer = /** @class */ (function () {\n    function Timer() {\n        this.isRunning = false;\n        this.startTime = 0;\n        this.endTime = 0;\n    }\n    /**\n   * Starts the timer\n   * @returns number\n   */\n    Timer.prototype.startTimer = function () {\n        if (this.isRunning)\n            return console.error('Timer is already running');\n        this.isRunning = true;\n        this.startTime = Date.now();\n    };\n    /**\n     *  Stops the timer\n    * @returns number\n    */\n    Timer.prototype.stopTimer = function () {\n        if (!this.isRunning)\n            return console.error('Timer is already stopped');\n        this.isRunning = false;\n        this.endTime = Date.now();\n    };\n    /**\n   * Calculates the duration\n   * @returns number\n   */\n    Timer.prototype.calculateDuration = function () {\n        if (!this.startTime || !this.endTime)\n            return console.error('Timer is yet to be initialized');\n        return this.endTime - this.startTime;\n    };\n    /**\n   * Getter method to get the startTime\n   * @returns number\n   */\n    Timer.prototype.getStartTime = function () {\n        return this.startTime;\n    };\n    /**\n   * Getter method to get the stopTime\n   * @returns number\n   */\n    Timer.prototype.getStopTime = function () {\n        return this.endTime;\n    };\n    /**\n   * Getter method to get the isRunning\n   * @returns boolean\n   */\n    Timer.prototype.getIsRunning = function () {\n        return this.isRunning;\n    };\n    return Timer;\n}());\nexports[\"default\"] = Timer;\n","\"use strict\";\nexports.__esModule = true;\nexports.doPost = exports.doGet = void 0;\nvar global_data_1 = require(\"./global-data\");\nvar doGet = function (path, headers) { return new Promise(function (resolve, reject) {\n    var _a = (0, global_data_1.globalData)(), logger = _a.logger, messagingSessionToken = _a.messagingSessionToken, tenant = _a.tenant;\n    headers = headers || {};\n    if (messagingSessionToken) {\n        headers['paypal-chat-session'] = messagingSessionToken;\n        headers['msg-session-token'] = messagingSessionToken;\n    }\n    headers['tenant-name'] = tenant;\n    var options = {\n        method: 'GET',\n        path: path,\n        headers: headers,\n        credentials: 'include'\n    };\n    fetch(path, options)\n        .then(function (response) {\n        if (response.ok) {\n            logger === null || logger === void 0 ? void 0 : logger.logInfo('success_in_get');\n            var contentType = response.headers.get('content-type');\n            logger === null || logger === void 0 ? void 0 : logger.logInfo('success_in_get');\n            if (!contentType) {\n                return Promise.resolve({});\n            }\n            if (contentType.includes('text/plain')) {\n                return response.text();\n            }\n            else if (contentType.includes('application/json')) {\n                return response.json();\n            }\n            return response.blob();\n        }\n        logger === null || logger === void 0 ? void 0 : logger.logError('error_in_get');\n        var err = {\n            code: response.status,\n            message: response.statusText\n        };\n        return Promise.reject(err);\n    })\n        .then(function (json) { return resolve(json); })[\"catch\"](function (err) {\n        logger === null || logger === void 0 ? void 0 : logger.logError('error_in_get', err);\n        reject(err);\n    });\n}); };\nexports.doGet = doGet;\nvar doPost = function (path, body, headers) { return new Promise(function (resolve, reject) {\n    var _a = (0, global_data_1.globalData)(), logger = _a.logger, csrfToken = _a.csrfToken, messagingSessionToken = _a.messagingSessionToken, tenant = _a.tenant;\n    var requestHeader = headers || {};\n    requestHeader['x-csrf-token'] = csrfToken;\n    requestHeader['content-type'] = 'application/json';\n    if (messagingSessionToken) {\n        requestHeader['paypal-chat-session'] = messagingSessionToken;\n        requestHeader['msg-session-token'] = messagingSessionToken;\n    }\n    requestHeader['tenant-name'] = tenant;\n    var options = {\n        method: 'POST',\n        headers: requestHeader,\n        credentials: 'include',\n        body: body\n    };\n    if (path.includes('file')) {\n        delete options.headers['content-type'];\n    }\n    fetch(path, options)\n        .then(function (response) {\n        switch (response.status) {\n            case 201: {\n                response.json()\n                    .then(function (json) {\n                    json.isCreated = true;\n                    resolve(json);\n                });\n                break;\n            }\n            case 200: {\n                response.json()\n                    .then(function (json) {\n                    resolve(json);\n                });\n                break;\n            }\n            case 204: {\n                var resp = {\n                    code: response.status,\n                    message: 'OK'\n                };\n                resolve(resp);\n                break;\n            }\n            default: {\n                var err = {\n                    code: response.status,\n                    message: response.statusText\n                };\n                reject(err);\n            }\n        }\n    })[\"catch\"](function (err) {\n        logger === null || logger === void 0 ? void 0 : logger.logError('error_in_post', err);\n        reject(err);\n    });\n}); };\nexports.doPost = doPost;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nexports.__esModule = true;\nvar ramda_1 = require(\"ramda\");\nvar xss_1 = __importDefault(require(\"xss\"));\nvar defaultExpresions = [\n    // eslint-disable-next-line max-len\n    { regex: /^4[0-9]{3}[-, ]?[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}$|^3(?:0[0-5]|[68][0-9])[0-9]{11}$|^6(?:011|5[0-9]{2})[0-9]{12}$|^(?:2131|1800|35\\d{3})\\d{11}$/, tokenType: 'CREDIT_CARD_2', country: 'WWW' },\n    { regex: /^;\\d{0,19}=\\d{7}\\w*\\?$/, tokenType: 'MAGNETIC_STRIPE_2', country: 'WWW' },\n    { regex: /^%B\\d{0,19}\\^[\\w\\s/]{2,26}\\^\\d{7}\\w*\\?$/, tokenType: 'MAGNETIC_STRIPE', country: 'WWW' },\n    // eslint-disable-next-line max-len\n    { regex: /^[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}$|^3[47][0-9]{13}$|^5[1-5][0-9]{2}[-, ]?[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}$|^62[0-5][0-9]{13,16}$/, tokenType: 'CREDIT_CARD', country: 'WWW' },\n    { regex: /^[a-zA-Z0-9]{10}$/, tokenType: 'SCHUFA_ID', country: 'DE' },\n    { regex: /^[0-0]{2}\\.?[0-9]{2}\\.?[0-9]{2}-[0-9]{3}\\.?[0-9]{2}$/, tokenType: 'NATIONAL_NUMBER', country: 'BE' },\n    // eslint-disable-next-line max-len\n    { regex: /^([A-Za-z]{6}[0-9lmnpqrstuvLMNPQRSTUV]{2}[abcdehlmprstABCDEHLMPRST]{1}[0-9lmnpqrstuvLMNPQRSTUV]{2}[A-Za-z]{1}[0-9lmnpqrstuvLMNPQRSTUV]{3}[A-Za-z]{1})|([0-9]{11})$/, tokenType: 'CODICE_FISCALE', country: 'IT' },\n    { regex: /^[1-9][0-9]{10}$/, tokenType: 'IDENTIFICATION_NUMBER', country: 'TR' },\n    // eslint-disable-next-line max-len\n    { regex: /^[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}$|^3[47][0-9]{13}$|^5[1-5][0-9]{2}[-, ]?[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}$|^62[0-5][0-9]{13,16}$/, tokenType: 'ACCOUNT_NUMBER', country: 'WWW' },\n    // eslint-disable-next-line max-len\n    { regex: /^4[0-9]{3}[-, ]?[0-9]{4}[-, ]?[0-9]{4}[-, ]?[0-9]{4}$|^3(?:0[0-5]|[68][0-9])[0-9]{11}$|^6(?:011|5[0-9]{2})[0-9]{12}$|^(?:2131|1800|35\\d{3})\\d{11}$/, tokenType: 'ACCOUNT_NUMBER_CC1', country: 'WWW' },\n    // eslint-disable-next-line max-len\n    { regex: /^(?=(.*[a-z]){1,})(?=(.*[\\d]){1,})(?=(.*[\\W]){1,})(?!.*\\s).{7,30}$/, tokenType: 'PASSWORD', country: 'WWW' },\n    { regex: /^6(?:011|5[0-9]{2})[0-9]{12}$/, tokenType: 'ACCOUNT_DISCOVER', country: 'WWW' },\n    { regex: /^[0-8][0-9]{2}[- ]?[0-9]{2}[- ]?[0-9]{4}[ ]{0,20}$/, tokenType: 'SSN', country: 'US' }\n];\nvar countryFilter = function (country) { return function (expression) {\n    if (!country) {\n        return expression.country === 'WWW';\n    }\n    return expression.country.toUpperCase() === country.toUpperCase() || expression.country.toUpperCase() === 'WWW';\n}; };\nvar createMasker = function (country, maskerConfiguration) {\n    var tokenizer = defaultExpresions;\n    var stringMasker = defaultExpresions;\n    if (maskerConfiguration) {\n        tokenizer = maskerConfiguration;\n    }\n    tokenizer = tokenizer.filter(countryFilter(country));\n    stringMasker = stringMasker.filter(countryFilter(country));\n    var getMaskedString = function (words) { return words.reduce(function (message, increased) { return message.concat(' ', increased.masked); }, '').trim(); };\n    var sanitize = function (message) { return (0, xss_1[\"default\"])(message).replace(/ {2}/g, '\\n'); };\n    var fullStringMasker = function (expresions) { return function (fullString) { return (0, ramda_1.reduceWhile)(function (maskedWord) { return maskedWord.masked !== '*'.repeat(maskedWord.original.length); }, function (maskedWord, expression) {\n        if (expression.regex.test(maskedWord.original)) {\n            maskedWord.masked = '*'.repeat(maskedWord.original.length);\n        }\n        return maskedWord;\n    }, { original: fullString, masked: fullString }, expresions); }; };\n    var tokenMasker = function (message) { return getMaskedString(message.trim().replace(/\\t/g, ' ').replace(/\\r?\\n\\r?/g, '  ').split(' ').map(fullStringMasker(tokenizer))); };\n    return function (message) {\n        var maskedMessage = tokenMasker(message);\n        maskedMessage = fullStringMasker(stringMasker)(maskedMessage).masked;\n        return sanitize(maskedMessage);\n    };\n};\nexports[\"default\"] = createMasker;\n","\"use strict\";\nexports.__esModule = true;\nexports.setAnalyticsData = exports.init = exports.globalData = exports.setCurrentParticipant = exports.getSessionToken = exports.setSessionToken = exports.setCsrfToken = void 0;\nvar MessagingLogger_1 = require(\"../MessagingLogger\");\nvar gData = {\n    csrfToken: '',\n    isLoggedIn: true,\n    tenant: 'paypal',\n    experience: 'widget',\n    locale: 'en_US',\n    country: 'US',\n    enableMultiStream: false,\n    analyticsData: {}\n};\nvar setCsrfToken = function (csrfToken) {\n    gData.csrfToken = csrfToken;\n};\nexports.setCsrfToken = setCsrfToken;\nvar setSessionToken = function (sessionToken) {\n    gData.messagingSessionToken = sessionToken;\n};\nexports.setSessionToken = setSessionToken;\nvar getSessionToken = function () { return gData.messagingSessionToken; };\nexports.getSessionToken = getSessionToken;\nvar setCurrentParticipant = function (participantId) {\n    gData.currentParticipantId = participantId;\n};\nexports.setCurrentParticipant = setCurrentParticipant;\nvar globalData = function () { return gData; };\nexports.globalData = globalData;\nvar init = function (data) {\n    gData.isLoggedIn = data.isLoggedIn;\n    gData.tenant = data.tenant;\n    gData.experience = data.experience;\n    gData.csrfToken = data.csrfToken;\n    gData.country = data.country ? data.country : gData.country;\n    gData.locale = data.locale ? data.locale : gData.locale;\n    gData.enableMultiStream = data.enableMultiStream ? data.enableMultiStream : gData.enableMultiStream;\n    gData.messagingSessionToken = data.messagingSessionToken ? data.messagingSessionToken : gData.messagingSessionToken;\n    if (data.logger) {\n        gData.logger = data.logger;\n    }\n    else {\n        //default logger\n        gData.logger = new MessagingLogger_1.MessagingLogger();\n    }\n};\nexports.init = init;\nvar setAnalyticsData = function (analyticsData) {\n    gData.analyticsData = analyticsData;\n};\nexports.setAnalyticsData = setAnalyticsData;\n","\"use strict\";\nexports.__esModule = true;\nexports.getPageNamesForInstrumentation = exports.getBasePath = void 0;\nvar global_data_1 = require(\"./global-data\");\n/**\n *\n * @returns the base path of the APIs based on the experience\n */\nvar getBasePath = function () {\n    var basePath = 'messaging';\n    var gData = (0, global_data_1.globalData)();\n    if (gData.isLoggedIn) {\n        return \"/\".concat(basePath, \"/\").concat(gData.tenant);\n    }\n    return \"/\".concat(basePath, \"/open/\").concat(gData.tenant);\n};\nexports.getBasePath = getBasePath;\nvar getPageNamesForInstrumentation = function () {\n    switch ((0, global_data_1.globalData)().experience) {\n        case 'inbox':\n            return {\n                page: 'main:messaging:data:web::inbox::',\n                pgrp: 'main:messaging:web::'\n            };\n        case 'widget':\n            return {\n                page: 'main:messaging:data:web::',\n                pgrp: 'main:messaging:web::'\n            };\n        default:\n            return {\n                page: 'main:messaging:data:web::',\n                pgrp: 'main:messaging:web::'\n            };\n    }\n};\nexports.getPageNamesForInstrumentation = getPageNamesForInstrumentation;\n","import _taggedTemplateLiteral from '@babel/runtime/helpers/esm/taggedTemplateLiteral';\nimport { css, useTheme, jsx } from '@emotion/react';\nimport { math } from 'polished';\nimport { devWarning, utilStyles, ZINDEX_DROPDOWN, highlightMatch, KeyboardCode, ScreenReaderContent } from '@paypalcorp/pp-react-utils';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';\nimport _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';\nimport React, { useMemo, useState, useRef, useEffect, forwardRef } from 'react';\nimport { TextInput } from '@paypalcorp/pp-react-text-input';\nimport { CaptionText, BodyText } from '@paypalcorp/pp-react-text';\nimport { LoadingSpinner } from '@paypalcorp/pp-react-loading-spinner';\nimport { ContextualAlert } from '@paypalcorp/pp-react-contextual-alert';\n\nvar _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11;\nfunction styles(tokens) {\n  /* istanbul ignore next */\n  if (!Object.keys(tokens).length) {\n    devWarning('Missing Emotion theme. Use ThemeProvider from @emotion/react to pass a valid theme from pp-react.');\n    return {};\n  }\n\n  var sysBorderRadiusLg = tokens.sysBorderRadiusLg,\n      sysBorderThicknessNormal = tokens.sysBorderThicknessNormal,\n      sysColorBackgroundSurface = tokens.sysColorBackgroundSurface,\n      sysColorBackgroundSurfaceHover = tokens.sysColorBackgroundSurfaceHover,\n      sysSizeMediaSm = tokens.sysSizeMediaSm,\n      sysSizeMediaMd = tokens.sysSizeMediaMd,\n      sysSizeMediaLg = tokens.sysSizeMediaLg,\n      sysSpaceLg = tokens.sysSpaceLg,\n      sysSpaceMd = tokens.sysSpaceMd,\n      sysSpaceSm = tokens.sysSpaceSm,\n      sysSizeFieldLg = tokens.sysSizeFieldLg,\n      sysSpaceTiny = tokens.sysSpaceTiny,\n      sysSpaceXs = tokens.sysSpaceXs;\n\n  var _utilStyles = utilStyles(tokens),\n      elevationStyles = _utilStyles.elevationStyles;\n\n  var base = css(_templateObject || (_templateObject = _taggedTemplateLiteral([\"\\n    label: auto-suggest_base;\\n    position: relative;\\n  \"])));\n  var suggestionListContainer = css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral([\"\\n    label: suggestion_list_container;\\n    min-width: \", \";\\n    max-width: \", \";\\n    margin-top: \", \";\\n    padding: \", \" 0;\\n    overflow-x: hidden;\\n    width: 100%;\\n  \"])), math(\"2 * \".concat(sysSizeFieldLg)), sysSizeMediaLg, math(\"\".concat(sysSpaceXs, \" + \").concat(sysSpaceTiny)), sysSpaceSm);\n  var elevatedSuggestionListContainer = css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral([\"\\n    label: elevated_suggestion_list_container;\\n    \", \"\\n    \", \"\\n\\n    border-radius: \", \";\\n    background-color: \", \";\\n    z-index: \", \";\\n    outline: \", \" solid transparent;\\n    top: \", \";\\n    position: absolute;\\n  \"])), suggestionListContainer, elevationStyles.level3, sysBorderRadiusLg, sysColorBackgroundSurface, ZINDEX_DROPDOWN, sysBorderThicknessNormal, sysSizeFieldLg);\n  var content = css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral([\"\\n    label: content;\\n    padding: \", \" \", \";\\n  \"])), sysSpaceMd, sysSpaceLg);\n  var centeredContent = css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral([\"\\n    label: centered_content;\\n    display: flex;\\n    justify-content: center;\\n  \"])));\n  var suggestionSublist = css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral([\"\\n    label: suggestion_sublist;\\n    list-style-type: none;\\n    margin: 0;\\n    padding: 0;\\n  \"])));\n  var suggestionList = css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral([\"\\n    label: suggestion_list;\\n    \", \"\\n    overflow-y: auto;\\n    max-height: \", \";\\n\\n    @media (max-width: \", \") {\\n      max-height: \", \";\\n    }\\n  \"])), suggestionSublist, sysSizeMediaSm, sysSizeMediaMd, math(\"\".concat(sysSizeMediaSm, \" / 2\")));\n  var highlightedSuggesiton = css(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral([\"\\n    label: highlighted_suggestion;\\n    background-color: \", \";\\n  \"])), sysColorBackgroundSurfaceHover);\n  var suggestion = css(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral([\"\\n    label: suggestion;\\n    \", \"\\n    cursor: pointer;\\n    display: flex;\\n    align-items: center;\\n\\n    &:hover {\\n      \", \"\\n    }\\n  \"])), content, highlightedSuggesiton);\n  var errorMessage = css(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral([\"\\n    label: error_message;\\n    margin: 0 \", \";\\n  \"])), sysSpaceLg);\n  var suggestionDecoration = css(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral([\"\\n    label: suggestion_decoration;\\n    margin-right: \", \";\\n\\n    [dir='rtl'] & {\\n      margin-right: 0;\\n      margin-left: \", \";\\n    }\\n  \"])), sysSpaceMd, sysSpaceMd);\n  return {\n    base: base,\n    suggestionListContainer: suggestionListContainer,\n    elevatedSuggestionListContainer: elevatedSuggestionListContainer,\n    content: content,\n    centeredContent: centeredContent,\n    suggestionSublist: suggestionSublist,\n    suggestionList: suggestionList,\n    highlightedSuggesiton: highlightedSuggesiton,\n    suggestion: suggestion,\n    errorMessage: errorMessage,\n    suggestionDecoration: suggestionDecoration\n  };\n}\n\nvar _excluded = [\"suggestions\", \"renderSuggestion\", \"onHighlight\", \"onSelect\", \"className\", \"listItemClassName\", \"query\", \"enableKeyboardInteraction\", \"hasSections\"];\n\nvar defaultRenderSuggestion = function (_ref, query, _styles) {\n  var value = _ref.value,\n      primaryText = _ref.primaryText,\n      secondaryText = _ref.secondaryText,\n      decoration = _ref.decoration;\n  var highlightedValue = highlightMatch(primaryText || value, query);\n  var secondaryElm = secondaryText ? jsx(CaptionText, {\n    \"data-ppui\": \"true\"\n  }, secondaryText) : null;\n  var decorationElm = decoration ? jsx(\"div\", {\n    css: _styles.suggestionDecoration,\n    \"data-ppui\": \"true\"\n  }, decoration) : null;\n  return jsx(React.Fragment, null, decorationElm, jsx(\"div\", {\n    \"data-ppui\": \"true\"\n  }, jsx(BodyText, {\n    dangerouslySetInnerHTML: {\n      __html: highlightedValue\n    },\n    \"data-ppui\": \"true\"\n  }), secondaryElm));\n};\n/* Create a flat list of suggestions for highlight and selection by index */\n\n\nvar normalizeSuggestions = function (suggestions, hasSections) {\n  if (!hasSections) {\n    return suggestions.reduce(function (acc, suggestion, index) {\n      acc.push({\n        value: suggestion,\n        suggestionIndex: index\n      });\n      return acc;\n    }, []);\n  }\n\n  return suggestions.reduce(function (acc, section, sectionIndex) {\n    if (section.suggestions) {\n      section.suggestions.forEach(function (suggestion, suggestionIndex) {\n        acc.push({\n          value: suggestion,\n          section: section,\n          suggestionIndex: suggestionIndex,\n          sectionIndex: sectionIndex\n        });\n      });\n    }\n\n    return acc;\n  }, []);\n};\n\nvar SuggestionList = function (_ref2) {\n  var _ref2$suggestions = _ref2.suggestions,\n      suggestions = _ref2$suggestions === void 0 ? [] : _ref2$suggestions,\n      renderSuggestion = _ref2.renderSuggestion,\n      onHighlight = _ref2.onHighlight,\n      onSelect = _ref2.onSelect,\n      className = _ref2.className,\n      listItemClassName = _ref2.listItemClassName,\n      query = _ref2.query,\n      _ref2$enableKeyboardI = _ref2.enableKeyboardInteraction,\n      enableKeyboardInteraction = _ref2$enableKeyboardI === void 0 ? true : _ref2$enableKeyboardI,\n      hasSections = _ref2.hasSections,\n      rest = _objectWithoutProperties(_ref2, _excluded);\n\n  var tokens = useTheme();\n\n  var _styles = useMemo(function () {\n    return styles(tokens);\n  }, [tokens]);\n\n  var _useState = useState(-1),\n      _useState2 = _slicedToArray(_useState, 2),\n      highlightedIndex = _useState2[0],\n      setHighlightedIndex = _useState2[1];\n\n  var highlightedIndexRef = useRef(-1);\n  var listRef = useRef([]);\n\n  var _suggestions = normalizeSuggestions(suggestions, hasSections);\n\n  var handleHighlight = function (evt, index) {\n    setHighlightedIndex(index);\n    highlightedIndexRef.current = index;\n    /* istanbul ignore next */\n\n    if (index !== -1) {\n      var id = _suggestions[index].section ? \"\".concat(_suggestions[index].section.id, \"_\").concat(_suggestions[index].value.id) : _suggestions[index].value.id;\n      var highlightedElm = listRef.current[id];\n\n      if (highlightedElm && highlightedElm.scrollIntoView) {\n        highlightedElm.scrollIntoView({\n          behavior: 'smooth',\n          block: 'nearest'\n        });\n      }\n    }\n    /* istanbul ignore next */\n\n\n    if (onHighlight) {\n      onHighlight(evt, _suggestions[index].value, _suggestions[index].section);\n    }\n  };\n\n  var handleSelect = function (evt, index) {\n    /* istanbul ignore next */\n    if (onSelect) {\n      onSelect(evt, _suggestions[index].value, _suggestions[index].section);\n    }\n  };\n  /* istanbul ignore next */\n\n\n  var handleKeyDown = function (evt) {\n    if (!_suggestions.length) {\n      return;\n    }\n\n    var currentHighlightedIndex = highlightedIndexRef.current;\n    /* istanbul ignore next */\n\n    var KeyCode = new KeyboardCode(evt.key || evt.keyCode);\n\n    if (KeyCode.IS_ARROW_UP) {\n      evt.preventDefault();\n\n      if (currentHighlightedIndex > 0) {\n        handleHighlight(evt, currentHighlightedIndex - 1);\n      } else if (currentHighlightedIndex === 0) {\n        handleHighlight(evt, _suggestions.length - 1);\n      }\n    } else if (KeyCode.IS_ARROW_DOWN) {\n      evt.preventDefault();\n\n      if (currentHighlightedIndex < _suggestions.length - 1) {\n        handleHighlight(evt, currentHighlightedIndex + 1);\n      } else if (currentHighlightedIndex === _suggestions.length - 1) {\n        handleHighlight(evt, 0);\n      }\n    } else if (KeyCode.IS_ENTER) {\n      evt.preventDefault();\n\n      if (currentHighlightedIndex >= 0) {\n        handleSelect(evt, currentHighlightedIndex);\n      }\n    }\n  };\n\n  useEffect(function () {\n    setHighlightedIndex(-1);\n    highlightedIndexRef.current = -1;\n\n    if (suggestions.length && enableKeyboardInteraction) {\n      document.addEventListener('keydown', handleKeyDown);\n    }\n\n    return function () {\n      document.removeEventListener('keydown', handleKeyDown);\n    };\n  }, [suggestions, enableKeyboardInteraction]);\n\n  var renderSuggestionList = function (items, section) {\n    var normalizedIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n    return items.map(function (suggestion, index) {\n      var cssVal = [_styles.suggestion, highlightedIndex >= 0 && suggestion === _suggestions[highlightedIndex].value && _styles.highlightedSuggesiton];\n      var id = section ? \"\".concat(section.id, \"_\").concat(suggestion.id) : suggestion.id;\n      var suggestionContent = renderSuggestion ? renderSuggestion(suggestion, query, section) : defaultRenderSuggestion(suggestion, query, _styles);\n      return jsx(\"li\", _extends({\n        role: \"option\"\n      }, section ? {\n        'aria-describedby': section.id\n      } : null, {\n        key: id,\n        id: id,\n        ref: function ref(el) {\n          return listRef.current[id] = el;\n        },\n        css: cssVal,\n        className: listItemClassName,\n        onMouseDown: function onMouseDown(evt) {\n          return evt.preventDefault();\n        },\n        onClick: function onClick(evt) {\n          handleSelect(evt, normalizedIndex + index);\n        },\n        \"data-ppui\": \"true\"\n      }), suggestionContent);\n    });\n  };\n\n  var listItems = hasSections ? function renderSections() {\n    var currentNormalizedIndex = 0;\n    return suggestions.reduce(function (acc, section) {\n      if (section.suggestions && section.suggestions.length) {\n        acc.push(jsx(\"li\", {\n          role: \"presentation\",\n          key: section.id,\n          \"data-ppui\": \"true\"\n        }, jsx(\"div\", {\n          css: _styles.content,\n          id: section.id,\n          \"aria-hidden\": \"true\",\n          \"data-ppui\": \"true\"\n        }, jsx(CaptionText, {\n          \"data-ppui\": \"true\"\n        }, section.title)), jsx(\"ul\", {\n          role: \"listbox\",\n          css: _styles.suggestionSublist,\n          \"aria-labelledby\": section.id,\n          \"data-ppui\": \"true\"\n        }, renderSuggestionList(section.suggestions, section, currentNormalizedIndex))));\n        currentNormalizedIndex += section.suggestions.length;\n      }\n\n      return acc;\n    }, []);\n  }() : renderSuggestionList(suggestions);\n\n  if (_suggestions.length) {\n    return jsx(\"ul\", _extends({\n      role: \"listbox\",\n      css: _styles.suggestionList,\n      className: className\n    }, rest, {\n      \"data-ppui\": \"true\"\n    }), listItems);\n  }\n\n  return null;\n};\n\nvar _excluded$1 = [\"id\", \"value\", \"debounceTimeout\", \"fetchSuggestions\", \"suggestionList\", \"isSuggestionListInline\", \"isLoadingSuggestions\", \"onChange\", \"onFocus\", \"onKeyDown\", \"onBlur\", \"onClear\", \"className\", \"triggerComponent\", \"suggestions\", \"defaultSuggestionList\", \"suggestionListFooter\", \"suggestionListContainerClassName\", \"suggestionListFooterClassName\", \"suggestionListChangeMessage\", \"suggestionListLoadingMessage\", \"suggestionListErrorMessage\", \"onSuggestionListClose\"];\nvar DEBOUNCE_TIMEOUT = 500;\n/* Get total number of suggestions */\n\nvar getNormalizedSuggestionLength = function (suggestions, hasSections) {\n  if (!hasSections) {\n    return suggestions.length;\n  }\n\n  return suggestions.reduce(function (acc, section) {\n    if (section.suggestions) {\n      acc += section.suggestions.length;\n    }\n\n    return acc;\n  }, 0);\n};\n/* eslint-disable complexity */\n\n\nvar AutoSuggest = forwardRef(function (props, ref) {\n  var _props$id = props.id,\n      id = _props$id === void 0 ? 'default' : _props$id,\n      value = props.value,\n      _props$debounceTimeou = props.debounceTimeout,\n      debounceTimeout = _props$debounceTimeou === void 0 ? DEBOUNCE_TIMEOUT : _props$debounceTimeou,\n      _props$fetchSuggestio = props.fetchSuggestions,\n      fetchSuggestions = _props$fetchSuggestio === void 0 ? function () {\n    return devWarning('Required prop `fetchSuggestions` is missing');\n  } : _props$fetchSuggestio,\n      _props$suggestionList = props.suggestionList,\n      suggestionList = _props$suggestionList === void 0 ? jsx(SuggestionList, {\n    suggestions: [],\n    \"data-ppui\": \"true\"\n  }) : _props$suggestionList,\n      isSuggestionListInline = props.isSuggestionListInline,\n      isLoadingSuggestions = props.isLoadingSuggestions,\n      onChange = props.onChange,\n      onFocus = props.onFocus,\n      onKeyDown = props.onKeyDown,\n      onBlur = props.onBlur,\n      onClear = props.onClear,\n      className = props.className,\n      _props$triggerCompone = props.triggerComponent,\n      triggerComponent = _props$triggerCompone === void 0 ? TextInput : _props$triggerCompone,\n      _props$suggestions = props.suggestions,\n      _props$defaultSuggest = props.defaultSuggestionList,\n      defaultSuggestionList = _props$defaultSuggest === void 0 ? jsx(SuggestionList, {\n    suggestions: [],\n    \"data-ppui\": \"true\"\n  }) : _props$defaultSuggest,\n      suggestionListFooter = props.suggestionListFooter,\n      suggestionListContainerClassName = props.suggestionListContainerClassName,\n      suggestionListFooterClassName = props.suggestionListFooterClassName,\n      suggestionListChangeMessage = props.suggestionListChangeMessage,\n      _props$suggestionList2 = props.suggestionListLoadingMessage,\n      suggestionListLoadingMessage = _props$suggestionList2 === void 0 ? 'Loading suggestions' : _props$suggestionList2,\n      suggestionListErrorMessage = props.suggestionListErrorMessage,\n      onSuggestionListClose = props.onSuggestionListClose,\n      rest = _objectWithoutProperties(props, _excluded$1);\n\n  var tokens = useTheme();\n\n  var _styles = useMemo(function () {\n    return styles(tokens);\n  }, [tokens]);\n\n  var timerRef = useRef();\n  var internalRef = useRef();\n  var suggestionListContainerRef = useRef();\n\n  var _useState = useState(false),\n      _useState2 = _slicedToArray(_useState, 2),\n      areSuggestionsVisible = _useState2[0],\n      setSuggestionsVisible = _useState2[1];\n\n  var _useState3 = useState(''),\n      _useState4 = _slicedToArray(_useState3, 2),\n      highlightedSuggestionId = _useState4[0],\n      setHighlightedSuggestionId = _useState4[1];\n\n  var _useState5 = useState(false),\n      _useState6 = _slicedToArray(_useState5, 2),\n      isTriggerFocused = _useState6[0],\n      setTriggerFocus = _useState6[1];\n\n  var inputRef = ref || internalRef;\n  var suggestionsLength = getNormalizedSuggestionLength(suggestionList.props.suggestions || [], suggestionList.props.hasSections);\n  /* istanbul ignore next */\n\n  var focusSuggestionLength = getNormalizedSuggestionLength(defaultSuggestionList.props.suggestions || [], defaultSuggestionList.props.hasSections);\n\n  var handleOutsideClick = function (evt) {\n    var inputElm = inputRef.current;\n    var suggestionListContainer = suggestionListContainerRef.current;\n    /* istanbul ignore next */\n\n    if (evt.target === inputElm || suggestionListContainer && suggestionListContainer.contains(evt.target)) {\n      return;\n    }\n    /* istanbul ignore next */\n\n\n    setSuggestionsVisible(false);\n  };\n\n  useEffect(function () {\n    return function () {\n      if (timerRef.current) {\n        clearTimeout(timerRef.current);\n      }\n    };\n  }, []);\n  useEffect(function () {\n    if (areSuggestionsVisible && !isSuggestionListInline) {\n      document.addEventListener('click', handleOutsideClick);\n    }\n\n    return function () {\n      document.removeEventListener('click', handleOutsideClick);\n    };\n  }, [areSuggestionsVisible, isSuggestionListInline]);\n\n  var callSuggestionListClose = function (evt) {\n    if (onSuggestionListClose && suggestionsLength) {\n      onSuggestionListClose(evt);\n    }\n  };\n\n  var handleHighlight = function (evt, suggestion, section) {\n    setHighlightedSuggestionId(section ? \"\".concat(section.id, \"_\").concat(suggestion.id) : suggestion.id);\n    /* istanbul ignore next */\n\n    if (suggestionList.props.onHighlight) {\n      suggestionList.props.onHighlight(evt, suggestion, section);\n    }\n  };\n\n  var handleSelect = function (evt, suggestion, section) {\n    /* istanbul ignore next */\n    if (suggestionList.props.onSelect) {\n      suggestionList.props.onSelect(evt, suggestion, section);\n    }\n\n    if (!isSuggestionListInline) {\n      setSuggestionsVisible(false);\n    }\n  };\n\n  var suggestionListId = \"\".concat(id, \"-suggestionList\");\n  var footer = suggestionListFooter ? jsx(\"div\", {\n    css: _styles.content,\n    className: suggestionListFooterClassName,\n    \"data-ppui\": \"true\"\n  }, suggestionListFooter) : null;\n  var suggestionsElm = !isLoadingSuggestions && suggestionsLength > 0 && jsx(React.Fragment, null, React.cloneElement(suggestionList, {\n    id: suggestionListId,\n    'aria-labelledby': \"\".concat(id, \"-label\"),\n    onHighlight: handleHighlight,\n    onSelect: handleSelect,\n    enableKeyboardInteraction: isTriggerFocused\n  }), footer);\n  var focusSuggestionElm = focusSuggestionLength > 0 && jsx(React.Fragment, null, React.cloneElement(defaultSuggestionList, {\n    id: suggestionListId,\n    'aria-labelledby': \"\".concat(id, \"-label\"),\n    onHighlight: handleHighlight,\n    onSelect: handleSelect,\n    enableKeyboardInteraction: isTriggerFocused\n  }), footer);\n  var loadingElm = isLoadingSuggestions ? jsx(\"div\", {\n    css: _styles.centeredContent,\n    \"data-ppui\": \"true\"\n  }, jsx(LoadingSpinner, {\n    screenReaderText: suggestionListLoadingMessage,\n    size: \"md\",\n    \"data-ppui\": \"true\"\n  })) : null;\n  var errorElm = suggestionListErrorMessage && !suggestionsLength && !isLoadingSuggestions ? jsx(ContextualAlert, {\n    css: _styles.errorMessage,\n    type: \"warning\",\n    \"data-ppui\": \"true\"\n  }, suggestionListErrorMessage) : null;\n  var suggestionListContainerCssVal = isSuggestionListInline ? _styles.suggestionListContainer : _styles.elevatedSuggestionListContainer;\n  var suggestionContainerElm = null;\n\n  if (value && areSuggestionsVisible && (suggestionsElm || loadingElm || errorElm)) {\n    suggestionContainerElm = jsx(\"div\", {\n      css: suggestionListContainerCssVal,\n      className: suggestionListContainerClassName,\n      ref: suggestionListContainerRef,\n      \"data-ppui\": \"true\"\n    }, suggestionsElm, loadingElm, errorElm);\n  } else if (!value && areSuggestionsVisible && focusSuggestionLength > 0) {\n    suggestionContainerElm = jsx(\"div\", {\n      css: suggestionListContainerCssVal,\n      className: suggestionListContainerClassName,\n      ref: suggestionListContainerRef,\n      \"data-ppui\": \"true\"\n    }, focusSuggestionElm);\n  }\n\n  var _suggestListChangeMessage = suggestionListChangeMessage || \"\".concat(suggestionsLength, \" suggestions available\");\n\n  var otherProps = triggerComponent !== TextInput ? {\n    onClear: function handleClear(evt) {\n      callSuggestionListClose(evt);\n\n      if (onClear) {\n        onClear(evt);\n      }\n    }\n  } : {};\n  return jsx(\"div\", {\n    css: _styles.base,\n    className: className,\n    \"data-ppui-info\": \"auto-suggest_2.0.2-ql\"\n  }, jsx(triggerComponent, _extends({}, rest, {\n    id: id,\n    value: value,\n    ref: inputRef,\n    onChange: function handleChange(evt) {\n      var newValue = evt.target.value;\n\n      if (timerRef.current) {\n        clearTimeout(timerRef.current);\n      }\n      /* istanbul ignore next */\n\n\n      timerRef.current = setTimeout(function () {\n        fetchSuggestions(newValue);\n      }, debounceTimeout);\n      setSuggestionsVisible(true);\n      onChange(evt);\n    },\n    onFocus: function handleFocus(evt) {\n      if (suggestionsLength || focusSuggestionLength) {\n        setSuggestionsVisible(true);\n      }\n\n      fetchSuggestions(value);\n      setTriggerFocus(true);\n      /* istanbul ignore next */\n\n      if (onFocus) {\n        onFocus(evt);\n      }\n    },\n    onKeyDown: function handleKey(evt) {\n      /* istanbul ignore next */\n      var KeyCode = new KeyboardCode(evt.key || evt.keyCode);\n\n      if (KeyCode.IS_ESC || KeyCode.IS_TAB) {\n        if (!isSuggestionListInline) {\n          setSuggestionsVisible(false);\n        }\n        /* istanbul ignore next */\n\n\n        if (KeyCode.IS_ESC && onClear) {\n          onClear(evt);\n        }\n      }\n      /* istanbul ignore next */\n\n\n      if (onKeyDown) {\n        onKeyDown(evt);\n      }\n    },\n    onBlur: function handleBlur(evt) {\n      // onSuggestionListClose callback\n      // this callback is triggered ONLY when suggestionList is visible\n      callSuggestionListClose(evt);\n      setTriggerFocus(false);\n      setSuggestionsVisible(false);\n      /* istanbul ignore next */\n\n      if (onBlur) {\n        onBlur(evt);\n      }\n    },\n    \"aria-activedescendant\": highlightedSuggestionId,\n    \"aria-autocomplete\": \"list\",\n    role: \"combobox\",\n    \"aria-expanded\": suggestionsLength > 0 && areSuggestionsVisible,\n    \"aria-owns\": suggestionListId,\n    \"aria-haspopup\": \"listbox\"\n  }, otherProps, {\n    \"data-ppui\": \"true\"\n  })), suggestionContainerElm, jsx(ScreenReaderContent, {\n    role: \"status\",\n    \"data-ppui\": \"true\"\n  }, _suggestListChangeMessage));\n});\n\nexport { AutoSuggest, SuggestionList, styles as autoSuggestStyles };\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';\nimport { useMemo } from 'react';\nimport { InformationIcon, CheckmarkBackgroundIcon, WarningIcon, CriticalIcon } from '@paypalcorp/pp-react-icons';\nimport { css, useTheme, jsx } from '@emotion/react';\nimport _taggedTemplateLiteral from '@babel/runtime/helpers/esm/taggedTemplateLiteral';\nimport { textStyles } from '@paypalcorp/pp-react-text';\nimport { devWarning } from '@paypalcorp/pp-react-utils';\n\nvar _templateObject, _templateObject2, _templateObject3;\nfunction styles(tokens) {\n  /* istanbul ignore next */\n  if (!Object.keys(tokens).length) {\n    devWarning('Missing Emotion theme. Use ThemeProvider from @emotion/react to pass a valid theme from pp-react.');\n    return {};\n  }\n\n  var sysSpaceSm = tokens.sysSpaceSm,\n      sysSpaceLg = tokens.sysSpaceLg,\n      sysSizeIconXs = tokens.sysSizeIconXs;\n\n  var _textStyles = textStyles(tokens),\n      textCaption = _textStyles.caption;\n\n  var base = css(_templateObject || (_templateObject = _taggedTemplateLiteral([\"\\n    label: contextual-alert_base;\\n    display: flex;\\n    padding: \", \" 0;\\n    \", \"\\n  \"])), sysSpaceLg, textCaption());\n  var statusIcon = css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral([\"\\n    label: status_icon;\\n    margin-top: \", \";\\n    margin-right: \", \";\\n    height: \", \";\\n\\n    [dir='rtl'] & {\\n      margin-left: \", \";\\n      margin-right: 0;\\n    }\\n  \"])), '0.0625rem', sysSpaceSm, sysSizeIconXs, sysSpaceSm);\n  var noPadding = css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral([\"\\n    label: no_padding;\\n    padding: 0;\\n  \"])));\n  return {\n    base: base,\n    statusIcon: statusIcon,\n    noPadding: noPadding\n  };\n}\n\nvar _excluded = [\"className\", \"type\", \"typeIconAriaLabel\", \"children\", \"noPadding\"];\nvar iconMap = {\n  info: InformationIcon,\n  success: CheckmarkBackgroundIcon,\n  warning: WarningIcon,\n  error: CriticalIcon\n};\n\nvar ContextualAlert = function (_ref) {\n  var className = _ref.className,\n      _ref$type = _ref.type,\n      type = _ref$type === void 0 ? 'info' : _ref$type,\n      _ref$typeIconAriaLabe = _ref.typeIconAriaLabel,\n      typeIconAriaLabel = _ref$typeIconAriaLabe === void 0 ? type : _ref$typeIconAriaLabe,\n      children = _ref.children,\n      _ref$noPadding = _ref.noPadding,\n      noPadding = _ref$noPadding === void 0 ? false : _ref$noPadding,\n      rest = _objectWithoutProperties(_ref, _excluded);\n\n  var tokens = useTheme();\n\n  var _styles = useMemo(function () {\n    return styles(tokens);\n  }, [tokens]);\n\n  var iconCssVal = _styles.statusIcon;\n  var StatusIcon = iconMap[type];\n  var baseCSS = [_styles.base, noPadding && _styles.noPadding];\n  return jsx(\"div\", _extends({\n    role: \"alert\",\n    css: baseCSS,\n    className: className,\n    \"data-ppui-info\": \"contextual-alert_3.0.2-ql\"\n  }, rest), jsx(StatusIcon, {\n    css: iconCssVal,\n    size: \"xs\",\n    color: {\n      info: 'sysColorInfoContrast',\n      success: 'sysColorSuccessMain',\n      warning: 'sysColorWarningAlt',\n      error: 'sysColorErrorMain'\n    }[type],\n    role: \"img\",\n    \"aria-label\": typeIconAriaLabel,\n    \"data-ppui\": \"true\"\n  }), children);\n};\n\nexport { ContextualAlert, styles as contextualAlertStyles };\n","!function(root, factory) {\n    \"object\" == typeof exports && \"object\" == typeof module ? module.exports = factory() : \"function\" == typeof define && define.amd ? define(\"beaver\", [], factory) : \"object\" == typeof exports ? exports.beaver = factory() : root.beaver = factory();\n}(\"undefined\" != typeof self ? self : this, (function() {\n    return function(modules) {\n        var installedModules = {};\n        function __webpack_require__(moduleId) {\n            if (installedModules[moduleId]) return installedModules[moduleId].exports;\n            var module = installedModules[moduleId] = {\n                i: moduleId,\n                l: !1,\n                exports: {}\n            };\n            modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n            module.l = !0;\n            return module.exports;\n        }\n        __webpack_require__.m = modules;\n        __webpack_require__.c = installedModules;\n        __webpack_require__.d = function(exports, name, getter) {\n            __webpack_require__.o(exports, name) || Object.defineProperty(exports, name, {\n                enumerable: !0,\n                get: getter\n            });\n        };\n        __webpack_require__.r = function(exports) {\n            \"undefined\" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {\n                value: \"Module\"\n            });\n            Object.defineProperty(exports, \"__esModule\", {\n                value: !0\n            });\n        };\n        __webpack_require__.t = function(value, mode) {\n            1 & mode && (value = __webpack_require__(value));\n            if (8 & mode) return value;\n            if (4 & mode && \"object\" == typeof value && value && value.__esModule) return value;\n            var ns = Object.create(null);\n            __webpack_require__.r(ns);\n            Object.defineProperty(ns, \"default\", {\n                enumerable: !0,\n                value: value\n            });\n            if (2 & mode && \"string\" != typeof value) for (var key in value) __webpack_require__.d(ns, key, function(key) {\n                return value[key];\n            }.bind(null, key));\n            return ns;\n        };\n        __webpack_require__.n = function(module) {\n            var getter = module && module.__esModule ? function() {\n                return module.default;\n            } : function() {\n                return module;\n            };\n            __webpack_require__.d(getter, \"a\", getter);\n            return getter;\n        };\n        __webpack_require__.o = function(object, property) {\n            return {}.hasOwnProperty.call(object, property);\n        };\n        __webpack_require__.p = \"\";\n        return __webpack_require__(__webpack_require__.s = 0);\n    }([ function(module, __webpack_exports__, __webpack_require__) {\n        \"use strict\";\n        __webpack_require__.r(__webpack_exports__);\n        __webpack_require__.d(__webpack_exports__, \"Logger\", (function() {\n            return Logger;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"LOG_LEVEL\", (function() {\n            return LOG_LEVEL;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"PROTOCOL\", (function() {\n            return constants_PROTOCOL;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"canUseSendBeacon\", (function() {\n            return canUseSendBeacon;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"extendIfDefined\", (function() {\n            return extendIfDefined;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"isAmplitude\", (function() {\n            return util_isAmplitude;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"sendBeacon\", (function() {\n            return sendBeacon;\n        }));\n        __webpack_require__.d(__webpack_exports__, \"getHTTPTransport\", (function() {\n            return getHTTPTransport;\n        }));\n        function _extends() {\n            return (_extends = Object.assign || function(target) {\n                for (var i = 1; i < arguments.length; i++) {\n                    var source = arguments[i];\n                    for (var key in source) ({}).hasOwnProperty.call(source, key) && (target[key] = source[key]);\n                }\n                return target;\n            }).apply(this, arguments);\n        }\n        function utils_isPromise(item) {\n            try {\n                if (!item) return !1;\n                if (\"undefined\" != typeof Promise && item instanceof Promise) return !0;\n                if (\"undefined\" != typeof window && \"function\" == typeof window.Window && item instanceof window.Window) return !1;\n                if (\"undefined\" != typeof window && \"function\" == typeof window.constructor && item instanceof window.constructor) return !1;\n                var _toString = {}.toString;\n                if (_toString) {\n                    var name = _toString.call(item);\n                    if (\"[object Window]\" === name || \"[object global]\" === name || \"[object DOMWindow]\" === name) return !1;\n                }\n                if (\"function\" == typeof item.then) return !0;\n            } catch (err) {\n                return !1;\n            }\n            return !1;\n        }\n        var dispatchedErrors = [];\n        var possiblyUnhandledPromiseHandlers = [];\n        var activeCount = 0;\n        var flushPromise;\n        function flushActive() {\n            if (!activeCount && flushPromise) {\n                var promise = flushPromise;\n                flushPromise = null;\n                promise.resolve();\n            }\n        }\n        function startActive() {\n            activeCount += 1;\n        }\n        function endActive() {\n            activeCount -= 1;\n            flushActive();\n        }\n        var promise_ZalgoPromise = function() {\n            function ZalgoPromise(handler) {\n                var _this = this;\n                this.resolved = void 0;\n                this.rejected = void 0;\n                this.errorHandled = void 0;\n                this.value = void 0;\n                this.error = void 0;\n                this.handlers = void 0;\n                this.dispatching = void 0;\n                this.stack = void 0;\n                this.resolved = !1;\n                this.rejected = !1;\n                this.errorHandled = !1;\n                this.handlers = [];\n                if (handler) {\n                    var _result;\n                    var _error;\n                    var resolved = !1;\n                    var rejected = !1;\n                    var isAsync = !1;\n                    startActive();\n                    try {\n                        handler((function(res) {\n                            if (isAsync) _this.resolve(res); else {\n                                resolved = !0;\n                                _result = res;\n                            }\n                        }), (function(err) {\n                            if (isAsync) _this.reject(err); else {\n                                rejected = !0;\n                                _error = err;\n                            }\n                        }));\n                    } catch (err) {\n                        endActive();\n                        this.reject(err);\n                        return;\n                    }\n                    endActive();\n                    isAsync = !0;\n                    resolved ? this.resolve(_result) : rejected && this.reject(_error);\n                }\n            }\n            var _proto = ZalgoPromise.prototype;\n            _proto.resolve = function(result) {\n                if (this.resolved || this.rejected) return this;\n                if (utils_isPromise(result)) throw new Error(\"Can not resolve promise with another promise\");\n                this.resolved = !0;\n                this.value = result;\n                this.dispatch();\n                return this;\n            };\n            _proto.reject = function(error) {\n                var _this2 = this;\n                if (this.resolved || this.rejected) return this;\n                if (utils_isPromise(error)) throw new Error(\"Can not reject promise with another promise\");\n                if (!error) {\n                    var _err = error && \"function\" == typeof error.toString ? error.toString() : {}.toString.call(error);\n                    error = new Error(\"Expected reject to be called with Error, got \" + _err);\n                }\n                this.rejected = !0;\n                this.error = error;\n                this.errorHandled || setTimeout((function() {\n                    _this2.errorHandled || function(err, promise) {\n                        if (-1 === dispatchedErrors.indexOf(err)) {\n                            dispatchedErrors.push(err);\n                            setTimeout((function() {\n                                throw err;\n                            }), 1);\n                            for (var j = 0; j < possiblyUnhandledPromiseHandlers.length; j++) possiblyUnhandledPromiseHandlers[j](err, promise);\n                        }\n                    }(error, _this2);\n                }), 1);\n                this.dispatch();\n                return this;\n            };\n            _proto.asyncReject = function(error) {\n                this.errorHandled = !0;\n                this.reject(error);\n                return this;\n            };\n            _proto.dispatch = function() {\n                var resolved = this.resolved, rejected = this.rejected, handlers = this.handlers;\n                if (!this.dispatching && (resolved || rejected)) {\n                    this.dispatching = !0;\n                    startActive();\n                    var chain = function(firstPromise, secondPromise) {\n                        return firstPromise.then((function(res) {\n                            secondPromise.resolve(res);\n                        }), (function(err) {\n                            secondPromise.reject(err);\n                        }));\n                    };\n                    for (var i = 0; i < handlers.length; i++) {\n                        var _handlers$i = handlers[i], onSuccess = _handlers$i.onSuccess, onError = _handlers$i.onError, promise = _handlers$i.promise;\n                        var _result2 = void 0;\n                        if (resolved) try {\n                            _result2 = onSuccess ? onSuccess(this.value) : this.value;\n                        } catch (err) {\n                            promise.reject(err);\n                            continue;\n                        } else if (rejected) {\n                            if (!onError) {\n                                promise.reject(this.error);\n                                continue;\n                            }\n                            try {\n                                _result2 = onError(this.error);\n                            } catch (err) {\n                                promise.reject(err);\n                                continue;\n                            }\n                        }\n                        if (_result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected)) {\n                            var promiseResult = _result2;\n                            promiseResult.resolved ? promise.resolve(promiseResult.value) : promise.reject(promiseResult.error);\n                            promiseResult.errorHandled = !0;\n                        } else utils_isPromise(_result2) ? _result2 instanceof ZalgoPromise && (_result2.resolved || _result2.rejected) ? _result2.resolved ? promise.resolve(_result2.value) : promise.reject(_result2.error) : chain(_result2, promise) : promise.resolve(_result2);\n                    }\n                    handlers.length = 0;\n                    this.dispatching = !1;\n                    endActive();\n                }\n            };\n            _proto.then = function(onSuccess, onError) {\n                if (onSuccess && \"function\" != typeof onSuccess && !onSuccess.call) throw new Error(\"Promise.then expected a function for success handler\");\n                if (onError && \"function\" != typeof onError && !onError.call) throw new Error(\"Promise.then expected a function for error handler\");\n                var promise = new ZalgoPromise;\n                this.handlers.push({\n                    promise: promise,\n                    onSuccess: onSuccess,\n                    onError: onError\n                });\n                this.errorHandled = !0;\n                this.dispatch();\n                return promise;\n            };\n            _proto.catch = function(onError) {\n                return this.then(void 0, onError);\n            };\n            _proto.finally = function(onFinally) {\n                if (onFinally && \"function\" != typeof onFinally && !onFinally.call) throw new Error(\"Promise.finally expected a function\");\n                return this.then((function(result) {\n                    return ZalgoPromise.try(onFinally).then((function() {\n                        return result;\n                    }));\n                }), (function(err) {\n                    return ZalgoPromise.try(onFinally).then((function() {\n                        throw err;\n                    }));\n                }));\n            };\n            _proto.timeout = function(time, err) {\n                var _this3 = this;\n                if (this.resolved || this.rejected) return this;\n                var timeout = setTimeout((function() {\n                    _this3.resolved || _this3.rejected || _this3.reject(err || new Error(\"Promise timed out after \" + time + \"ms\"));\n                }), time);\n                return this.then((function(result) {\n                    clearTimeout(timeout);\n                    return result;\n                }));\n            };\n            _proto.toPromise = function() {\n                if (\"undefined\" == typeof Promise) throw new TypeError(\"Could not find Promise\");\n                return Promise.resolve(this);\n            };\n            _proto.lazy = function() {\n                this.errorHandled = !0;\n                return this;\n            };\n            ZalgoPromise.resolve = function(value) {\n                return value instanceof ZalgoPromise ? value : utils_isPromise(value) ? new ZalgoPromise((function(resolve, reject) {\n                    return value.then(resolve, reject);\n                })) : (new ZalgoPromise).resolve(value);\n            };\n            ZalgoPromise.reject = function(error) {\n                return (new ZalgoPromise).reject(error);\n            };\n            ZalgoPromise.asyncReject = function(error) {\n                return (new ZalgoPromise).asyncReject(error);\n            };\n            ZalgoPromise.all = function(promises) {\n                var promise = new ZalgoPromise;\n                var count = promises.length;\n                var results = [].slice();\n                if (!count) {\n                    promise.resolve(results);\n                    return promise;\n                }\n                var chain = function(i, firstPromise, secondPromise) {\n                    return firstPromise.then((function(res) {\n                        results[i] = res;\n                        0 == (count -= 1) && promise.resolve(results);\n                    }), (function(err) {\n                        secondPromise.reject(err);\n                    }));\n                };\n                for (var i = 0; i < promises.length; i++) {\n                    var prom = promises[i];\n                    if (prom instanceof ZalgoPromise) {\n                        if (prom.resolved) {\n                            results[i] = prom.value;\n                            count -= 1;\n                            continue;\n                        }\n                    } else if (!utils_isPromise(prom)) {\n                        results[i] = prom;\n                        count -= 1;\n                        continue;\n                    }\n                    chain(i, ZalgoPromise.resolve(prom), promise);\n                }\n                0 === count && promise.resolve(results);\n                return promise;\n            };\n            ZalgoPromise.hash = function(promises) {\n                var result = {};\n                var awaitPromises = [];\n                var _loop = function(key) {\n                    if (promises.hasOwnProperty(key)) {\n                        var value = promises[key];\n                        utils_isPromise(value) ? awaitPromises.push(value.then((function(res) {\n                            result[key] = res;\n                        }))) : result[key] = value;\n                    }\n                };\n                for (var key in promises) _loop(key);\n                return ZalgoPromise.all(awaitPromises).then((function() {\n                    return result;\n                }));\n            };\n            ZalgoPromise.map = function(items, method) {\n                return ZalgoPromise.all(items.map(method));\n            };\n            ZalgoPromise.onPossiblyUnhandledException = function(handler) {\n                return function(handler) {\n                    possiblyUnhandledPromiseHandlers.push(handler);\n                    return {\n                        cancel: function() {\n                            possiblyUnhandledPromiseHandlers.splice(possiblyUnhandledPromiseHandlers.indexOf(handler), 1);\n                        }\n                    };\n                }(handler);\n            };\n            ZalgoPromise.try = function(method, context, args) {\n                if (method && \"function\" != typeof method && !method.call) throw new Error(\"Promise.try expected a function\");\n                var result;\n                startActive();\n                try {\n                    result = method.apply(context, args || []);\n                } catch (err) {\n                    endActive();\n                    return ZalgoPromise.reject(err);\n                }\n                endActive();\n                return ZalgoPromise.resolve(result);\n            };\n            ZalgoPromise.delay = function(_delay) {\n                return new ZalgoPromise((function(resolve) {\n                    setTimeout(resolve, _delay);\n                }));\n            };\n            ZalgoPromise.isPromise = function(value) {\n                return !!(value && value instanceof ZalgoPromise) || utils_isPromise(value);\n            };\n            ZalgoPromise.flush = function() {\n                return function(Zalgo) {\n                    var promise = flushPromise = flushPromise || new Zalgo;\n                    flushActive();\n                    return promise;\n                }(ZalgoPromise);\n            };\n            return ZalgoPromise;\n        }();\n        var IE_WIN_ACCESS_ERROR = \"Call was rejected by callee.\\r\\n\";\n        function getActualProtocol(win) {\n            void 0 === win && (win = window);\n            return win.location.protocol;\n        }\n        function getProtocol(win) {\n            void 0 === win && (win = window);\n            if (win.mockDomain) {\n                var protocol = win.mockDomain.split(\"//\")[0];\n                if (protocol) return protocol;\n            }\n            return getActualProtocol(win);\n        }\n        function isAboutProtocol(win) {\n            void 0 === win && (win = window);\n            return \"about:\" === getProtocol(win);\n        }\n        function canReadFromWindow(win) {\n            try {\n                return !0;\n            } catch (err) {}\n            return !1;\n        }\n        function getActualDomain(win) {\n            void 0 === win && (win = window);\n            var location = win.location;\n            if (!location) throw new Error(\"Can not read window location\");\n            var protocol = getActualProtocol(win);\n            if (!protocol) throw new Error(\"Can not read window protocol\");\n            if (\"file:\" === protocol) return \"file://\";\n            if (\"about:\" === protocol) {\n                var parent = function(win) {\n                    void 0 === win && (win = window);\n                    if (win) try {\n                        if (win.parent && win.parent !== win) return win.parent;\n                    } catch (err) {}\n                }(win);\n                return parent && canReadFromWindow() ? getActualDomain(parent) : \"about://\";\n            }\n            var host = location.host;\n            if (!host) throw new Error(\"Can not read window host\");\n            return protocol + \"//\" + host;\n        }\n        function getDomain(win) {\n            void 0 === win && (win = window);\n            var domain = getActualDomain(win);\n            return domain && win.mockDomain && 0 === win.mockDomain.indexOf(\"mock:\") ? win.mockDomain : domain;\n        }\n        function isSameDomain(win) {\n            if (!function(win) {\n                try {\n                    if (win === window) return !0;\n                } catch (err) {}\n                try {\n                    var desc = Object.getOwnPropertyDescriptor(win, \"location\");\n                    if (desc && !1 === desc.enumerable) return !1;\n                } catch (err) {}\n                try {\n                    if (isAboutProtocol(win) && canReadFromWindow()) return !0;\n                } catch (err) {}\n                try {\n                    if (function(win) {\n                        void 0 === win && (win = window);\n                        return \"mock:\" === getProtocol(win);\n                    }(win) && canReadFromWindow()) return !0;\n                } catch (err) {}\n                try {\n                    if (getActualDomain(win) === getActualDomain(window)) return !0;\n                } catch (err) {}\n                return !1;\n            }(win)) return !1;\n            try {\n                if (win === window) return !0;\n                if (isAboutProtocol(win) && canReadFromWindow()) return !0;\n                if (getDomain(window) === getDomain(win)) return !0;\n            } catch (err) {}\n            return !1;\n        }\n        var iframeWindows = [];\n        var iframeFrames = [];\n        function isWindowClosed(win, allowMock) {\n            void 0 === allowMock && (allowMock = !0);\n            try {\n                if (win === window) return !1;\n            } catch (err) {\n                return !0;\n            }\n            try {\n                if (!win) return !0;\n            } catch (err) {\n                return !0;\n            }\n            try {\n                if (win.closed) return !0;\n            } catch (err) {\n                return !err || err.message !== IE_WIN_ACCESS_ERROR;\n            }\n            if (allowMock && isSameDomain(win)) try {\n                if (win.mockclosed) return !0;\n            } catch (err) {}\n            try {\n                if (!win.parent || !win.top) return !0;\n            } catch (err) {}\n            var iframeIndex = function(collection, item) {\n                for (var i = 0; i < collection.length; i++) try {\n                    if (collection[i] === item) return i;\n                } catch (err) {}\n                return -1;\n            }(iframeWindows, win);\n            if (-1 !== iframeIndex) {\n                var frame = iframeFrames[iframeIndex];\n                if (frame && function(frame) {\n                    if (!frame.contentWindow) return !0;\n                    if (!frame.parentNode) return !0;\n                    var doc = frame.ownerDocument;\n                    if (doc && doc.documentElement && !doc.documentElement.contains(frame)) {\n                        var parent = frame;\n                        for (;parent.parentNode && parent.parentNode !== parent; ) parent = parent.parentNode;\n                        if (!parent.host || !doc.documentElement.contains(parent.host)) return !0;\n                    }\n                    return !1;\n                }(frame)) return !0;\n            }\n            return !1;\n        }\n        function isWindow(obj) {\n            try {\n                if (obj === window) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (\"[object Window]\" === {}.toString.call(obj)) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (window.Window && obj instanceof window.Window) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && obj.self === obj) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && obj.parent === obj) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && obj.top === obj) return !0;\n            } catch (err) {\n                if (err && err.message === IE_WIN_ACCESS_ERROR) return !0;\n            }\n            try {\n                if (obj && \"__unlikely_value__\" === obj.__cross_domain_utils_window_check__) return !1;\n            } catch (err) {\n                return !0;\n            }\n            try {\n                if (\"postMessage\" in obj && \"self\" in obj && \"location\" in obj) return !0;\n            } catch (err) {}\n            return !1;\n        }\n        function util_safeIndexOf(collection, item) {\n            for (var i = 0; i < collection.length; i++) try {\n                if (collection[i] === item) return i;\n            } catch (err) {}\n            return -1;\n        }\n        var weakmap_CrossDomainSafeWeakMap = function() {\n            function CrossDomainSafeWeakMap() {\n                this.name = void 0;\n                this.weakmap = void 0;\n                this.keys = void 0;\n                this.values = void 0;\n                this.name = \"__weakmap_\" + (1e9 * Math.random() >>> 0) + \"__\";\n                if (function() {\n                    if (\"undefined\" == typeof WeakMap) return !1;\n                    if (void 0 === Object.freeze) return !1;\n                    try {\n                        var testWeakMap = new WeakMap;\n                        var testKey = {};\n                        Object.freeze(testKey);\n                        testWeakMap.set(testKey, \"__testvalue__\");\n                        return \"__testvalue__\" === testWeakMap.get(testKey);\n                    } catch (err) {\n                        return !1;\n                    }\n                }()) try {\n                    this.weakmap = new WeakMap;\n                } catch (err) {}\n                this.keys = [];\n                this.values = [];\n            }\n            var _proto = CrossDomainSafeWeakMap.prototype;\n            _proto._cleanupClosedWindows = function() {\n                var weakmap = this.weakmap;\n                var keys = this.keys;\n                for (var i = 0; i < keys.length; i++) {\n                    var value = keys[i];\n                    if (isWindow(value) && isWindowClosed(value)) {\n                        if (weakmap) try {\n                            weakmap.delete(value);\n                        } catch (err) {}\n                        keys.splice(i, 1);\n                        this.values.splice(i, 1);\n                        i -= 1;\n                    }\n                }\n            };\n            _proto.isSafeToReadWrite = function(key) {\n                return !isWindow(key);\n            };\n            _proto.set = function(key, value) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    weakmap.set(key, value);\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var name = this.name;\n                    var entry = key[name];\n                    entry && entry[0] === key ? entry[1] = value : Object.defineProperty(key, name, {\n                        value: [ key, value ],\n                        writable: !0\n                    });\n                    return;\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                var keys = this.keys;\n                var values = this.values;\n                var index = util_safeIndexOf(keys, key);\n                if (-1 === index) {\n                    keys.push(key);\n                    values.push(value);\n                } else values[index] = value;\n            };\n            _proto.get = function(key) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    if (weakmap.has(key)) return weakmap.get(key);\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var entry = key[this.name];\n                    return entry && entry[0] === key ? entry[1] : void 0;\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                var index = util_safeIndexOf(this.keys, key);\n                if (-1 !== index) return this.values[index];\n            };\n            _proto.delete = function(key) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    weakmap.delete(key);\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var entry = key[this.name];\n                    entry && entry[0] === key && (entry[0] = entry[1] = void 0);\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                var keys = this.keys;\n                var index = util_safeIndexOf(keys, key);\n                if (-1 !== index) {\n                    keys.splice(index, 1);\n                    this.values.splice(index, 1);\n                }\n            };\n            _proto.has = function(key) {\n                if (!key) throw new Error(\"WeakMap expected key\");\n                var weakmap = this.weakmap;\n                if (weakmap) try {\n                    if (weakmap.has(key)) return !0;\n                } catch (err) {\n                    delete this.weakmap;\n                }\n                if (this.isSafeToReadWrite(key)) try {\n                    var entry = key[this.name];\n                    return !(!entry || entry[0] !== key);\n                } catch (err) {}\n                this._cleanupClosedWindows();\n                return -1 !== util_safeIndexOf(this.keys, key);\n            };\n            _proto.getOrSet = function(key, getter) {\n                if (this.has(key)) return this.get(key);\n                var value = getter();\n                this.set(key, value);\n                return value;\n            };\n            return CrossDomainSafeWeakMap;\n        }();\n        function getFunctionName(fn) {\n            return fn.name || fn.__name__ || fn.displayName || \"anonymous\";\n        }\n        function setFunctionName(fn, name) {\n            try {\n                delete fn.name;\n                fn.name = name;\n            } catch (err) {}\n            fn.__name__ = fn.displayName = name;\n            return fn;\n        }\n        function uniqueID() {\n            var chars = \"0123456789abcdef\";\n            return \"uid_\" + \"xxxxxxxxxx\".replace(/./g, (function() {\n                return chars.charAt(Math.floor(Math.random() * chars.length));\n            })) + \"_\" + function(str) {\n                if (\"function\" == typeof btoa) return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (function(m, p1) {\n                    return String.fromCharCode(parseInt(p1, 16));\n                }))).replace(/[=]/g, \"\");\n                if (\"undefined\" != typeof Buffer) return Buffer.from(str, \"utf8\").toString(\"base64\").replace(/[=]/g, \"\");\n                throw new Error(\"Can not find window.btoa or Buffer\");\n            }((new Date).toISOString().slice(11, 19).replace(\"T\", \".\")).replace(/[^a-zA-Z0-9]/g, \"\").toLowerCase();\n        }\n        var objectIDs;\n        function serializeArgs(args) {\n            try {\n                return JSON.stringify([].slice.call(args), (function(subkey, val) {\n                    return \"function\" == typeof val ? \"memoize[\" + function(obj) {\n                        objectIDs = objectIDs || new weakmap_CrossDomainSafeWeakMap;\n                        if (null == obj || \"object\" != typeof obj && \"function\" != typeof obj) throw new Error(\"Invalid object\");\n                        var uid = objectIDs.get(obj);\n                        if (!uid) {\n                            uid = typeof obj + \":\" + uniqueID();\n                            objectIDs.set(obj, uid);\n                        }\n                        return uid;\n                    }(val) + \"]\" : function(element) {\n                        var passed = !1;\n                        try {\n                            (element instanceof window.Element || null !== element && \"object\" == typeof element && 1 === element.nodeType && \"object\" == typeof element.style && \"object\" == typeof element.ownerDocument) && (passed = !0);\n                        } catch (_) {}\n                        return passed;\n                    }(val) ? {} : val;\n                }));\n            } catch (err) {\n                throw new Error(\"Arguments not serializable -- can not be used to memoize\");\n            }\n        }\n        function getEmptyObject() {\n            return {};\n        }\n        var memoizeGlobalIndex = 0;\n        var memoizeGlobalIndexValidFrom = 0;\n        function memoize(method, options) {\n            void 0 === options && (options = {});\n            var _options$thisNamespac = options.thisNamespace, thisNamespace = void 0 !== _options$thisNamespac && _options$thisNamespac, cacheTime = options.time;\n            var simpleCache;\n            var thisCache;\n            var memoizeIndex = memoizeGlobalIndex;\n            memoizeGlobalIndex += 1;\n            var memoizedFunction = function() {\n                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];\n                if (memoizeIndex < memoizeGlobalIndexValidFrom) {\n                    simpleCache = null;\n                    thisCache = null;\n                    memoizeIndex = memoizeGlobalIndex;\n                    memoizeGlobalIndex += 1;\n                }\n                var cache;\n                cache = thisNamespace ? (thisCache = thisCache || new weakmap_CrossDomainSafeWeakMap).getOrSet(this, getEmptyObject) : simpleCache = simpleCache || {};\n                var cacheKey;\n                try {\n                    cacheKey = serializeArgs(args);\n                } catch (_unused) {\n                    return method.apply(this, arguments);\n                }\n                var cacheResult = cache[cacheKey];\n                if (cacheResult && cacheTime && Date.now() - cacheResult.time < cacheTime) {\n                    delete cache[cacheKey];\n                    cacheResult = null;\n                }\n                if (cacheResult) return cacheResult.value;\n                var time = Date.now();\n                var value = method.apply(this, arguments);\n                cache[cacheKey] = {\n                    time: time,\n                    value: value\n                };\n                return value;\n            };\n            memoizedFunction.reset = function() {\n                simpleCache = null;\n                thisCache = null;\n            };\n            return setFunctionName(memoizedFunction, (options.name || getFunctionName(method)) + \"::memoized\");\n        }\n        memoize.clear = function() {\n            memoizeGlobalIndexValidFrom = memoizeGlobalIndex;\n        };\n        function src_util_noop() {}\n        memoize((function(obj) {\n            if (Object.values) return Object.values(obj);\n            var result = [];\n            for (var key in obj) obj.hasOwnProperty(key) && result.push(obj[key]);\n            return result;\n        }));\n        function objFilter(obj, filter) {\n            void 0 === filter && (filter = Boolean);\n            var result = {};\n            for (var key in obj) obj.hasOwnProperty(key) && filter(obj[key], key) && (result[key] = obj[key]);\n            return result;\n        }\n        Error;\n        function isDocumentReady() {\n            return Boolean(document.body) && \"complete\" === document.readyState;\n        }\n        function isDocumentInteractive() {\n            return Boolean(document.body) && \"interactive\" === document.readyState;\n        }\n        memoize((function() {\n            return new promise_ZalgoPromise((function(resolve) {\n                if (isDocumentReady() || isDocumentInteractive()) return resolve();\n                var interval = setInterval((function() {\n                    if (isDocumentReady() || isDocumentInteractive()) {\n                        clearInterval(interval);\n                        return resolve();\n                    }\n                }), 10);\n            }));\n        }));\n        function dom_isBrowser() {\n            return \"undefined\" != typeof window && void 0 !== window.location;\n        }\n        var currentScript = \"undefined\" != typeof document ? document.currentScript : null;\n        var getCurrentScript = memoize((function() {\n            if (currentScript) return currentScript;\n            if (currentScript = function() {\n                try {\n                    var stack = function() {\n                        try {\n                            throw new Error(\"_\");\n                        } catch (err) {\n                            return err.stack || \"\";\n                        }\n                    }();\n                    var stackDetails = /.*at [^(]*\\((.*):(.+):(.+)\\)$/gi.exec(stack);\n                    var scriptLocation = stackDetails && stackDetails[1];\n                    if (!scriptLocation) return;\n                    for (var _i22 = 0, _Array$prototype$slic2 = [].slice.call(document.getElementsByTagName(\"script\")).reverse(); _i22 < _Array$prototype$slic2.length; _i22++) {\n                        var script = _Array$prototype$slic2[_i22];\n                        if (script.src && script.src === scriptLocation) return script;\n                    }\n                } catch (err) {}\n            }()) return currentScript;\n            throw new Error(\"Can not determine current script\");\n        }));\n        var currentUID = uniqueID();\n        memoize((function() {\n            var script;\n            try {\n                script = getCurrentScript();\n            } catch (err) {\n                return currentUID;\n            }\n            var uid = script.getAttribute(\"data-uid\");\n            if (uid && \"string\" == typeof uid) return uid;\n            if ((uid = script.getAttribute(\"data-uid-auto\")) && \"string\" == typeof uid) return uid;\n            if (script.src) {\n                var hashedString = function(str) {\n                    var hash = \"\";\n                    for (var i = 0; i < str.length; i++) {\n                        var total = str[i].charCodeAt(0) * i;\n                        str[i + 1] && (total += str[i + 1].charCodeAt(0) * (i - 1));\n                        hash += String.fromCharCode(97 + Math.abs(total) % 26);\n                    }\n                    return hash;\n                }(JSON.stringify({\n                    src: script.src,\n                    dataset: script.dataset\n                }));\n                uid = \"uid_\" + hashedString.slice(hashedString.length - 30);\n            } else uid = uniqueID();\n            script.setAttribute(\"data-uid-auto\", uid);\n            return uid;\n        }));\n        var http_headerBuilders = [];\n        var LOG_LEVEL = {\n            DEBUG: \"debug\",\n            INFO: \"info\",\n            WARN: \"warn\",\n            ERROR: \"error\"\n        };\n        var constants_PROTOCOL = {\n            FILE: \"file:\"\n        };\n        var AUTO_FLUSH_LEVEL = [ LOG_LEVEL.WARN, LOG_LEVEL.ERROR ];\n        var LOG_LEVEL_PRIORITY = [ LOG_LEVEL.ERROR, LOG_LEVEL.WARN, LOG_LEVEL.INFO, LOG_LEVEL.DEBUG ];\n        var DEFAULT_LOG_LEVEL = LOG_LEVEL.WARN;\n        var canUseSendBeacon = function(_ref) {\n            var headers = _ref.headers, enableSendBeacon = _ref.enableSendBeacon;\n            var hasHeaders = headers && Object.keys(headers).length;\n            return !!(window && window.navigator.sendBeacon && !hasHeaders && enableSendBeacon && window.Blob);\n        };\n        var util_isAmplitude = function(url) {\n            return \"https://api2.amplitude.com/2/httpapi\" === url;\n        };\n        var sendBeacon = function(_ref2) {\n            var _ref2$win = _ref2.win, win = void 0 === _ref2$win ? window : _ref2$win, url = _ref2.url, data = _ref2.data, _ref2$useBlob = _ref2.useBlob, useBlob = void 0 === _ref2$useBlob || _ref2$useBlob;\n            try {\n                var json = JSON.stringify(data);\n                if (!win.navigator.sendBeacon) throw new Error(\"No sendBeacon available\");\n                if (useBlob) {\n                    var blob = new Blob([ json ], {\n                        type: \"application/json\"\n                    });\n                    return win.navigator.sendBeacon(url, blob);\n                }\n                return win.navigator.sendBeacon(url, json);\n            } catch (e) {\n                return !1;\n            }\n        };\n        var extendIfDefined = function(target, source) {\n            for (var key in source) source.hasOwnProperty(key) && (target[key] = source[key]);\n        };\n        function getHTTPTransport(httpWin) {\n            void 0 === httpWin && (httpWin = window);\n            var win = isSameDomain(httpWin) ? function(win) {\n                if (!isSameDomain(win)) throw new Error(\"Expected window to be same domain\");\n                return win;\n            }(httpWin) : window;\n            return function(_ref) {\n                var url = _ref.url, method = _ref.method, headers = _ref.headers, json = _ref.json, _ref$enableSendBeacon = _ref.enableSendBeacon, enableSendBeacon = void 0 !== _ref$enableSendBeacon && _ref$enableSendBeacon;\n                return promise_ZalgoPromise.try((function() {\n                    var beaconResult = !1;\n                    canUseSendBeacon({\n                        headers: headers,\n                        enableSendBeacon: enableSendBeacon\n                    }) && (beaconResult = util_isAmplitude(url) ? sendBeacon({\n                        win: win,\n                        url: url,\n                        data: json,\n                        useBlob: !1\n                    }) : sendBeacon({\n                        win: win,\n                        url: url,\n                        data: json,\n                        useBlob: !0\n                    }));\n                    return beaconResult || function(_ref) {\n                        var url = _ref.url, _ref$method = _ref.method, method = void 0 === _ref$method ? \"get\" : _ref$method, _ref$headers = _ref.headers, headers = void 0 === _ref$headers ? {} : _ref$headers, json = _ref.json, data = _ref.data, body = _ref.body, _ref$win = _ref.win, win = void 0 === _ref$win ? window : _ref$win, _ref$timeout = _ref.timeout, timeout = void 0 === _ref$timeout ? 0 : _ref$timeout;\n                        return new promise_ZalgoPromise((function(resolve, reject) {\n                            if (json && data || json && body || data && json) throw new Error(\"Only options.json or options.data or options.body should be passed\");\n                            var normalizedHeaders = {};\n                            for (var _i4 = 0, _Object$keys2 = Object.keys(headers); _i4 < _Object$keys2.length; _i4++) {\n                                var _key2 = _Object$keys2[_i4];\n                                normalizedHeaders[_key2.toLowerCase()] = headers[_key2];\n                            }\n                            json ? normalizedHeaders[\"content-type\"] = normalizedHeaders[\"content-type\"] || \"application/json\" : (data || body) && (normalizedHeaders[\"content-type\"] = normalizedHeaders[\"content-type\"] || \"application/x-www-form-urlencoded; charset=utf-8\");\n                            normalizedHeaders.accept = normalizedHeaders.accept || \"application/json\";\n                            for (var _i6 = 0; _i6 < http_headerBuilders.length; _i6++) {\n                                var builtHeaders = (0, http_headerBuilders[_i6])();\n                                for (var _i8 = 0, _Object$keys4 = Object.keys(builtHeaders); _i8 < _Object$keys4.length; _i8++) {\n                                    var _key3 = _Object$keys4[_i8];\n                                    normalizedHeaders[_key3.toLowerCase()] = builtHeaders[_key3];\n                                }\n                            }\n                            var xhr = new win.XMLHttpRequest;\n                            xhr.addEventListener(\"load\", (function() {\n                                var responseHeaders = function(rawHeaders) {\n                                    void 0 === rawHeaders && (rawHeaders = \"\");\n                                    var result = {};\n                                    for (var _i2 = 0, _rawHeaders$trim$spli2 = rawHeaders.trim().split(\"\\n\"); _i2 < _rawHeaders$trim$spli2.length; _i2++) {\n                                        var _line$split = _rawHeaders$trim$spli2[_i2].split(\":\"), _key = _line$split[0], values = _line$split.slice(1);\n                                        result[_key.toLowerCase()] = values.join(\":\").trim();\n                                    }\n                                    return result;\n                                }(this.getAllResponseHeaders());\n                                if (!this.status) return reject(new Error(\"Request to \" + method.toLowerCase() + \" \" + url + \" failed: no response status code.\"));\n                                var contentType = responseHeaders[\"content-type\"];\n                                var isJSON = contentType && (0 === contentType.indexOf(\"application/json\") || 0 === contentType.indexOf(\"text/json\"));\n                                var responseBody = this.responseText;\n                                try {\n                                    responseBody = JSON.parse(responseBody);\n                                } catch (err) {\n                                    if (isJSON) return reject(new Error(\"Invalid json: \" + this.responseText + \".\"));\n                                }\n                                return resolve({\n                                    status: this.status,\n                                    headers: responseHeaders,\n                                    body: responseBody\n                                });\n                            }), !1);\n                            xhr.addEventListener(\"error\", (function(evt) {\n                                reject(new Error(\"Request to \" + method.toLowerCase() + \" \" + url + \" failed: \" + evt.toString() + \".\"));\n                            }), !1);\n                            xhr.open(method, url, !0);\n                            for (var _key4 in normalizedHeaders) normalizedHeaders.hasOwnProperty(_key4) && xhr.setRequestHeader(_key4, normalizedHeaders[_key4]);\n                            json ? body = JSON.stringify(json) : data && (body = Object.keys(data).map((function(key) {\n                                return encodeURIComponent(key) + \"=\" + (data ? encodeURIComponent(data[key]) : \"\");\n                            })).join(\"&\"));\n                            xhr.timeout = timeout;\n                            xhr.ontimeout = function() {\n                                reject(new Error(\"Request to \" + method.toLowerCase() + \" \" + url + \" has timed out\"));\n                            };\n                            xhr.send(body);\n                        }));\n                    }({\n                        win: win,\n                        url: url,\n                        method: method,\n                        headers: headers,\n                        json: json\n                    });\n                })).then(src_util_noop);\n            };\n        }\n        function Logger(_ref) {\n            var url = _ref.url, prefix = _ref.prefix, _ref$logLevel = _ref.logLevel, logLevel = void 0 === _ref$logLevel ? DEFAULT_LOG_LEVEL : _ref$logLevel, _ref$transport = _ref.transport, transport = void 0 === _ref$transport ? getHTTPTransport() : _ref$transport, amplitudeApiKey = _ref.amplitudeApiKey, _ref$flushInterval = _ref.flushInterval, flushInterval = void 0 === _ref$flushInterval ? 6e4 : _ref$flushInterval, _ref$enableSendBeacon = _ref.enableSendBeacon, enableSendBeacon = void 0 !== _ref$enableSendBeacon && _ref$enableSendBeacon;\n            var events = [];\n            var tracking = [];\n            var payloadBuilders = [];\n            var metaBuilders = [];\n            var trackingBuilders = [];\n            var headerBuilders = [];\n            function print(level, event, payload) {\n                if (dom_isBrowser() && window.console && window.console.log && !(LOG_LEVEL_PRIORITY.indexOf(level) > LOG_LEVEL_PRIORITY.indexOf(logLevel))) {\n                    var args = [ event ];\n                    args.push(payload);\n                    (payload.error || payload.warning) && args.push(\"\\n\\n\", payload.error || payload.warning);\n                    try {\n                        window.console[level] && window.console[level].apply ? window.console[level].apply(window.console, args) : window.console.log && window.console.log.apply && window.console.log.apply(window.console, args);\n                    } catch (err) {}\n                }\n            }\n            function immediateFlush() {\n                return promise_ZalgoPromise.try((function() {\n                    if (dom_isBrowser() && window.location.protocol !== constants_PROTOCOL.FILE && (events.length || tracking.length)) {\n                        var meta = {};\n                        for (var _i2 = 0; _i2 < metaBuilders.length; _i2++) extendIfDefined(meta, (0, metaBuilders[_i2])(meta));\n                        var headers = {};\n                        for (var _i4 = 0; _i4 < headerBuilders.length; _i4++) extendIfDefined(headers, (0, \n                        headerBuilders[_i4])(headers));\n                        var res;\n                        url && (res = transport({\n                            method: \"POST\",\n                            url: url,\n                            headers: headers,\n                            json: {\n                                events: events,\n                                meta: meta,\n                                tracking: tracking\n                            },\n                            enableSendBeacon: enableSendBeacon\n                        }).catch(src_util_noop));\n                        amplitudeApiKey && transport({\n                            method: \"POST\",\n                            url: \"https://api2.amplitude.com/2/httpapi\",\n                            headers: {},\n                            json: {\n                                api_key: amplitudeApiKey,\n                                events: tracking.map((function(payload) {\n                                    return _extends({\n                                        event_type: payload.transition_name || \"event\",\n                                        event_properties: payload\n                                    }, payload);\n                                }))\n                            },\n                            enableSendBeacon: enableSendBeacon\n                        }).catch(src_util_noop);\n                        events = [];\n                        tracking = [];\n                        return promise_ZalgoPromise.resolve(res).then(src_util_noop);\n                    }\n                }));\n            }\n            var flush = function(method, delay) {\n                void 0 === delay && (delay = 50);\n                var promise;\n                var timeout;\n                return setFunctionName((function() {\n                    timeout && clearTimeout(timeout);\n                    var localPromise = promise = promise || new promise_ZalgoPromise;\n                    timeout = setTimeout((function() {\n                        promise = null;\n                        timeout = null;\n                        promise_ZalgoPromise.try(method).then((function(result) {\n                            localPromise.resolve(result);\n                        }), (function(err) {\n                            localPromise.reject(err);\n                        }));\n                    }), delay);\n                    return localPromise;\n                }), getFunctionName(method) + \"::promiseDebounced\");\n            }(immediateFlush);\n            function log(level, event, payload) {\n                void 0 === payload && (payload = {});\n                if (!dom_isBrowser()) return logger;\n                prefix && (event = prefix + \"_\" + event);\n                var logPayload = _extends({}, objFilter(payload, (function(value) {\n                    return null != value;\n                })), {\n                    timestamp: Date.now().toString()\n                });\n                for (var _i6 = 0; _i6 < payloadBuilders.length; _i6++) extendIfDefined(logPayload, (0, \n                payloadBuilders[_i6])(logPayload));\n                !function(level, event, payload) {\n                    events.push({\n                        level: level,\n                        event: event,\n                        payload: payload\n                    });\n                    -1 !== AUTO_FLUSH_LEVEL.indexOf(level) && flush();\n                }(level, event, logPayload);\n                print(level, event, logPayload);\n                return logger;\n            }\n            function addBuilder(builders, builder) {\n                builders.push(builder);\n                return logger;\n            }\n            dom_isBrowser() && (method = flush, time = flushInterval, function loop() {\n                setTimeout((function() {\n                    method();\n                    loop();\n                }), time);\n            }());\n            var method, time;\n            if (\"object\" == typeof window) {\n                window.addEventListener(\"beforeunload\", (function() {\n                    immediateFlush();\n                }));\n                window.addEventListener(\"unload\", (function() {\n                    immediateFlush();\n                }));\n                window.addEventListener(\"pagehide\", (function() {\n                    immediateFlush();\n                }));\n            }\n            var logger = {\n                debug: function(event, payload) {\n                    return log(LOG_LEVEL.DEBUG, event, payload);\n                },\n                info: function(event, payload) {\n                    return log(LOG_LEVEL.INFO, event, payload);\n                },\n                warn: function(event, payload) {\n                    return log(LOG_LEVEL.WARN, event, payload);\n                },\n                error: function(event, payload) {\n                    return log(LOG_LEVEL.ERROR, event, payload);\n                },\n                track: function(payload) {\n                    void 0 === payload && (payload = {});\n                    if (!dom_isBrowser()) return logger;\n                    var trackingPayload = objFilter(payload, (function(value) {\n                        return null != value;\n                    }));\n                    for (var _i8 = 0; _i8 < trackingBuilders.length; _i8++) extendIfDefined(trackingPayload, (0, \n                    trackingBuilders[_i8])(trackingPayload));\n                    print(LOG_LEVEL.DEBUG, \"track\", trackingPayload);\n                    tracking.push(trackingPayload);\n                    return logger;\n                },\n                flush: flush,\n                immediateFlush: immediateFlush,\n                addPayloadBuilder: function(builder) {\n                    return addBuilder(payloadBuilders, builder);\n                },\n                addMetaBuilder: function(builder) {\n                    return addBuilder(metaBuilders, builder);\n                },\n                addTrackingBuilder: function(builder) {\n                    return addBuilder(trackingBuilders, builder);\n                },\n                addHeaderBuilder: function(builder) {\n                    return addBuilder(headerBuilders, builder);\n                },\n                setTransport: function(newTransport) {\n                    transport = newTransport;\n                    return logger;\n                },\n                configure: function(opts) {\n                    opts.url && (url = opts.url);\n                    opts.prefix && (prefix = opts.prefix);\n                    opts.logLevel && (logLevel = opts.logLevel);\n                    opts.transport && (transport = opts.transport);\n                    opts.amplitudeApiKey && (amplitudeApiKey = opts.amplitudeApiKey);\n                    opts.flushInterval && (flushInterval = opts.flushInterval);\n                    opts.enableSendBeacon && (enableSendBeacon = opts.enableSendBeacon);\n                    return logger;\n                }\n            };\n            return logger;\n        }\n    } ]);\n}));","/**\n * cssfilter\n *\n * @author 老雷<leizongmin@gmail.com>\n */\n\nvar DEFAULT = require('./default');\nvar parseStyle = require('./parser');\nvar _ = require('./util');\n\n\n/**\n * 返回值是否为空\n *\n * @param {Object} obj\n * @return {Boolean}\n */\nfunction isNull (obj) {\n  return (obj === undefined || obj === null);\n}\n\n/**\n * 浅拷贝对象\n *\n * @param {Object} obj\n * @return {Object}\n */\nfunction shallowCopyObject (obj) {\n  var ret = {};\n  for (var i in obj) {\n    ret[i] = obj[i];\n  }\n  return ret;\n}\n\n/**\n * 创建CSS过滤器\n *\n * @param {Object} options\n *   - {Object} whiteList\n *   - {Function} onAttr\n *   - {Function} onIgnoreAttr\n *   - {Function} safeAttrValue\n */\nfunction FilterCSS (options) {\n  options = shallowCopyObject(options || {});\n  options.whiteList = options.whiteList || DEFAULT.whiteList;\n  options.onAttr = options.onAttr || DEFAULT.onAttr;\n  options.onIgnoreAttr = options.onIgnoreAttr || DEFAULT.onIgnoreAttr;\n  options.safeAttrValue = options.safeAttrValue || DEFAULT.safeAttrValue;\n  this.options = options;\n}\n\nFilterCSS.prototype.process = function (css) {\n  // 兼容各种奇葩输入\n  css = css || '';\n  css = css.toString();\n  if (!css) return '';\n\n  var me = this;\n  var options = me.options;\n  var whiteList = options.whiteList;\n  var onAttr = options.onAttr;\n  var onIgnoreAttr = options.onIgnoreAttr;\n  var safeAttrValue = options.safeAttrValue;\n\n  var retCSS = parseStyle(css, function (sourcePosition, position, name, value, source) {\n\n    var check = whiteList[name];\n    var isWhite = false;\n    if (check === true) isWhite = check;\n    else if (typeof check === 'function') isWhite = check(value);\n    else if (check instanceof RegExp) isWhite = check.test(value);\n    if (isWhite !== true) isWhite = false;\n\n    // 如果过滤后 value 为空则直接忽略\n    value = safeAttrValue(name, value);\n    if (!value) return;\n\n    var opts = {\n      position: position,\n      sourcePosition: sourcePosition,\n      source: source,\n      isWhite: isWhite\n    };\n\n    if (isWhite) {\n\n      var ret = onAttr(name, value, opts);\n      if (isNull(ret)) {\n        return name + ':' + value;\n      } else {\n        return ret;\n      }\n\n    } else {\n\n      var ret = onIgnoreAttr(name, value, opts);\n      if (!isNull(ret)) {\n        return ret;\n      }\n\n    }\n  });\n\n  return retCSS;\n};\n\n\nmodule.exports = FilterCSS;\n","/**\n * cssfilter\n *\n * @author 老雷<leizongmin@gmail.com>\n */\n\nfunction getDefaultWhiteList () {\n  // 白名单值说明：\n  // true: 允许该属性\n  // Function: function (val) { } 返回true表示允许该属性，其他值均表示不允许\n  // RegExp: regexp.test(val) 返回true表示允许该属性，其他值均表示不允许\n  // 除上面列出的值外均表示不允许\n  var whiteList = {};\n\n  whiteList['align-content'] = false; // default: auto\n  whiteList['align-items'] = false; // default: auto\n  whiteList['align-self'] = false; // default: auto\n  whiteList['alignment-adjust'] = false; // default: auto\n  whiteList['alignment-baseline'] = false; // default: baseline\n  whiteList['all'] = false; // default: depending on individual properties\n  whiteList['anchor-point'] = false; // default: none\n  whiteList['animation'] = false; // default: depending on individual properties\n  whiteList['animation-delay'] = false; // default: 0\n  whiteList['animation-direction'] = false; // default: normal\n  whiteList['animation-duration'] = false; // default: 0\n  whiteList['animation-fill-mode'] = false; // default: none\n  whiteList['animation-iteration-count'] = false; // default: 1\n  whiteList['animation-name'] = false; // default: none\n  whiteList['animation-play-state'] = false; // default: running\n  whiteList['animation-timing-function'] = false; // default: ease\n  whiteList['azimuth'] = false; // default: center\n  whiteList['backface-visibility'] = false; // default: visible\n  whiteList['background'] = true; // default: depending on individual properties\n  whiteList['background-attachment'] = true; // default: scroll\n  whiteList['background-clip'] = true; // default: border-box\n  whiteList['background-color'] = true; // default: transparent\n  whiteList['background-image'] = true; // default: none\n  whiteList['background-origin'] = true; // default: padding-box\n  whiteList['background-position'] = true; // default: 0% 0%\n  whiteList['background-repeat'] = true; // default: repeat\n  whiteList['background-size'] = true; // default: auto\n  whiteList['baseline-shift'] = false; // default: baseline\n  whiteList['binding'] = false; // default: none\n  whiteList['bleed'] = false; // default: 6pt\n  whiteList['bookmark-label'] = false; // default: content()\n  whiteList['bookmark-level'] = false; // default: none\n  whiteList['bookmark-state'] = false; // default: open\n  whiteList['border'] = true; // default: depending on individual properties\n  whiteList['border-bottom'] = true; // default: depending on individual properties\n  whiteList['border-bottom-color'] = true; // default: current color\n  whiteList['border-bottom-left-radius'] = true; // default: 0\n  whiteList['border-bottom-right-radius'] = true; // default: 0\n  whiteList['border-bottom-style'] = true; // default: none\n  whiteList['border-bottom-width'] = true; // default: medium\n  whiteList['border-collapse'] = true; // default: separate\n  whiteList['border-color'] = true; // default: depending on individual properties\n  whiteList['border-image'] = true; // default: none\n  whiteList['border-image-outset'] = true; // default: 0\n  whiteList['border-image-repeat'] = true; // default: stretch\n  whiteList['border-image-slice'] = true; // default: 100%\n  whiteList['border-image-source'] = true; // default: none\n  whiteList['border-image-width'] = true; // default: 1\n  whiteList['border-left'] = true; // default: depending on individual properties\n  whiteList['border-left-color'] = true; // default: current color\n  whiteList['border-left-style'] = true; // default: none\n  whiteList['border-left-width'] = true; // default: medium\n  whiteList['border-radius'] = true; // default: 0\n  whiteList['border-right'] = true; // default: depending on individual properties\n  whiteList['border-right-color'] = true; // default: current color\n  whiteList['border-right-style'] = true; // default: none\n  whiteList['border-right-width'] = true; // default: medium\n  whiteList['border-spacing'] = true; // default: 0\n  whiteList['border-style'] = true; // default: depending on individual properties\n  whiteList['border-top'] = true; // default: depending on individual properties\n  whiteList['border-top-color'] = true; // default: current color\n  whiteList['border-top-left-radius'] = true; // default: 0\n  whiteList['border-top-right-radius'] = true; // default: 0\n  whiteList['border-top-style'] = true; // default: none\n  whiteList['border-top-width'] = true; // default: medium\n  whiteList['border-width'] = true; // default: depending on individual properties\n  whiteList['bottom'] = false; // default: auto\n  whiteList['box-decoration-break'] = true; // default: slice\n  whiteList['box-shadow'] = true; // default: none\n  whiteList['box-sizing'] = true; // default: content-box\n  whiteList['box-snap'] = true; // default: none\n  whiteList['box-suppress'] = true; // default: show\n  whiteList['break-after'] = true; // default: auto\n  whiteList['break-before'] = true; // default: auto\n  whiteList['break-inside'] = true; // default: auto\n  whiteList['caption-side'] = false; // default: top\n  whiteList['chains'] = false; // default: none\n  whiteList['clear'] = true; // default: none\n  whiteList['clip'] = false; // default: auto\n  whiteList['clip-path'] = false; // default: none\n  whiteList['clip-rule'] = false; // default: nonzero\n  whiteList['color'] = true; // default: implementation dependent\n  whiteList['color-interpolation-filters'] = true; // default: auto\n  whiteList['column-count'] = false; // default: auto\n  whiteList['column-fill'] = false; // default: balance\n  whiteList['column-gap'] = false; // default: normal\n  whiteList['column-rule'] = false; // default: depending on individual properties\n  whiteList['column-rule-color'] = false; // default: current color\n  whiteList['column-rule-style'] = false; // default: medium\n  whiteList['column-rule-width'] = false; // default: medium\n  whiteList['column-span'] = false; // default: none\n  whiteList['column-width'] = false; // default: auto\n  whiteList['columns'] = false; // default: depending on individual properties\n  whiteList['contain'] = false; // default: none\n  whiteList['content'] = false; // default: normal\n  whiteList['counter-increment'] = false; // default: none\n  whiteList['counter-reset'] = false; // default: none\n  whiteList['counter-set'] = false; // default: none\n  whiteList['crop'] = false; // default: auto\n  whiteList['cue'] = false; // default: depending on individual properties\n  whiteList['cue-after'] = false; // default: none\n  whiteList['cue-before'] = false; // default: none\n  whiteList['cursor'] = false; // default: auto\n  whiteList['direction'] = false; // default: ltr\n  whiteList['display'] = true; // default: depending on individual properties\n  whiteList['display-inside'] = true; // default: auto\n  whiteList['display-list'] = true; // default: none\n  whiteList['display-outside'] = true; // default: inline-level\n  whiteList['dominant-baseline'] = false; // default: auto\n  whiteList['elevation'] = false; // default: level\n  whiteList['empty-cells'] = false; // default: show\n  whiteList['filter'] = false; // default: none\n  whiteList['flex'] = false; // default: depending on individual properties\n  whiteList['flex-basis'] = false; // default: auto\n  whiteList['flex-direction'] = false; // default: row\n  whiteList['flex-flow'] = false; // default: depending on individual properties\n  whiteList['flex-grow'] = false; // default: 0\n  whiteList['flex-shrink'] = false; // default: 1\n  whiteList['flex-wrap'] = false; // default: nowrap\n  whiteList['float'] = false; // default: none\n  whiteList['float-offset'] = false; // default: 0 0\n  whiteList['flood-color'] = false; // default: black\n  whiteList['flood-opacity'] = false; // default: 1\n  whiteList['flow-from'] = false; // default: none\n  whiteList['flow-into'] = false; // default: none\n  whiteList['font'] = true; // default: depending on individual properties\n  whiteList['font-family'] = true; // default: implementation dependent\n  whiteList['font-feature-settings'] = true; // default: normal\n  whiteList['font-kerning'] = true; // default: auto\n  whiteList['font-language-override'] = true; // default: normal\n  whiteList['font-size'] = true; // default: medium\n  whiteList['font-size-adjust'] = true; // default: none\n  whiteList['font-stretch'] = true; // default: normal\n  whiteList['font-style'] = true; // default: normal\n  whiteList['font-synthesis'] = true; // default: weight style\n  whiteList['font-variant'] = true; // default: normal\n  whiteList['font-variant-alternates'] = true; // default: normal\n  whiteList['font-variant-caps'] = true; // default: normal\n  whiteList['font-variant-east-asian'] = true; // default: normal\n  whiteList['font-variant-ligatures'] = true; // default: normal\n  whiteList['font-variant-numeric'] = true; // default: normal\n  whiteList['font-variant-position'] = true; // default: normal\n  whiteList['font-weight'] = true; // default: normal\n  whiteList['grid'] = false; // default: depending on individual properties\n  whiteList['grid-area'] = false; // default: depending on individual properties\n  whiteList['grid-auto-columns'] = false; // default: auto\n  whiteList['grid-auto-flow'] = false; // default: none\n  whiteList['grid-auto-rows'] = false; // default: auto\n  whiteList['grid-column'] = false; // default: depending on individual properties\n  whiteList['grid-column-end'] = false; // default: auto\n  whiteList['grid-column-start'] = false; // default: auto\n  whiteList['grid-row'] = false; // default: depending on individual properties\n  whiteList['grid-row-end'] = false; // default: auto\n  whiteList['grid-row-start'] = false; // default: auto\n  whiteList['grid-template'] = false; // default: depending on individual properties\n  whiteList['grid-template-areas'] = false; // default: none\n  whiteList['grid-template-columns'] = false; // default: none\n  whiteList['grid-template-rows'] = false; // default: none\n  whiteList['hanging-punctuation'] = false; // default: none\n  whiteList['height'] = true; // default: auto\n  whiteList['hyphens'] = false; // default: manual\n  whiteList['icon'] = false; // default: auto\n  whiteList['image-orientation'] = false; // default: auto\n  whiteList['image-resolution'] = false; // default: normal\n  whiteList['ime-mode'] = false; // default: auto\n  whiteList['initial-letters'] = false; // default: normal\n  whiteList['inline-box-align'] = false; // default: last\n  whiteList['justify-content'] = false; // default: auto\n  whiteList['justify-items'] = false; // default: auto\n  whiteList['justify-self'] = false; // default: auto\n  whiteList['left'] = false; // default: auto\n  whiteList['letter-spacing'] = true; // default: normal\n  whiteList['lighting-color'] = true; // default: white\n  whiteList['line-box-contain'] = false; // default: block inline replaced\n  whiteList['line-break'] = false; // default: auto\n  whiteList['line-grid'] = false; // default: match-parent\n  whiteList['line-height'] = false; // default: normal\n  whiteList['line-snap'] = false; // default: none\n  whiteList['line-stacking'] = false; // default: depending on individual properties\n  whiteList['line-stacking-ruby'] = false; // default: exclude-ruby\n  whiteList['line-stacking-shift'] = false; // default: consider-shifts\n  whiteList['line-stacking-strategy'] = false; // default: inline-line-height\n  whiteList['list-style'] = true; // default: depending on individual properties\n  whiteList['list-style-image'] = true; // default: none\n  whiteList['list-style-position'] = true; // default: outside\n  whiteList['list-style-type'] = true; // default: disc\n  whiteList['margin'] = true; // default: depending on individual properties\n  whiteList['margin-bottom'] = true; // default: 0\n  whiteList['margin-left'] = true; // default: 0\n  whiteList['margin-right'] = true; // default: 0\n  whiteList['margin-top'] = true; // default: 0\n  whiteList['marker-offset'] = false; // default: auto\n  whiteList['marker-side'] = false; // default: list-item\n  whiteList['marks'] = false; // default: none\n  whiteList['mask'] = false; // default: border-box\n  whiteList['mask-box'] = false; // default: see individual properties\n  whiteList['mask-box-outset'] = false; // default: 0\n  whiteList['mask-box-repeat'] = false; // default: stretch\n  whiteList['mask-box-slice'] = false; // default: 0 fill\n  whiteList['mask-box-source'] = false; // default: none\n  whiteList['mask-box-width'] = false; // default: auto\n  whiteList['mask-clip'] = false; // default: border-box\n  whiteList['mask-image'] = false; // default: none\n  whiteList['mask-origin'] = false; // default: border-box\n  whiteList['mask-position'] = false; // default: center\n  whiteList['mask-repeat'] = false; // default: no-repeat\n  whiteList['mask-size'] = false; // default: border-box\n  whiteList['mask-source-type'] = false; // default: auto\n  whiteList['mask-type'] = false; // default: luminance\n  whiteList['max-height'] = true; // default: none\n  whiteList['max-lines'] = false; // default: none\n  whiteList['max-width'] = true; // default: none\n  whiteList['min-height'] = true; // default: 0\n  whiteList['min-width'] = true; // default: 0\n  whiteList['move-to'] = false; // default: normal\n  whiteList['nav-down'] = false; // default: auto\n  whiteList['nav-index'] = false; // default: auto\n  whiteList['nav-left'] = false; // default: auto\n  whiteList['nav-right'] = false; // default: auto\n  whiteList['nav-up'] = false; // default: auto\n  whiteList['object-fit'] = false; // default: fill\n  whiteList['object-position'] = false; // default: 50% 50%\n  whiteList['opacity'] = false; // default: 1\n  whiteList['order'] = false; // default: 0\n  whiteList['orphans'] = false; // default: 2\n  whiteList['outline'] = false; // default: depending on individual properties\n  whiteList['outline-color'] = false; // default: invert\n  whiteList['outline-offset'] = false; // default: 0\n  whiteList['outline-style'] = false; // default: none\n  whiteList['outline-width'] = false; // default: medium\n  whiteList['overflow'] = false; // default: depending on individual properties\n  whiteList['overflow-wrap'] = false; // default: normal\n  whiteList['overflow-x'] = false; // default: visible\n  whiteList['overflow-y'] = false; // default: visible\n  whiteList['padding'] = true; // default: depending on individual properties\n  whiteList['padding-bottom'] = true; // default: 0\n  whiteList['padding-left'] = true; // default: 0\n  whiteList['padding-right'] = true; // default: 0\n  whiteList['padding-top'] = true; // default: 0\n  whiteList['page'] = false; // default: auto\n  whiteList['page-break-after'] = false; // default: auto\n  whiteList['page-break-before'] = false; // default: auto\n  whiteList['page-break-inside'] = false; // default: auto\n  whiteList['page-policy'] = false; // default: start\n  whiteList['pause'] = false; // default: implementation dependent\n  whiteList['pause-after'] = false; // default: implementation dependent\n  whiteList['pause-before'] = false; // default: implementation dependent\n  whiteList['perspective'] = false; // default: none\n  whiteList['perspective-origin'] = false; // default: 50% 50%\n  whiteList['pitch'] = false; // default: medium\n  whiteList['pitch-range'] = false; // default: 50\n  whiteList['play-during'] = false; // default: auto\n  whiteList['position'] = false; // default: static\n  whiteList['presentation-level'] = false; // default: 0\n  whiteList['quotes'] = false; // default: text\n  whiteList['region-fragment'] = false; // default: auto\n  whiteList['resize'] = false; // default: none\n  whiteList['rest'] = false; // default: depending on individual properties\n  whiteList['rest-after'] = false; // default: none\n  whiteList['rest-before'] = false; // default: none\n  whiteList['richness'] = false; // default: 50\n  whiteList['right'] = false; // default: auto\n  whiteList['rotation'] = false; // default: 0\n  whiteList['rotation-point'] = false; // default: 50% 50%\n  whiteList['ruby-align'] = false; // default: auto\n  whiteList['ruby-merge'] = false; // default: separate\n  whiteList['ruby-position'] = false; // default: before\n  whiteList['shape-image-threshold'] = false; // default: 0.0\n  whiteList['shape-outside'] = false; // default: none\n  whiteList['shape-margin'] = false; // default: 0\n  whiteList['size'] = false; // default: auto\n  whiteList['speak'] = false; // default: auto\n  whiteList['speak-as'] = false; // default: normal\n  whiteList['speak-header'] = false; // default: once\n  whiteList['speak-numeral'] = false; // default: continuous\n  whiteList['speak-punctuation'] = false; // default: none\n  whiteList['speech-rate'] = false; // default: medium\n  whiteList['stress'] = false; // default: 50\n  whiteList['string-set'] = false; // default: none\n  whiteList['tab-size'] = false; // default: 8\n  whiteList['table-layout'] = false; // default: auto\n  whiteList['text-align'] = true; // default: start\n  whiteList['text-align-last'] = true; // default: auto\n  whiteList['text-combine-upright'] = true; // default: none\n  whiteList['text-decoration'] = true; // default: none\n  whiteList['text-decoration-color'] = true; // default: currentColor\n  whiteList['text-decoration-line'] = true; // default: none\n  whiteList['text-decoration-skip'] = true; // default: objects\n  whiteList['text-decoration-style'] = true; // default: solid\n  whiteList['text-emphasis'] = true; // default: depending on individual properties\n  whiteList['text-emphasis-color'] = true; // default: currentColor\n  whiteList['text-emphasis-position'] = true; // default: over right\n  whiteList['text-emphasis-style'] = true; // default: none\n  whiteList['text-height'] = true; // default: auto\n  whiteList['text-indent'] = true; // default: 0\n  whiteList['text-justify'] = true; // default: auto\n  whiteList['text-orientation'] = true; // default: mixed\n  whiteList['text-overflow'] = true; // default: clip\n  whiteList['text-shadow'] = true; // default: none\n  whiteList['text-space-collapse'] = true; // default: collapse\n  whiteList['text-transform'] = true; // default: none\n  whiteList['text-underline-position'] = true; // default: auto\n  whiteList['text-wrap'] = true; // default: normal\n  whiteList['top'] = false; // default: auto\n  whiteList['transform'] = false; // default: none\n  whiteList['transform-origin'] = false; // default: 50% 50% 0\n  whiteList['transform-style'] = false; // default: flat\n  whiteList['transition'] = false; // default: depending on individual properties\n  whiteList['transition-delay'] = false; // default: 0s\n  whiteList['transition-duration'] = false; // default: 0s\n  whiteList['transition-property'] = false; // default: all\n  whiteList['transition-timing-function'] = false; // default: ease\n  whiteList['unicode-bidi'] = false; // default: normal\n  whiteList['vertical-align'] = false; // default: baseline\n  whiteList['visibility'] = false; // default: visible\n  whiteList['voice-balance'] = false; // default: center\n  whiteList['voice-duration'] = false; // default: auto\n  whiteList['voice-family'] = false; // default: implementation dependent\n  whiteList['voice-pitch'] = false; // default: medium\n  whiteList['voice-range'] = false; // default: medium\n  whiteList['voice-rate'] = false; // default: normal\n  whiteList['voice-stress'] = false; // default: normal\n  whiteList['voice-volume'] = false; // default: medium\n  whiteList['volume'] = false; // default: medium\n  whiteList['white-space'] = false; // default: normal\n  whiteList['widows'] = false; // default: 2\n  whiteList['width'] = true; // default: auto\n  whiteList['will-change'] = false; // default: auto\n  whiteList['word-break'] = true; // default: normal\n  whiteList['word-spacing'] = true; // default: normal\n  whiteList['word-wrap'] = true; // default: normal\n  whiteList['wrap-flow'] = false; // default: auto\n  whiteList['wrap-through'] = false; // default: wrap\n  whiteList['writing-mode'] = false; // default: horizontal-tb\n  whiteList['z-index'] = false; // default: auto\n\n  return whiteList;\n}\n\n\n/**\n * 匹配到白名单上的一个属性时\n *\n * @param {String} name\n * @param {String} value\n * @param {Object} options\n * @return {String}\n */\nfunction onAttr (name, value, options) {\n  // do nothing\n}\n\n/**\n * 匹配到不在白名单上的一个属性时\n *\n * @param {String} name\n * @param {String} value\n * @param {Object} options\n * @return {String}\n */\nfunction onIgnoreAttr (name, value, options) {\n  // do nothing\n}\n\nvar REGEXP_URL_JAVASCRIPT = /javascript\\s*\\:/img;\n\n/**\n * 过滤属性值\n *\n * @param {String} name\n * @param {String} value\n * @return {String}\n */\nfunction safeAttrValue(name, value) {\n  if (REGEXP_URL_JAVASCRIPT.test(value)) return '';\n  return value;\n}\n\n\nexports.whiteList = getDefaultWhiteList();\nexports.getDefaultWhiteList = getDefaultWhiteList;\nexports.onAttr = onAttr;\nexports.onIgnoreAttr = onIgnoreAttr;\nexports.safeAttrValue = safeAttrValue;\n","/**\n * cssfilter\n *\n * @author 老雷<leizongmin@gmail.com>\n */\n\nvar DEFAULT = require('./default');\nvar FilterCSS = require('./css');\n\n\n/**\n * XSS过滤\n *\n * @param {String} css 要过滤的CSS代码\n * @param {Object} options 选项：whiteList, onAttr, onIgnoreAttr\n * @return {String}\n */\nfunction filterCSS (html, options) {\n  var xss = new FilterCSS(options);\n  return xss.process(html);\n}\n\n\n// 输出\nexports = module.exports = filterCSS;\nexports.FilterCSS = FilterCSS;\nfor (var i in DEFAULT) exports[i] = DEFAULT[i];\n\n// 在浏览器端使用\nif (typeof window !== 'undefined') {\n  window.filterCSS = module.exports;\n}\n","/**\n * cssfilter\n *\n * @author 老雷<leizongmin@gmail.com>\n */\n\nvar _ = require('./util');\n\n\n/**\n * 解析style\n *\n * @param {String} css\n * @param {Function} onAttr 处理属性的函数\n *   参数格式： function (sourcePosition, position, name, value, source)\n * @return {String}\n */\nfunction parseStyle (css, onAttr) {\n  css = _.trimRight(css);\n  if (css[css.length - 1] !== ';') css += ';';\n  var cssLength = css.length;\n  var isParenthesisOpen = false;\n  var lastPos = 0;\n  var i = 0;\n  var retCSS = '';\n\n  function addNewAttr () {\n    // 如果没有正常的闭合圆括号，则直接忽略当前属性\n    if (!isParenthesisOpen) {\n      var source = _.trim(css.slice(lastPos, i));\n      var j = source.indexOf(':');\n      if (j !== -1) {\n        var name = _.trim(source.slice(0, j));\n        var value = _.trim(source.slice(j + 1));\n        // 必须有属性名称\n        if (name) {\n          var ret = onAttr(lastPos, retCSS.length, name, value, source);\n          if (ret) retCSS += ret + '; ';\n        }\n      }\n    }\n    lastPos = i + 1;\n  }\n\n  for (; i < cssLength; i++) {\n    var c = css[i];\n    if (c === '/' && css[i + 1] === '*') {\n      // 备注开始\n      var j = css.indexOf('*/', i + 2);\n      // 如果没有正常的备注结束，则后面的部分全部跳过\n      if (j === -1) break;\n      // 直接将当前位置调到备注结尾，并且初始化状态\n      i = j + 1;\n      lastPos = i + 1;\n      isParenthesisOpen = false;\n    } else if (c === '(') {\n      isParenthesisOpen = true;\n    } else if (c === ')') {\n      isParenthesisOpen = false;\n    } else if (c === ';') {\n      if (isParenthesisOpen) {\n        // 在圆括号里面，忽略\n      } else {\n        addNewAttr();\n      }\n    } else if (c === '\\n') {\n      addNewAttr();\n    }\n  }\n\n  return _.trim(retCSS);\n}\n\nmodule.exports = parseStyle;\n","module.exports = {\n  indexOf: function (arr, item) {\n    var i, j;\n    if (Array.prototype.indexOf) {\n      return arr.indexOf(item);\n    }\n    for (i = 0, j = arr.length; i < j; i++) {\n      if (arr[i] === item) {\n        return i;\n      }\n    }\n    return -1;\n  },\n  forEach: function (arr, fn, scope) {\n    var i, j;\n    if (Array.prototype.forEach) {\n      return arr.forEach(fn, scope);\n    }\n    for (i = 0, j = arr.length; i < j; i++) {\n      fn.call(scope, arr[i], i, arr);\n    }\n  },\n  trim: function (str) {\n    if (String.prototype.trim) {\n      return str.trim();\n    }\n    return str.replace(/(^\\s*)|(\\s*$)/g, '');\n  },\n  trimRight: function (str) {\n    if (String.prototype.trimRight) {\n      return str.trimRight();\n    }\n    return str.replace(/(\\s*$)/g, '');\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.T\n * @example\n *\n *      R.F(); //=> false\n */\nvar F = function () {\n  return false;\n};\n\nmodule.exports = F;","/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig * -> Boolean\n * @param {*}\n * @return {Boolean}\n * @see R.F\n * @example\n *\n *      R.T(); //=> true\n */\nvar T = function () {\n  return true;\n};\n\nmodule.exports = T;","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments, regardless of\n * their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are\n * equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @name __\n * @constant\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @example\n *\n *      const greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nmodule.exports = {\n  '@@functional/placeholder': true\n};","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Adds two values.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a\n * @param {Number} b\n * @return {Number}\n * @see R.subtract\n * @example\n *\n *      R.add(2, 3);       //=>  5\n *      R.add(7)(10);      //=> 17\n */\n\n\nvar add =\n/*#__PURE__*/\n_curry2(function add(a, b) {\n  return Number(a) + Number(b);\n});\n\nmodule.exports = add;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n/**\n * Creates a new list iteration function from an existing one by adding two new\n * parameters to its callback function: the current index, and the entire list.\n *\n * This would turn, for instance, [`R.map`](#map) function into one that\n * more closely resembles `Array.prototype.map`. Note that this will only work\n * for functions in which the iteration callback function is the first\n * parameter, and where the list is the last parameter. (This latter might be\n * unimportant if the list parameter is not used.)\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Function\n * @category List\n * @sig (((a ...) -> b) ... -> [a] -> *) -> (((a ..., Int, [a]) -> b) ... -> [a] -> *)\n * @param {Function} fn A list iteration function that does not pass index or list to its callback\n * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n * @example\n *\n *      const mapIndexed = R.addIndex(R.map);\n *      mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);\n *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n */\n\n\nvar addIndex =\n/*#__PURE__*/\n_curry1(function addIndex(fn) {\n  return curryN(fn.length, function () {\n    var idx = 0;\n    var origFn = arguments[0];\n    var list = arguments[arguments.length - 1];\n    var args = Array.prototype.slice.call(arguments, 0);\n\n    args[0] = function () {\n      var result = origFn.apply(this, _concat(arguments, [idx, list]));\n      idx += 1;\n      return result;\n    };\n\n    return fn.apply(this, args);\n  });\n});\n\nmodule.exports = addIndex;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Applies a function to the value at the given index of an array, returning a\n * new copy of the array with the element at the given index replaced with the\n * result of the function application.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig Number -> (a -> a) -> [a] -> [a]\n * @param {Number} idx The index.\n * @param {Function} fn The function to apply.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @see R.update\n * @example\n *\n *      R.adjust(1, R.toUpper, ['a', 'b', 'c', 'd']);      //=> ['a', 'B', 'c', 'd']\n *      R.adjust(-1, R.toUpper, ['a', 'b', 'c', 'd']);     //=> ['a', 'b', 'c', 'D']\n * @symb R.adjust(-1, f, [a, b]) = [a, f(b)]\n * @symb R.adjust(0, f, [a, b]) = [f(a), b]\n */\n\n\nvar adjust =\n/*#__PURE__*/\n_curry3(function adjust(idx, fn, list) {\n  var len = list.length;\n\n  if (idx >= len || idx < -len) {\n    return list;\n  }\n\n  var _idx = (len + idx) % len;\n\n  var _list = _concat(list);\n\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\n\nmodule.exports = adjust;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xall =\n/*#__PURE__*/\nrequire(\"./internal/_xall.js\");\n/**\n * Returns `true` if all elements of the list match the predicate, `false` if\n * there are any that don't.\n *\n * Dispatches to the `all` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is satisfied by every element, `false`\n *         otherwise.\n * @see R.any, R.none, R.transduce\n * @example\n *\n *      const equals3 = R.equals(3);\n *      R.all(equals3)([3, 3, 3, 3]); //=> true\n *      R.all(equals3)([3, 3, 1, 3]); //=> false\n */\n\n\nvar all =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['all'], _xall, function all(fn, list) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (!fn(list[idx])) {\n      return false;\n    }\n\n    idx += 1;\n  }\n\n  return true;\n}));\n\nmodule.exports = all;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar max =\n/*#__PURE__*/\nrequire(\"./max.js\");\n\nvar pluck =\n/*#__PURE__*/\nrequire(\"./pluck.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n/**\n * Takes a list of predicates and returns a predicate that returns true for a\n * given list of arguments if every one of the provided predicates is satisfied\n * by those arguments.\n *\n * The function returned is a curried function whose arity matches that of the\n * highest-arity predicate.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Logic\n * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n * @param {Array} predicates An array of predicates to check\n * @return {Function} The combined predicate\n * @see R.anyPass\n * @example\n *\n *      const isQueen = R.propEq('rank', 'Q');\n *      const isSpade = R.propEq('suit', '♠︎');\n *      const isQueenOfSpades = R.allPass([isQueen, isSpade]);\n *\n *      isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false\n *      isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true\n */\n\n\nvar allPass =\n/*#__PURE__*/\n_curry1(function allPass(preds) {\n  return curryN(reduce(max, 0, pluck('length', preds)), function () {\n    var idx = 0;\n    var len = preds.length;\n\n    while (idx < len) {\n      if (!preds[idx].apply(this, arguments)) {\n        return false;\n      }\n\n      idx += 1;\n    }\n\n    return true;\n  });\n});\n\nmodule.exports = allPass;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator) in\n * other languages and libraries.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      const t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\n\n\nvar always =\n/*#__PURE__*/\n_curry1(function always(val) {\n  return function () {\n    return val;\n  };\n});\n\nmodule.exports = always;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns the first argument if it is falsy, otherwise the second argument.\n * Acts as the boolean `and` statement if both inputs are `Boolean`s.\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}\n * @see R.both, R.or\n * @example\n *\n *      R.and(true, true); //=> true\n *      R.and(true, false); //=> false\n *      R.and(false, true); //=> false\n *      R.and(false, false); //=> false\n */\n\n\nvar and =\n/*#__PURE__*/\n_curry2(function and(a, b) {\n  return a && b;\n});\n\nmodule.exports = and;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _assertPromise =\n/*#__PURE__*/\nrequire(\"./internal/_assertPromise.js\");\n/**\n * Returns the result of applying the onSuccess function to the value inside\n * a successfully resolved promise. This is useful for working with promises\n * inside function compositions.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Function\n * @sig (a -> b) -> (Promise e a) -> (Promise e b)\n * @sig (a -> (Promise e b)) -> (Promise e a) -> (Promise e b)\n * @param {Function} onSuccess The function to apply. Can return a value or a promise of a value.\n * @param {Promise} p\n * @return {Promise} The result of calling `p.then(onSuccess)`\n * @see R.otherwise\n * @example\n *\n *      const makeQuery = email => ({ query: { email }});\n *      const fetchMember = request =>\n *        Promise.resolve({ firstName: 'Bob', lastName: 'Loblaw', id: 42 });\n *\n *      //getMemberName :: String -> Promise ({ firstName, lastName })\n *      const getMemberName = R.pipe(\n *        makeQuery,\n *        fetchMember,\n *        R.andThen(R.pick(['firstName', 'lastName']))\n *      );\n *\n *      getMemberName('bob@gmail.com').then(console.log);\n */\n\n\nvar andThen =\n/*#__PURE__*/\n_curry2(function andThen(f, p) {\n  _assertPromise('andThen', p);\n\n  return p.then(f);\n});\n\nmodule.exports = andThen;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xany =\n/*#__PURE__*/\nrequire(\"./internal/_xany.js\");\n/**\n * Returns `true` if at least one of the elements of the list match the predicate,\n * `false` otherwise.\n *\n * Dispatches to the `any` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`\n *         otherwise.\n * @see R.all, R.none, R.transduce\n * @example\n *\n *      const lessThan0 = R.flip(R.lt)(0);\n *      const lessThan2 = R.flip(R.lt)(2);\n *      R.any(lessThan0)([1, 2]); //=> false\n *      R.any(lessThan2)([1, 2]); //=> true\n */\n\n\nvar any =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['any'], _xany, function any(fn, list) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (fn(list[idx])) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n}));\n\nmodule.exports = any;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar max =\n/*#__PURE__*/\nrequire(\"./max.js\");\n\nvar pluck =\n/*#__PURE__*/\nrequire(\"./pluck.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n/**\n * Takes a list of predicates and returns a predicate that returns true for a\n * given list of arguments if at least one of the provided predicates is\n * satisfied by those arguments.\n *\n * The function returned is a curried function whose arity matches that of the\n * highest-arity predicate.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Logic\n * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n * @param {Array} predicates An array of predicates to check\n * @return {Function} The combined predicate\n * @see R.allPass\n * @example\n *\n *      const isClub = R.propEq('suit', '♣');\n *      const isSpade = R.propEq('suit', '♠');\n *      const isBlackCard = R.anyPass([isClub, isSpade]);\n *\n *      isBlackCard({rank: '10', suit: '♣'}); //=> true\n *      isBlackCard({rank: 'Q', suit: '♠'}); //=> true\n *      isBlackCard({rank: 'Q', suit: '♦'}); //=> false\n */\n\n\nvar anyPass =\n/*#__PURE__*/\n_curry1(function anyPass(preds) {\n  return curryN(reduce(max, 0, pluck('length', preds)), function () {\n    var idx = 0;\n    var len = preds.length;\n\n    while (idx < len) {\n      if (preds[idx].apply(this, arguments)) {\n        return true;\n      }\n\n      idx += 1;\n    }\n\n    return false;\n  });\n});\n\nmodule.exports = anyPass;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n/**\n * ap applies a list of functions to a list of values.\n *\n * Dispatches to the `ap` method of the second argument, if present. Also\n * treats curried functions as applicatives.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig [a -> b] -> [a] -> [b]\n * @sig Apply f => f (a -> b) -> f a -> f b\n * @sig (r -> a -> b) -> (r -> a) -> (r -> b)\n * @param {*} applyF\n * @param {*} applyX\n * @return {*}\n * @example\n *\n *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n *      R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> [\"tasty pizza\", \"tasty salad\", \"PIZZA\", \"SALAD\"]\n *\n *      // R.ap can also be used as S combinator\n *      // when only two functions are passed\n *      R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'\n * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]\n */\n\n\nvar ap =\n/*#__PURE__*/\n_curry2(function ap(applyF, applyX) {\n  return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {\n    return applyF(x)(applyX(x));\n  } : _reduce(function (acc, f) {\n    return _concat(acc, map(f, applyX));\n  }, [], applyF);\n});\n\nmodule.exports = ap;","var _aperture =\n/*#__PURE__*/\nrequire(\"./internal/_aperture.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xaperture =\n/*#__PURE__*/\nrequire(\"./internal/_xaperture.js\");\n/**\n * Returns a new list, composed of n-tuples of consecutive elements. If `n` is\n * greater than the length of the list, an empty list is returned.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig Number -> [a] -> [[a]]\n * @param {Number} n The size of the tuples to create\n * @param {Array} list The list to split into `n`-length tuples\n * @return {Array} The resulting list of `n`-length tuples\n * @see R.transduce\n * @example\n *\n *      R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]\n *      R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]\n *      R.aperture(7, [1, 2, 3, 4, 5]); //=> []\n */\n\n\nvar aperture =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xaperture, _aperture));\n\nmodule.exports = aperture;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns a new list containing the contents of the given list, followed by\n * the given element.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The element to add to the end of the new list.\n * @param {Array} list The list of elements to add a new item to.\n *        list.\n * @return {Array} A new list containing the elements of the old list followed by `el`.\n * @see R.prepend\n * @example\n *\n *      R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']\n *      R.append('tests', []); //=> ['tests']\n *      R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]\n */\n\n\nvar append =\n/*#__PURE__*/\n_curry2(function append(el, list) {\n  return _concat(list, [el]);\n});\n\nmodule.exports = append;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Applies function `fn` to the argument list `args`. This is useful for\n * creating a fixed-arity function from a variadic function. `fn` should be a\n * bound function if context is significant.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig (*... -> a) -> [*] -> a\n * @param {Function} fn The function which will be called with `args`\n * @param {Array} args The arguments to call `fn` with\n * @return {*} result The result, equivalent to `fn(...args)`\n * @see R.call, R.unapply\n * @example\n *\n *      const nums = [1, 2, 3, -99, 42, 6, 7];\n *      R.apply(Math.max, nums); //=> 42\n * @symb R.apply(f, [a, b, c]) = f(a, b, c)\n */\n\n\nvar apply =\n/*#__PURE__*/\n_curry2(function apply(fn, args) {\n  return fn.apply(this, args);\n});\n\nmodule.exports = apply;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar apply =\n/*#__PURE__*/\nrequire(\"./apply.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar max =\n/*#__PURE__*/\nrequire(\"./max.js\");\n\nvar pluck =\n/*#__PURE__*/\nrequire(\"./pluck.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n\nvar values =\n/*#__PURE__*/\nrequire(\"./values.js\"); // Use custom mapValues function to avoid issues with specs that include a \"map\" key and R.map\n// delegating calls to .map\n\n\nfunction mapValues(fn, obj) {\n  return _isArray(obj) ? obj.map(fn) : keys(obj).reduce(function (acc, key) {\n    acc[key] = fn(obj[key]);\n    return acc;\n  }, {});\n}\n/**\n * Given a spec object recursively mapping properties to functions, creates a\n * function producing an object of the same structure, by mapping each property\n * to the result of calling its associated function with the supplied arguments.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Function\n * @sig {k: ((a, b, ..., m) -> v)} -> ((a, b, ..., m) -> {k: v})\n * @param {Object} spec an object recursively mapping properties to functions for\n *        producing the values for these properties.\n * @return {Function} A function that returns an object of the same structure\n * as `spec', with each property set to the value returned by calling its\n * associated function with the supplied arguments.\n * @see R.converge, R.juxt\n * @example\n *\n *      const getMetrics = R.applySpec({\n *        sum: R.add,\n *        nested: { mul: R.multiply }\n *      });\n *      getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } }\n * @symb R.applySpec({ x: f, y: { z: g } })(a, b) = { x: f(a, b), y: { z: g(a, b) } }\n */\n\n\nvar applySpec =\n/*#__PURE__*/\n_curry1(function applySpec(spec) {\n  spec = mapValues(function (v) {\n    return typeof v == 'function' ? v : applySpec(v);\n  }, spec);\n  return curryN(reduce(max, 0, pluck('length', values(spec))), function () {\n    var args = arguments;\n    return mapValues(function (f) {\n      return apply(f, args);\n    }, spec);\n  });\n});\n\nmodule.exports = applySpec;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Takes a value and applies a function to it.\n *\n * This function is also known as the `thrush` combinator.\n *\n * @func\n * @memberOf R\n * @since v0.25.0\n * @category Function\n * @sig a -> (a -> b) -> b\n * @param {*} x The value\n * @param {Function} f The function to apply\n * @return {*} The result of applying `f` to `x`\n * @example\n *\n *      const t42 = R.applyTo(42);\n *      t42(R.identity); //=> 42\n *      t42(R.add(1)); //=> 43\n */\n\n\nvar applyTo =\n/*#__PURE__*/\n_curry2(function applyTo(x, f) {\n  return f(x);\n});\n\nmodule.exports = applyTo;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Makes an ascending comparator function out of a function that returns a value\n * that can be compared with `<` and `>`.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Function\n * @sig Ord b => (a -> b) -> a -> a -> Number\n * @param {Function} fn A function of arity one that returns a value that can be compared\n * @param {*} a The first item to be compared.\n * @param {*} b The second item to be compared.\n * @return {Number} `-1` if fn(a) < fn(b), `1` if fn(b) < fn(a), otherwise `0`\n * @see R.descend\n * @example\n *\n *      const byAge = R.ascend(R.prop('age'));\n *      const people = [\n *        { name: 'Emma', age: 70 },\n *        { name: 'Peter', age: 78 },\n *        { name: 'Mikhail', age: 62 },\n *      ];\n *      const peopleByYoungestFirst = R.sort(byAge, people);\n *        //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]\n */\n\n\nvar ascend =\n/*#__PURE__*/\n_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\nmodule.exports = ascend;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar assocPath =\n/*#__PURE__*/\nrequire(\"./assocPath.js\");\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value. Note that this copies and flattens prototype\n * properties onto the new object as well. All non-primitive properties are\n * copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig Idx -> a -> {k: v} -> {k: v}\n * @param {String|Number} prop The property name to set\n * @param {*} val The new value\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original except for the changed property.\n * @see R.dissoc, R.pick\n * @example\n *\n *      R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}\n */\n\n\nvar assoc =\n/*#__PURE__*/\n_curry3(function assoc(prop, val, obj) {\n  return assocPath([prop], val, obj);\n});\n\nmodule.exports = assoc;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n\nvar _isInteger =\n/*#__PURE__*/\nrequire(\"./internal/_isInteger.js\");\n\nvar _assoc =\n/*#__PURE__*/\nrequire(\"./internal/_assoc.js\");\n\nvar isNil =\n/*#__PURE__*/\nrequire(\"./isNil.js\");\n/**\n * Makes a shallow clone of an object, setting or overriding the nodes required\n * to create the given path, and placing the specific value at the tail end of\n * that path. Note that this copies and flattens prototype properties onto the\n * new object as well. All non-primitive properties are copied by reference.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @typedefn Idx = String | Int | Symbol\n * @sig [Idx] -> a -> {a} -> {a}\n * @param {Array} path the path to set\n * @param {*} val The new value\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original except along the specified path.\n * @see R.dissocPath\n * @example\n *\n *      R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}\n *\n *      // Any missing or non-object keys in path will be overridden\n *      R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}\n */\n\n\nvar assocPath =\n/*#__PURE__*/\n_curry3(function assocPath(path, val, obj) {\n  if (path.length === 0) {\n    return val;\n  }\n\n  var idx = path[0];\n\n  if (path.length > 1) {\n    var nextObj = !isNil(obj) && _has(idx, obj) ? obj[idx] : _isInteger(path[1]) ? [] : {};\n    val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);\n  }\n\n  return _assoc(idx, val, obj);\n});\n\nmodule.exports = assocPath;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar nAry =\n/*#__PURE__*/\nrequire(\"./nAry.js\");\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly 2 parameters. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Function\n * @sig (a -> b -> c -> ... -> z) -> ((a, b) -> z)\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n *         arity 2.\n * @see R.nAry, R.unary\n * @example\n *\n *      const takesThreeArgs = function(a, b, c) {\n *        return [a, b, c];\n *      };\n *      takesThreeArgs.length; //=> 3\n *      takesThreeArgs(1, 2, 3); //=> [1, 2, 3]\n *\n *      const takesTwoArgs = R.binary(takesThreeArgs);\n *      takesTwoArgs.length; //=> 2\n *      // Only 2 arguments are passed to the wrapped function\n *      takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]\n * @symb R.binary(f)(a, b, c) = f(a, b)\n */\n\n\nvar binary =\n/*#__PURE__*/\n_curry1(function binary(fn) {\n  return nAry(2, fn);\n});\n\nmodule.exports = binary;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @category Object\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n * @see R.partial\n * @example\n *\n *      const log = R.bind(console.log, console);\n *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}\n *      // logs {a: 2}\n * @symb R.bind(f, o)(a, b) = f.call(o, a, b)\n */\n\n\nvar bind =\n/*#__PURE__*/\n_curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function () {\n    return fn.apply(thisObj, arguments);\n  });\n});\n\nmodule.exports = bind;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isFunction =\n/*#__PURE__*/\nrequire(\"./internal/_isFunction.js\");\n\nvar and =\n/*#__PURE__*/\nrequire(\"./and.js\");\n\nvar lift =\n/*#__PURE__*/\nrequire(\"./lift.js\");\n/**\n * A function which calls the two provided functions and returns the `&&`\n * of the results.\n * It returns the result of the first function if it is false-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * false-y value.\n *\n * In addition to functions, `R.both` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f A predicate\n * @param {Function} g Another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.\n * @see R.either, R.and\n * @example\n *\n *      const gt10 = R.gt(R.__, 10)\n *      const lt20 = R.lt(R.__, 20)\n *      const f = R.both(gt10, lt20);\n *      f(15); //=> true\n *      f(30); //=> false\n *\n *      R.both(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(false)\n *      R.both([false, false, 'a'], [11]); //=> [false, false, 11]\n */\n\n\nvar both =\n/*#__PURE__*/\n_curry2(function both(f, g) {\n  return _isFunction(f) ? function _both() {\n    return f.apply(this, arguments) && g.apply(this, arguments);\n  } : lift(and)(f, g);\n});\n\nmodule.exports = both;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Returns the result of calling its first argument with the remaining\n * arguments. This is occasionally useful as a converging function for\n * [`R.converge`](#converge): the first branch can produce a function while the\n * remaining branches produce values to be passed to that function as its\n * arguments.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig ((*... -> a), *...) -> a\n * @param {Function} fn The function to apply to the remaining arguments.\n * @param {...*} args Any number of positional arguments.\n * @return {*}\n * @see R.apply\n * @example\n *\n *      R.call(R.add, 1, 2); //=> 3\n *\n *      const indentN = R.pipe(\n *        R.repeat(' '),\n *        R.join(''),\n *        R.replace(/^(?!$)/gm)\n *      );\n *\n *      const format = R.converge(\n *        R.call,\n *        [\n *          R.pipe(R.prop('indent'), indentN),\n *          R.prop('value')\n *        ]\n *      );\n *\n *      format({indent: 2, value: 'foo\\nbar\\nbaz\\n'}); //=> '  foo\\n  bar\\n  baz\\n'\n * @symb R.call(f, a, b) = f(a, b)\n */\n\n\nvar call =\n/*#__PURE__*/\n_curry1(function call(fn) {\n  return fn.apply(this, Array.prototype.slice.call(arguments, 1));\n});\n\nmodule.exports = call;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _makeFlat =\n/*#__PURE__*/\nrequire(\"./internal/_makeFlat.js\");\n\nvar _xchain =\n/*#__PURE__*/\nrequire(\"./internal/_xchain.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n/**\n * `chain` maps a function over a list and concatenates the results. `chain`\n * is also known as `flatMap` in some libraries.\n *\n * Dispatches to the `chain` method of the second argument, if present,\n * according to the [FantasyLand Chain spec](https://github.com/fantasyland/fantasy-land#chain).\n *\n * If second argument is a function, `chain(f, g)(x)` is equivalent to `f(g(x), x)`.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig Chain m => (a -> m b) -> m a -> m b\n * @param {Function} fn The function to map with\n * @param {Array} list The list to map over\n * @return {Array} The result of flat-mapping `list` with `fn`\n * @example\n *\n *      const duplicate = n => [n, n];\n *      R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]\n *\n *      R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1]\n */\n\n\nvar chain =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/chain', 'chain'], _xchain, function chain(fn, monad) {\n  if (typeof monad === 'function') {\n    return function (x) {\n      return fn(monad(x))(x);\n    };\n  }\n\n  return _makeFlat(false)(map(fn, monad));\n}));\n\nmodule.exports = chain;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Restricts a number to be within a range.\n *\n * Also works for other ordered types such as Strings and Dates.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Relation\n * @sig Ord a => a -> a -> a -> a\n * @param {Number} minimum The lower limit of the clamp (inclusive)\n * @param {Number} maximum The upper limit of the clamp (inclusive)\n * @param {Number} value Value to be clamped\n * @return {Number} Returns `minimum` when `val < minimum`, `maximum` when `val > maximum`, returns `val` otherwise\n * @example\n *\n *      R.clamp(1, 10, -5) // => 1\n *      R.clamp(1, 10, 15) // => 10\n *      R.clamp(1, 10, 4)  // => 4\n */\n\n\nvar clamp =\n/*#__PURE__*/\n_curry3(function clamp(min, max, value) {\n  if (min > max) {\n    throw new Error('min must not be greater than max in clamp(min, max, value)');\n  }\n\n  return value < min ? min : value > max ? max : value;\n});\n\nmodule.exports = clamp;","var _clone =\n/*#__PURE__*/\nrequire(\"./internal/_clone.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Creates a deep copy of the source that can be used in place of the source\n * object without retaining any references to it.\n * The source object may contain (nested) `Array`s and `Object`s,\n * `Number`s, `String`s, `Boolean`s and `Date`s.\n * `Function`s are assigned by reference rather than copied.\n *\n * Dispatches to a `clone` method if present.\n *\n * Note that if the source object has multiple nodes that share a reference,\n * the returned object will have the same structure, but the references will\n * be pointed to the location within the cloned value.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {*} -> {*}\n * @param {*} value The object or array to clone\n * @return {*} A deeply cloned copy of `val`\n * @example\n *\n *      const objects = [{}, {}, {}];\n *      const objectsClone = R.clone(objects);\n *      objects === objectsClone; //=> false\n *      objects[0] === objectsClone[0]; //=> false\n */\n\n\nvar clone =\n/*#__PURE__*/\n_curry1(function clone(value) {\n  return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], [], true);\n});\n\nmodule.exports = clone;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n/**\n * Splits a list into sub-lists, based on the result of calling a key-returning function on each element,\n * and grouping the results according to values returned.\n *\n * @func\n * @memberOf R\n * @since v0.28.0\n * @category List\n * @typedefn Idx = String | Int | Symbol\n * @sig Idx a => (b -> a) -> [b] -> [[b]]\n * @param {Function} fn Function :: a -> Idx\n * @param {Array} list The array to group\n * @return {Array}\n *    An array of arrays where each sub-array contains items for which\n *    the String-returning function has returned the same value.\n * @see R.groupBy, R.partition\n * @example\n *      R.collectBy(R.prop('type'), [\n *        {type: 'breakfast', item: '☕️'},\n *        {type: 'lunch', item: '🌯'},\n *        {type: 'dinner', item: '🍝'},\n *        {type: 'breakfast', item: '🥐'},\n *        {type: 'lunch', item: '🍕'}\n *      ]);\n *\n *      // [ [ {type: 'breakfast', item: '☕️'},\n *      //     {type: 'breakfast', item: '🥐'} ],\n *      //   [ {type: 'lunch', item: '🌯'},\n *      //     {type: 'lunch', item: '🍕'} ],\n *      //   [ {type: 'dinner', item: '🍝'} ] ]\n */\n\n\nvar collectBy =\n/*#__PURE__*/\n_curry2(function collectBy(fn, list) {\n  var group = _reduce(function (o, x) {\n    var tag = fn(x);\n\n    if (o[tag] === undefined) {\n      o[tag] = [];\n    }\n\n    o[tag].push(x);\n    return o;\n  }, {}, list);\n\n  var newList = [];\n\n  for (var tag in group) {\n    newList.push(group[tag]);\n  }\n\n  return newList;\n});\n\nmodule.exports = collectBy;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Makes a comparator function out of a function that reports whether the first\n * element is less than the second.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((a, b) -> Boolean) -> ((a, b) -> Number)\n * @param {Function} pred A predicate function of arity two which will return `true` if the first argument\n * is less than the second, `false` otherwise\n * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`\n * @example\n *\n *      const byAge = R.comparator((a, b) => a.age < b.age);\n *      const people = [\n *        { name: 'Emma', age: 70 },\n *        { name: 'Peter', age: 78 },\n *        { name: 'Mikhail', age: 62 },\n *      ];\n *      const peopleByIncreasingAge = R.sort(byAge, people);\n *        //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }]\n */\n\n\nvar comparator =\n/*#__PURE__*/\n_curry1(function comparator(pred) {\n  return function (a, b) {\n    return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;\n  };\n});\n\nmodule.exports = comparator;","var lift =\n/*#__PURE__*/\nrequire(\"./lift.js\");\n\nvar not =\n/*#__PURE__*/\nrequire(\"./not.js\");\n/**\n * Takes a function `f` and returns a function `g` such that if called with the same arguments\n * when `f` returns a \"truthy\" value, `g` returns `false` and when `f` returns a \"falsy\" value `g` returns `true`.\n *\n * `R.complement` may be applied to any functor\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> *) -> (*... -> Boolean)\n * @param {Function} f\n * @return {Function}\n * @see R.not\n * @example\n *\n *      const isNotNil = R.complement(R.isNil);\n *      R.isNil(null); //=> true\n *      isNotNil(null); //=> false\n *      R.isNil(7); //=> false\n *      isNotNil(7); //=> true\n */\n\n\nvar complement =\n/*#__PURE__*/\nlift(not);\nmodule.exports = complement;","var pipe =\n/*#__PURE__*/\nrequire(\"./pipe.js\");\n\nvar reverse =\n/*#__PURE__*/\nrequire(\"./reverse.js\");\n/**\n * Performs right-to-left function composition. The last argument may have\n * any arity; the remaining arguments must be unary.\n *\n * **Note:** The result of compose is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)\n * @param {...Function} ...functions The functions to compose\n * @return {Function}\n * @see R.pipe\n * @example\n *\n *      const classyGreeting = (firstName, lastName) => \"The name's \" + lastName + \", \" + firstName + \" \" + lastName\n *      const yellGreeting = R.compose(R.toUpper, classyGreeting);\n *      yellGreeting('James', 'Bond'); //=> \"THE NAME'S BOND, JAMES BOND\"\n *\n *      R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7\n *\n * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))\n * @symb R.compose(f, g, h)(a)(b) = f(g(h(a)))(b)\n */\n\n\nfunction compose() {\n  if (arguments.length === 0) {\n    throw new Error('compose requires at least one argument');\n  }\n\n  return pipe.apply(this, reverse(arguments));\n}\n\nmodule.exports = compose;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar pipeWith =\n/*#__PURE__*/\nrequire(\"./pipeWith.js\");\n\nvar reverse =\n/*#__PURE__*/\nrequire(\"./reverse.js\");\n/**\n * Performs right-to-left function composition using transforming function. The last function may have\n * any arity; the remaining functions must be unary.\n *\n * **Note:** The result of composeWith is not automatically curried. Transforming function is not used\n * on the last argument.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig ((* -> *), [(y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)]) -> ((a, b, ..., n) -> z)\n * @param {Function} transformer The transforming function\n * @param {Array} functions The functions to compose\n * @return {Function}\n * @see R.compose, R.pipeWith\n * @example\n *\n *      const composeWhileNotNil = R.composeWith((f, res) => R.isNil(res) ? res : f(res));\n *\n *      composeWhileNotNil([R.inc, R.prop('age')])({age: 1}) //=> 2\n *      composeWhileNotNil([R.inc, R.prop('age')])({}) //=> undefined\n *\n * @symb R.composeWith(f)([g, h, i])(...args) = f(g, f(h, i(...args)))\n */\n\n\nvar composeWith =\n/*#__PURE__*/\n_curry2(function composeWith(xf, list) {\n  return pipeWith.apply(this, [xf, reverse(list)]);\n});\n\nmodule.exports = composeWith;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar _isFunction =\n/*#__PURE__*/\nrequire(\"./internal/_isFunction.js\");\n\nvar _isString =\n/*#__PURE__*/\nrequire(\"./internal/_isString.js\");\n\nvar toString =\n/*#__PURE__*/\nrequire(\"./toString.js\");\n/**\n * Returns the result of concatenating the given lists or strings.\n *\n * Note: `R.concat` expects both arguments to be of the same type,\n * unlike the native `Array.prototype.concat` method. It will throw\n * an error if you `concat` an Array with a non-Array value.\n *\n * Dispatches to the `concat` method of the first argument, if present.\n * Can also concatenate two members of a [fantasy-land\n * compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a] -> [a]\n * @sig String -> String -> String\n * @param {Array|String} firstList The first list\n * @param {Array|String} secondList The second list\n * @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of\n * `secondList`.\n *\n * @example\n *\n *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n *      R.concat([], []); //=> []\n */\n\n\nvar concat =\n/*#__PURE__*/\n_curry2(function concat(a, b) {\n  if (_isArray(a)) {\n    if (_isArray(b)) {\n      return a.concat(b);\n    }\n\n    throw new TypeError(toString(b) + ' is not an array');\n  }\n\n  if (_isString(a)) {\n    if (_isString(b)) {\n      return a + b;\n    }\n\n    throw new TypeError(toString(b) + ' is not a string');\n  }\n\n  if (a != null && _isFunction(a['fantasy-land/concat'])) {\n    return a['fantasy-land/concat'](b);\n  }\n\n  if (a != null && _isFunction(a.concat)) {\n    return a.concat(b);\n  }\n\n  throw new TypeError(toString(a) + ' does not have a method named \"concat\" or \"fantasy-land/concat\"');\n});\n\nmodule.exports = concat;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n\nvar max =\n/*#__PURE__*/\nrequire(\"./max.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n/**\n * Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic.\n * `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments\n * to `fn` are applied to each of the predicates in turn until one returns a\n * \"truthy\" value, at which point `fn` returns the result of applying its\n * arguments to the corresponding transformer. If none of the predicates\n * matches, `fn` returns undefined.\n *\n * **Please note**: This is not a direct substitute for a `switch` statement.\n * Remember that both elements of every pair passed to `cond` are *functions*,\n * and `cond` returns a function.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Logic\n * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n * @param {Array} pairs A list of [predicate, transformer]\n * @return {Function}\n * @see R.ifElse, R.unless, R.when\n * @example\n *\n *      const fn = R.cond([\n *        [R.equals(0),   R.always('water freezes at 0°C')],\n *        [R.equals(100), R.always('water boils at 100°C')],\n *        [R.T,           temp => 'nothing special happens at ' + temp + '°C']\n *      ]);\n *      fn(0); //=> 'water freezes at 0°C'\n *      fn(50); //=> 'nothing special happens at 50°C'\n *      fn(100); //=> 'water boils at 100°C'\n */\n\n\nvar cond =\n/*#__PURE__*/\n_curry1(function cond(pairs) {\n  var arity = reduce(max, 0, map(function (pair) {\n    return pair[0].length;\n  }, pairs));\n  return _arity(arity, function () {\n    var idx = 0;\n\n    while (idx < pairs.length) {\n      if (pairs[idx][0].apply(this, arguments)) {\n        return pairs[idx][1].apply(this, arguments);\n      }\n\n      idx += 1;\n    }\n  });\n});\n\nmodule.exports = cond;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar constructN =\n/*#__PURE__*/\nrequire(\"./constructN.js\");\n/**\n * Wraps a constructor function inside a curried function that can be called\n * with the same arguments and returns the same type.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (* -> {*}) -> (* -> {*})\n * @param {Function} fn The constructor function to wrap.\n * @return {Function} A wrapped, curried constructor function.\n * @see R.invoker\n * @example\n *\n *      // Constructor function\n *      function Animal(kind) {\n *        this.kind = kind;\n *      };\n *      Animal.prototype.sighting = function() {\n *        return \"It's a \" + this.kind + \"!\";\n *      }\n *\n *      const AnimalConstructor = R.construct(Animal)\n *\n *      // Notice we no longer need the 'new' keyword:\n *      AnimalConstructor('Pig'); //=> {\"kind\": \"Pig\", \"sighting\": function (){...}};\n *\n *      const animalTypes = [\"Lion\", \"Tiger\", \"Bear\"];\n *      const animalSighting = R.invoker(0, 'sighting');\n *      const sightNewAnimal = R.compose(animalSighting, AnimalConstructor);\n *      R.map(sightNewAnimal, animalTypes); //=> [\"It's a Lion!\", \"It's a Tiger!\", \"It's a Bear!\"]\n */\n\n\nvar construct =\n/*#__PURE__*/\n_curry1(function construct(Fn) {\n  return constructN(Fn.length, Fn);\n});\n\nmodule.exports = construct;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar curry =\n/*#__PURE__*/\nrequire(\"./curry.js\");\n\nvar nAry =\n/*#__PURE__*/\nrequire(\"./nAry.js\");\n/**\n * Wraps a constructor function inside a curried function that can be called\n * with the same arguments and returns the same type. The arity of the function\n * returned is specified to allow using variadic constructor functions.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Function\n * @sig Number -> (* -> {*}) -> (* -> {*})\n * @param {Number} n The arity of the constructor function.\n * @param {Function} Fn The constructor function to wrap.\n * @return {Function} A wrapped, curried constructor function.\n * @example\n *\n *      // Variadic Constructor function\n *      function Salad() {\n *        this.ingredients = arguments;\n *      }\n *\n *      Salad.prototype.recipe = function() {\n *        const instructions = R.map(ingredient => 'Add a dollop of ' + ingredient, this.ingredients);\n *        return R.join('\\n', instructions);\n *      };\n *\n *      const ThreeLayerSalad = R.constructN(3, Salad);\n *\n *      // Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments.\n *      const salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup');\n *\n *      console.log(salad.recipe());\n *      // Add a dollop of Mayonnaise\n *      // Add a dollop of Potato Chips\n *      // Add a dollop of Ketchup\n */\n\n\nvar constructN =\n/*#__PURE__*/\n_curry2(function constructN(n, Fn) {\n  if (n > 10) {\n    throw new Error('Constructor with greater than ten arguments');\n  }\n\n  if (n === 0) {\n    return function () {\n      return new Fn();\n    };\n  }\n\n  return curry(nAry(n, function ($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {\n    switch (arguments.length) {\n      case 1:\n        return new Fn($0);\n\n      case 2:\n        return new Fn($0, $1);\n\n      case 3:\n        return new Fn($0, $1, $2);\n\n      case 4:\n        return new Fn($0, $1, $2, $3);\n\n      case 5:\n        return new Fn($0, $1, $2, $3, $4);\n\n      case 6:\n        return new Fn($0, $1, $2, $3, $4, $5);\n\n      case 7:\n        return new Fn($0, $1, $2, $3, $4, $5, $6);\n\n      case 8:\n        return new Fn($0, $1, $2, $3, $4, $5, $6, $7);\n\n      case 9:\n        return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);\n\n      case 10:\n        return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);\n    }\n  }));\n});\n\nmodule.exports = constructN;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _map =\n/*#__PURE__*/\nrequire(\"./internal/_map.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar max =\n/*#__PURE__*/\nrequire(\"./max.js\");\n\nvar pluck =\n/*#__PURE__*/\nrequire(\"./pluck.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n/**\n * Accepts a converging function and a list of branching functions and returns\n * a new function. The arity of the new function is the same as the arity of\n * the longest branching function. When invoked, this new function is applied\n * to some arguments, and each branching function is applied to those same\n * arguments. The results of each branching function are passed as arguments\n * to the converging function to produce the return value.\n *\n * @func\n * @memberOf R\n * @since v0.4.2\n * @category Function\n * @sig ((x1, x2, ...) -> z) -> [((a, b, ...) -> x1), ((a, b, ...) -> x2), ...] -> (a -> b -> ... -> z)\n * @param {Function} after A function. `after` will be invoked with the return values of\n *        `fn1` and `fn2` as its arguments.\n * @param {Array} functions A list of functions.\n * @return {Function} A new function.\n * @see R.useWith\n * @example\n *\n *      const average = R.converge(R.divide, [R.sum, R.length])\n *      average([1, 2, 3, 4, 5, 6, 7]) //=> 4\n *\n *      const strangeConcat = R.converge(R.concat, [R.toUpper, R.toLower])\n *      strangeConcat(\"Yodel\") //=> \"YODELyodel\"\n *\n * @symb R.converge(f, [g, h])(a, b) = f(g(a, b), h(a, b))\n */\n\n\nvar converge =\n/*#__PURE__*/\n_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\nmodule.exports = converge;","var _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar curry =\n/*#__PURE__*/\nrequire(\"./curry.js\");\n/**\n * Returns the number of items in a given `list` matching the predicate `f`\n *\n * @func\n * @memberOf R\n * @since v0.28.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> Number\n * @param {Function} predicate to match items against\n * @return {Array} list of items to count in\n * @example\n *\n *      const even = x => x % 2 == 0;\n *\n *      R.count(even, [1, 2, 3, 4, 5]); // => 2\n *      R.map(R.count(even), [[1, 1, 1], [2, 3, 4, 5], [6]]); // => [0, 2, 1]\n */\n\n\nvar count =\n/*#__PURE__*/\ncurry(function (pred, list) {\n  return _reduce(function (a, e) {\n    return pred(e) ? a + 1 : a;\n  }, 0, list);\n});\nmodule.exports = count;","var reduceBy =\n/*#__PURE__*/\nrequire(\"./reduceBy.js\");\n/**\n * Counts the elements of a list according to how many match each value of a\n * key generated by the supplied function. Returns an object mapping the keys\n * produced by `fn` to the number of occurrences in the list. Note that all\n * keys are coerced to strings because of how JavaScript objects work.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig (a -> String) -> [a] -> {*}\n * @param {Function} fn The function used to map values to keys.\n * @param {Array} list The list to count elements from.\n * @return {Object} An object mapping keys to number of occurrences in the list.\n * @example\n *\n *      const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];\n *      R.countBy(Math.floor)(numbers);    //=> {'1': 3, '2': 2, '3': 1}\n *\n *      const letters = ['a', 'b', 'A', 'a', 'B', 'c'];\n *      R.countBy(R.toLower)(letters);   //=> {'a': 3, 'b': 2, 'c': 1}\n */\n\n\nvar countBy =\n/*#__PURE__*/\nreduceBy(function (acc, elem) {\n  return acc + 1;\n}, 0);\nmodule.exports = countBy;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n/**\n * Returns a curried equivalent of the provided function. The curried function\n * has two unusual capabilities. First, its arguments needn't be provided one\n * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (* -> a) -> (* -> a)\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curryN, R.partial\n * @example\n *\n *      const addFourNumbers = (a, b, c, d) => a + b + c + d;\n *\n *      const curriedAddFourNumbers = R.curry(addFourNumbers);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\n\nvar curry =\n/*#__PURE__*/\n_curry1(function curry(fn) {\n  return curryN(fn.length, fn);\n});\n\nmodule.exports = curry;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _curryN =\n/*#__PURE__*/\nrequire(\"./internal/_curryN.js\");\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      const sumArgs = (...args) => R.sum(args);\n *\n *      const curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\n\nvar curryN =\n/*#__PURE__*/\n_curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n\n  return _arity(length, _curryN(length, [], fn));\n});\n\nmodule.exports = curryN;","var add =\n/*#__PURE__*/\nrequire(\"./add.js\");\n/**\n * Decrements its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number} n - 1\n * @see R.inc\n * @example\n *\n *      R.dec(42); //=> 41\n */\n\n\nvar dec =\n/*#__PURE__*/\nadd(-1);\nmodule.exports = dec;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns the second argument if it is not `null`, `undefined` or `NaN`;\n * otherwise the first argument is returned.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {a} default The default value.\n * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.\n * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value\n * @example\n *\n *      const defaultTo42 = R.defaultTo(42);\n *\n *      defaultTo42(null);  //=> 42\n *      defaultTo42(undefined);  //=> 42\n *      defaultTo42(false);  //=> false\n *      defaultTo42('Ramda');  //=> 'Ramda'\n *      // parseInt('string') results in NaN\n *      defaultTo42(parseInt('string')); //=> 42\n */\n\n\nvar defaultTo =\n/*#__PURE__*/\n_curry2(function defaultTo(d, v) {\n  return v == null || v !== v ? d : v;\n});\n\nmodule.exports = defaultTo;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Makes a descending comparator function out of a function that returns a value\n * that can be compared with `<` and `>`.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Function\n * @sig Ord b => (a -> b) -> a -> a -> Number\n * @param {Function} fn A function of arity one that returns a value that can be compared\n * @param {*} a The first item to be compared.\n * @param {*} b The second item to be compared.\n * @return {Number} `-1` if fn(a) > fn(b), `1` if fn(b) > fn(a), otherwise `0`\n * @see R.ascend\n * @example\n *\n *      const byAge = R.descend(R.prop('age'));\n *      const people = [\n *        { name: 'Emma', age: 70 },\n *        { name: 'Peter', age: 78 },\n *        { name: 'Mikhail', age: 62 },\n *      ];\n *      const peopleByOldestFirst = R.sort(byAge, people);\n *        //=> [{ name: 'Peter', age: 78 }, { name: 'Emma', age: 70 }, { name: 'Mikhail', age: 62 }]\n */\n\n\nvar descend =\n/*#__PURE__*/\n_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\nmodule.exports = descend;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _Set =\n/*#__PURE__*/\nrequire(\"./internal/_Set.js\");\n/**\n * Finds the set (i.e. no duplicates) of all elements in the first list not\n * contained in the second list. Objects and Arrays are compared in terms of\n * value equality, not reference equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` that are not in `list2`.\n * @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith, R.without\n * @example\n *\n *      R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]\n *      R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]\n *      R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]\n */\n\n\nvar difference =\n/*#__PURE__*/\n_curry2(function difference(first, second) {\n  var out = [];\n  var idx = 0;\n  var firstLen = first.length;\n  var secondLen = second.length;\n  var toFilterOut = new _Set();\n\n  for (var i = 0; i < secondLen; i += 1) {\n    toFilterOut.add(second[i]);\n  }\n\n  while (idx < firstLen) {\n    if (toFilterOut.add(first[idx])) {\n      out[out.length] = first[idx];\n    }\n\n    idx += 1;\n  }\n\n  return out;\n});\n\nmodule.exports = difference;","var _includesWith =\n/*#__PURE__*/\nrequire(\"./internal/_includesWith.js\");\n\nvar _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Finds the set (i.e. no duplicates) of all elements in the first list not\n * contained in the second list. Duplication is determined according to the\n * value returned by applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` that are not in `list2`.\n * @see R.difference, R.symmetricDifference, R.symmetricDifferenceWith\n * @example\n *\n *      const cmp = (x, y) => x.a === y.a;\n *      const l1 = [{a: 1}, {a: 2}, {a: 3}];\n *      const l2 = [{a: 3}, {a: 4}];\n *      R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]\n */\n\n\nvar differenceWith =\n/*#__PURE__*/\n_curry3(function differenceWith(pred, first, second) {\n  var out = [];\n  var idx = 0;\n  var firstLen = first.length;\n\n  while (idx < firstLen) {\n    if (!_includesWith(pred, first[idx], second) && !_includesWith(pred, first[idx], out)) {\n      out.push(first[idx]);\n    }\n\n    idx += 1;\n  }\n\n  return out;\n});\n\nmodule.exports = differenceWith;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar dissocPath =\n/*#__PURE__*/\nrequire(\"./dissocPath.js\");\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Object\n * @sig String -> {k: v} -> {k: v}\n * @param {String} prop The name of the property to dissociate\n * @param {Object} obj The object to clone\n * @return {Object} A new object equivalent to the original but without the specified property\n * @see R.assoc, R.omit\n * @example\n *\n *      R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}\n */\n\n\nvar dissoc =\n/*#__PURE__*/\n_curry2(function dissoc(prop, obj) {\n  return dissocPath([prop], obj);\n});\n\nmodule.exports = dissoc;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dissoc =\n/*#__PURE__*/\nrequire(\"./internal/_dissoc.js\");\n\nvar _isInteger =\n/*#__PURE__*/\nrequire(\"./internal/_isInteger.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar assoc =\n/*#__PURE__*/\nrequire(\"./assoc.js\");\n/**\n * Makes a shallow clone of an object. Note that this copies and flattens\n * prototype properties onto the new object as well. All non-primitive\n * properties are copied by reference.\n *\n * @private\n * @param {String|Integer} prop The prop operating\n * @param {Object|Array} obj The object to clone\n * @return {Object|Array} A new object equivalent to the original.\n */\n\n\nfunction _shallowCloneObject(prop, obj) {\n  if (_isInteger(prop) && _isArray(obj)) {\n    return [].concat(obj);\n  }\n\n  var result = {};\n\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n\n  return result;\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 | Symbol\n * @sig [Idx] -> {k: v} -> {k: v}\n * @param {Array} path The path to the value to omit\n * @param {Object} obj The object to clone\n * @return {Object} A new object without the property at path\n * @see R.assocPath\n * @example\n *\n *      R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}\n */\n\n\nvar dissocPath =\n/*#__PURE__*/\n_curry2(function dissocPath(path, obj) {\n  if (obj == null) {\n    return obj;\n  }\n\n  switch (path.length) {\n    case 0:\n      return obj;\n\n    case 1:\n      return _dissoc(path[0], obj);\n\n    default:\n      var head = path[0];\n      var tail = Array.prototype.slice.call(path, 1);\n\n      if (obj[head] == null) {\n        return _shallowCloneObject(head, obj);\n      } else {\n        return assoc(head, dissocPath(tail, obj[head]), obj);\n      }\n\n  }\n});\n\nmodule.exports = dissocPath;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Divides two numbers. Equivalent to `a / b`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a / b`.\n * @see R.multiply\n * @example\n *\n *      R.divide(71, 100); //=> 0.71\n *\n *      const half = R.divide(R.__, 2);\n *      half(42); //=> 21\n *\n *      const reciprocal = R.divide(1);\n *      reciprocal(4);   //=> 0.25\n */\n\n\nvar divide =\n/*#__PURE__*/\n_curry2(function divide(a, b) {\n  return a / b;\n});\n\nmodule.exports = divide;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xdrop =\n/*#__PURE__*/\nrequire(\"./internal/_xdrop.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Returns all but the first `n` elements of the given list, string, or\n * transducer/transformer (or object with a `drop` method).\n *\n * Dispatches to the `drop` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n\n * @param {*} list\n * @return {*} A copy of list without the first `n` elements\n * @see R.take, R.transduce, R.dropLast, R.dropWhile\n * @example\n *\n *      R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n *      R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']\n *      R.drop(3, ['foo', 'bar', 'baz']); //=> []\n *      R.drop(4, ['foo', 'bar', 'baz']); //=> []\n *      R.drop(3, 'ramda');               //=> 'da'\n */\n\n\nvar drop =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['drop'], _xdrop, function drop(n, xs) {\n  return slice(Math.max(0, n), Infinity, xs);\n}));\n\nmodule.exports = drop;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _dropLast =\n/*#__PURE__*/\nrequire(\"./internal/_dropLast.js\");\n\nvar _xdropLast =\n/*#__PURE__*/\nrequire(\"./internal/_xdropLast.js\");\n/**\n * Returns a list containing all but the last `n` elements of the given `list`.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n The number of elements of `list` to skip.\n * @param {Array} list The list of elements to consider.\n * @return {Array} A copy of the list with only the first `list.length - n` elements\n * @see R.takeLast, R.drop, R.dropWhile, R.dropLastWhile\n * @example\n *\n *      R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n *      R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']\n *      R.dropLast(3, ['foo', 'bar', 'baz']); //=> []\n *      R.dropLast(4, ['foo', 'bar', 'baz']); //=> []\n *      R.dropLast(3, 'ramda');               //=> 'ra'\n */\n\n\nvar dropLast =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xdropLast, _dropLast));\n\nmodule.exports = dropLast;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _dropLastWhile =\n/*#__PURE__*/\nrequire(\"./internal/_dropLastWhile.js\");\n\nvar _xdropLastWhile =\n/*#__PURE__*/\nrequire(\"./internal/_xdropLastWhile.js\");\n/**\n * Returns a new list excluding all the tailing elements of a given list which\n * satisfy the supplied predicate function. It passes each value from the right\n * to the supplied predicate function, skipping elements until the predicate\n * function returns a `falsy` value. The predicate function is applied to one argument:\n * *(value)*.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} predicate The function to be called on each element\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array without any trailing elements that return `falsy` values from the `predicate`.\n * @see R.takeLastWhile, R.addIndex, R.drop, R.dropWhile\n * @example\n *\n *      const lteThree = x => x <= 3;\n *\n *      R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]\n *\n *      R.dropLastWhile(x => x !== 'd' , 'Ramda'); //=> 'Ramd'\n */\n\n\nvar dropLastWhile =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xdropLastWhile, _dropLastWhile));\n\nmodule.exports = dropLastWhile;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xdropRepeatsWith =\n/*#__PURE__*/\nrequire(\"./internal/_xdropRepeatsWith.js\");\n\nvar dropRepeatsWith =\n/*#__PURE__*/\nrequire(\"./dropRepeatsWith.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n/**\n * Returns a new list without any consecutively repeating elements.\n * [`R.equals`](#equals) is used to determine equality.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The array to consider.\n * @return {Array} `list` without repeating elements.\n * @see R.transduce\n * @example\n *\n *     R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]\n */\n\n\nvar dropRepeats =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_dispatchable([],\n/*#__PURE__*/\n_xdropRepeatsWith(equals),\n/*#__PURE__*/\ndropRepeatsWith(equals)));\n\nmodule.exports = dropRepeats;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xdropRepeatsWith =\n/*#__PURE__*/\nrequire(\"./internal/_xdropRepeatsWith.js\");\n\nvar last =\n/*#__PURE__*/\nrequire(\"./last.js\");\n/**\n * Returns a new list without any consecutively repeating elements. Equality is\n * determined by applying the supplied predicate to each pair of consecutive elements. The\n * first element in a series of equal elements will be preserved.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig ((a, a) -> Boolean) -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list The array to consider.\n * @return {Array} `list` without repeating elements.\n * @see R.transduce\n * @example\n *\n *      const l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];\n *      R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]\n */\n\n\nvar dropRepeatsWith =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xdropRepeatsWith, function dropRepeatsWith(pred, list) {\n  var result = [];\n  var idx = 1;\n  var len = list.length;\n\n  if (len !== 0) {\n    result[0] = list[0];\n\n    while (idx < len) {\n      if (!pred(last(result), list[idx])) {\n        result[result.length] = list[idx];\n      }\n\n      idx += 1;\n    }\n  }\n\n  return result;\n}));\n\nmodule.exports = dropRepeatsWith;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xdropWhile =\n/*#__PURE__*/\nrequire(\"./internal/_xdropWhile.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Returns a new list excluding the leading elements of a given list which\n * satisfy the supplied predicate function. It passes each value to the supplied\n * predicate function, skipping elements while the predicate function returns\n * `true`. The predicate function is applied to one argument: *(value)*.\n *\n * Dispatches to the `dropWhile` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.takeWhile, R.transduce, R.addIndex\n * @example\n *\n *      const lteTwo = x => x <= 2;\n *\n *      R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]\n *\n *      R.dropWhile(x => x !== 'd' , 'Ramda'); //=> 'da'\n */\n\n\nvar dropWhile =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['dropWhile'], _xdropWhile, function dropWhile(pred, xs) {\n  var idx = 0;\n  var len = xs.length;\n\n  while (idx < len && pred(xs[idx])) {\n    idx += 1;\n  }\n\n  return slice(idx, Infinity, xs);\n}));\n\nmodule.exports = dropWhile;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isFunction =\n/*#__PURE__*/\nrequire(\"./internal/_isFunction.js\");\n\nvar lift =\n/*#__PURE__*/\nrequire(\"./lift.js\");\n\nvar or =\n/*#__PURE__*/\nrequire(\"./or.js\");\n/**\n * A function wrapping calls to the two functions in an `||` operation,\n * returning the result of the first function if it is truth-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * truth-y value.\n *\n * In addition to functions, `R.either` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f a predicate\n * @param {Function} g another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n * @see R.both, R.or\n * @example\n *\n *      const gt10 = x => x > 10;\n *      const even = x => x % 2 === 0;\n *      const f = R.either(gt10, even);\n *      f(101); //=> true\n *      f(8); //=> true\n *\n *      R.either(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(55)\n *      R.either([false, false, 'a'], [11]) // => [11, 11, \"a\"]\n */\n\n\nvar either =\n/*#__PURE__*/\n_curry2(function either(f, g) {\n  return _isFunction(f) ? function _either() {\n    return f.apply(this, arguments) || g.apply(this, arguments);\n  } : lift(or)(f, g);\n});\n\nmodule.exports = either;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _isArguments =\n/*#__PURE__*/\nrequire(\"./internal/_isArguments.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar _isObject =\n/*#__PURE__*/\nrequire(\"./internal/_isObject.js\");\n\nvar _isString =\n/*#__PURE__*/\nrequire(\"./internal/_isString.js\");\n\nvar _isTypedArray =\n/*#__PURE__*/\nrequire(\"./internal/_isTypedArray.js\");\n/**\n * Returns the empty value of its argument's type. Ramda defines the empty\n * value of Array (`[]`), Object (`{}`), String (`''`),\n * TypedArray (`Uint8Array []`, `Float32Array []`, etc), and Arguments. Other\n * types are supported if they define `<Type>.empty`,\n * `<Type>.prototype.empty` or implement the\n * [FantasyLand Monoid spec](https://github.com/fantasyland/fantasy-land#monoid).\n *\n * Dispatches to the `empty` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig a -> a\n * @param {*} x\n * @return {*}\n * @example\n *\n *      R.empty(Just(42));               //=> Nothing()\n *      R.empty([1, 2, 3]);              //=> []\n *      R.empty('unicorns');             //=> ''\n *      R.empty({x: 1, y: 2});           //=> {}\n *      R.empty(Uint8Array.from('123')); //=> Uint8Array []\n */\n\n\nvar empty =\n/*#__PURE__*/\n_curry1(function empty(x) {\n  return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {\n    return arguments;\n  }() : _isTypedArray(x) ? x.constructor.from('') : void 0 // else\n  ;\n});\n\nmodule.exports = empty;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n\nvar takeLast =\n/*#__PURE__*/\nrequire(\"./takeLast.js\");\n/**\n * Checks if a list ends with the provided sublist.\n *\n * Similarly, checks if a string ends with the provided substring.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> [a] -> Boolean\n * @sig String -> String -> Boolean\n * @param {*} suffix\n * @param {*} list\n * @return {Boolean}\n * @see R.startsWith\n * @example\n *\n *      R.endsWith('c', 'abc')                //=> true\n *      R.endsWith('b', 'abc')                //=> false\n *      R.endsWith(['c'], ['a', 'b', 'c'])    //=> true\n *      R.endsWith(['b'], ['a', 'b', 'c'])    //=> false\n */\n\n\nvar endsWith =\n/*#__PURE__*/\n_curry2(function (suffix, list) {\n  return equals(takeLast(suffix.length, list), suffix);\n});\n\nmodule.exports = endsWith;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n/**\n * Takes a function and two values in its domain and returns `true` if the\n * values map to the same value in the codomain; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Relation\n * @sig (a -> b) -> a -> a -> Boolean\n * @param {Function} f\n * @param {*} x\n * @param {*} y\n * @return {Boolean}\n * @example\n *\n *      R.eqBy(Math.abs, 5, -5); //=> true\n */\n\n\nvar eqBy =\n/*#__PURE__*/\n_curry3(function eqBy(f, x, y) {\n  return equals(f(x), f(y));\n});\n\nmodule.exports = eqBy;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n/**\n * Reports whether two objects have the same value, in [`R.equals`](#equals)\n * terms, for the specified property. Useful as a curried predicate.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig k -> {k: v} -> {k: v} -> Boolean\n * @param {String} prop The name of the property to compare\n * @param {Object} obj1\n * @param {Object} obj2\n * @return {Boolean}\n *\n * @example\n *\n *      const o1 = { a: 1, b: 2, c: 3, d: 4 };\n *      const o2 = { a: 10, b: 20, c: 3, d: 40 };\n *      R.eqProps('a', o1, o2); //=> false\n *      R.eqProps('c', o1, o2); //=> true\n */\n\n\nvar eqProps =\n/*#__PURE__*/\n_curry3(function eqProps(prop, obj1, obj2) {\n  return equals(obj1[prop], obj2[prop]);\n});\n\nmodule.exports = eqProps;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _equals =\n/*#__PURE__*/\nrequire(\"./internal/_equals.js\");\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise. Handles\n * cyclical data structures.\n *\n * Dispatches symmetrically to the `equals` methods of both arguments, if\n * present.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      const a = {}; a.v = a;\n *      const b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\n\n\nvar equals =\n/*#__PURE__*/\n_curry2(function equals(a, b) {\n  return _equals(a, b, [], []);\n});\n\nmodule.exports = equals;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar _isObject =\n/*#__PURE__*/\nrequire(\"./internal/_isObject.js\");\n/**\n * Creates a new object by recursively evolving a shallow copy of `object`,\n * according to the `transformation` functions. All non-primitive properties\n * are copied by reference.\n *\n * A `transformation` function will not be invoked if its corresponding key\n * does not exist in the evolved object.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {k: (v -> v)} -> {k: v} -> {k: v}\n * @param {Object} transformations The object specifying transformation functions to apply\n *        to the object.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      const tomato = {firstName: '  Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};\n *      const transformations = {\n *        firstName: R.trim,\n *        lastName: R.trim, // Will not get invoked.\n *        data: {elapsed: R.add(1), remaining: R.add(-1)}\n *      };\n *      R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}\n */\n\n\nvar evolve =\n/*#__PURE__*/\n_curry2(function evolve(transformations, object) {\n  if (!_isObject(object) && !_isArray(object)) {\n    return object;\n  }\n\n  var result = object instanceof Array ? [] : {};\n  var transformation, key, type;\n\n  for (key in object) {\n    transformation = transformations[key];\n    type = typeof transformation;\n    result[key] = type === 'function' ? transformation(object[key]) : transformation && type === 'object' ? evolve(transformation, object[key]) : object[key];\n  }\n\n  return result;\n});\n\nmodule.exports = evolve;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _filter =\n/*#__PURE__*/\nrequire(\"./internal/_filter.js\");\n\nvar _isObject =\n/*#__PURE__*/\nrequire(\"./internal/_isObject.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar _xfilter =\n/*#__PURE__*/\nrequire(\"./internal/_xfilter.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n/**\n * Takes a predicate and a `Filterable`, and returns a new filterable of the\n * same type containing the members of the given filterable which satisfy the\n * given predicate. Filterable objects include plain objects or any object\n * that has a filter method such as `Array`.\n *\n * Dispatches to the `filter` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array} Filterable\n * @see R.reject, R.transduce, R.addIndex\n * @example\n *\n *      const isEven = n => n % 2 === 0;\n *\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\n\n\nvar filter =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/filter', 'filter'], _xfilter, function (pred, filterable) {\n  return _isObject(filterable) ? _reduce(function (acc, key) {\n    if (pred(filterable[key])) {\n      acc[key] = filterable[key];\n    }\n\n    return acc;\n  }, {}, keys(filterable)) : // else\n  _filter(pred, filterable);\n}));\n\nmodule.exports = filter;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xfind =\n/*#__PURE__*/\nrequire(\"./internal/_xfind.js\");\n/**\n * Returns the first element of the list which matches the predicate, or\n * `undefined` if no element matches.\n *\n * Dispatches to the `find` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> a | undefined\n * @param {Function} fn The predicate function used to determine if the element is the\n *        desired one.\n * @param {Array} list The array to consider.\n * @return {Object} The element found, or `undefined`.\n * @see R.transduce\n * @example\n *\n *      const xs = [{a: 1}, {a: 2}, {a: 3}];\n *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n *      R.find(R.propEq('a', 4))(xs); //=> undefined\n */\n\n\nvar find =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['find'], _xfind, function find(fn, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      return list[idx];\n    }\n\n    idx += 1;\n  }\n}));\n\nmodule.exports = find;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xfindIndex =\n/*#__PURE__*/\nrequire(\"./internal/_xfindIndex.js\");\n/**\n * Returns the index of the first element of the list which matches the\n * predicate, or `-1` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> Number\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Number} The index of the element found, or `-1`.\n * @see R.transduce, R.indexOf\n * @example\n *\n *      const xs = [{a: 1}, {a: 2}, {a: 3}];\n *      R.findIndex(R.propEq('a', 2))(xs); //=> 1\n *      R.findIndex(R.propEq('a', 4))(xs); //=> -1\n */\n\n\nvar findIndex =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xfindIndex, function findIndex(fn, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      return idx;\n    }\n\n    idx += 1;\n  }\n\n  return -1;\n}));\n\nmodule.exports = findIndex;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xfindLast =\n/*#__PURE__*/\nrequire(\"./internal/_xfindLast.js\");\n/**\n * Returns the last element of the list which matches the predicate, or\n * `undefined` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> a | undefined\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Object} The element found, or `undefined`.\n * @see R.transduce\n * @example\n *\n *      const xs = [{a: 1, b: 0}, {a:1, b: 1}];\n *      R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}\n *      R.findLast(R.propEq('a', 4))(xs); //=> undefined\n */\n\n\nvar findLast =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xfindLast, function findLast(fn, list) {\n  var idx = list.length - 1;\n\n  while (idx >= 0) {\n    if (fn(list[idx])) {\n      return list[idx];\n    }\n\n    idx -= 1;\n  }\n}));\n\nmodule.exports = findLast;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xfindLastIndex =\n/*#__PURE__*/\nrequire(\"./internal/_xfindLastIndex.js\");\n/**\n * Returns the index of the last element of the list which matches the\n * predicate, or `-1` if no element matches.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> Boolean) -> [a] -> Number\n * @param {Function} fn The predicate function used to determine if the element is the\n * desired one.\n * @param {Array} list The array to consider.\n * @return {Number} The index of the element found, or `-1`.\n * @see R.transduce, R.lastIndexOf\n * @example\n *\n *      const xs = [{a: 1, b: 0}, {a:1, b: 1}];\n *      R.findLastIndex(R.propEq('a', 1))(xs); //=> 1\n *      R.findLastIndex(R.propEq('a', 4))(xs); //=> -1\n */\n\n\nvar findLastIndex =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xfindLastIndex, function findLastIndex(fn, list) {\n  var idx = list.length - 1;\n\n  while (idx >= 0) {\n    if (fn(list[idx])) {\n      return idx;\n    }\n\n    idx -= 1;\n  }\n\n  return -1;\n}));\n\nmodule.exports = findLastIndex;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _makeFlat =\n/*#__PURE__*/\nrequire(\"./internal/_makeFlat.js\");\n/**\n * Returns a new list by pulling every item out of it (and all its sub-arrays)\n * and putting them in a new array, depth-first.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b]\n * @param {Array} list The array to consider.\n * @return {Array} The flattened list.\n * @see R.unnest\n * @example\n *\n *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n */\n\n\nvar flatten =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_makeFlat(true));\n\nmodule.exports = flatten;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n/**\n * Returns a new function much like the supplied one, except that the first two\n * arguments' order is reversed.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((a, b, c, ...) -> z) -> (b -> a -> c -> ... -> z)\n * @param {Function} fn The function to invoke with its first two parameters reversed.\n * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n * @example\n *\n *      const mergeThree = (a, b, c) => [].concat(a, b, c);\n *\n *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n *\n *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n * @symb R.flip(f)(a, b, c) = f(b, a, c)\n */\n\n\nvar flip =\n/*#__PURE__*/\n_curry1(function flip(fn) {\n  return curryN(fn.length, function (a, b) {\n    var args = Array.prototype.slice.call(arguments, 0);\n    args[0] = b;\n    args[1] = a;\n    return fn.apply(this, args);\n  });\n});\n\nmodule.exports = flip;","var _checkForMethod =\n/*#__PURE__*/\nrequire(\"./internal/_checkForMethod.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Iterate over an input `list`, calling a provided function `fn` for each\n * element in the list.\n *\n * `fn` receives one argument: *(value)*.\n *\n * Note: `R.forEach` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.forEach` method. For more\n * details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n *\n * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns\n * the original array. In some libraries this function is named `each`.\n *\n * Dispatches to the `forEach` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> *) -> [a] -> [a]\n * @param {Function} fn The function to invoke. Receives one argument, `value`.\n * @param {Array} list The list to iterate over.\n * @return {Array} The original list.\n * @see R.addIndex\n * @example\n *\n *      const printXPlusFive = x => console.log(x + 5);\n *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n *      // logs 6\n *      // logs 7\n *      // logs 8\n * @symb R.forEach(f, [a, b, c]) = [a, b, c]\n */\n\n\nvar forEach =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_checkForMethod('forEach', function forEach(fn, list) {\n  var len = list.length;\n  var idx = 0;\n\n  while (idx < len) {\n    fn(list[idx]);\n    idx += 1;\n  }\n\n  return list;\n}));\n\nmodule.exports = forEach;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n/**\n * Iterate over an input `object`, calling a provided function `fn` for each\n * key and value in the object.\n *\n * `fn` receives three argument: *(value, key, obj)*.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Object\n * @sig ((a, String, StrMap a) -> Any) -> StrMap a -> StrMap a\n * @param {Function} fn The function to invoke. Receives three argument, `value`, `key`, `obj`.\n * @param {Object} obj The object to iterate over.\n * @return {Object} The original object.\n * @example\n *\n *      const printKeyConcatValue = (value, key) => console.log(key + ':' + value);\n *      R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2}); //=> {x: 1, y: 2}\n *      // logs x:1\n *      // logs y:2\n * @symb R.forEachObjIndexed(f, {x: a, y: b}) = {x: a, y: b}\n */\n\n\nvar forEachObjIndexed =\n/*#__PURE__*/\n_curry2(function forEachObjIndexed(fn, obj) {\n  var keyList = keys(obj);\n  var idx = 0;\n\n  while (idx < keyList.length) {\n    var key = keyList[idx];\n    fn(obj[key], key, obj);\n    idx += 1;\n  }\n\n  return obj;\n});\n\nmodule.exports = forEachObjIndexed;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Creates a new object from a list key-value pairs. If a key appears in\n * multiple pairs, the rightmost pair is included in the object.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [[k,v]] -> {k: v}\n * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.\n * @return {Object} The object made by pairing up `keys` and `values`.\n * @see R.toPairs, R.pair\n * @example\n *\n *      R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3}\n */\n\n\nvar fromPairs =\n/*#__PURE__*/\n_curry1(function fromPairs(pairs) {\n  var result = {};\n  var idx = 0;\n\n  while (idx < pairs.length) {\n    result[pairs[idx][0]] = pairs[idx][1];\n    idx += 1;\n  }\n\n  return result;\n});\n\nmodule.exports = fromPairs;","var _checkForMethod =\n/*#__PURE__*/\nrequire(\"./internal/_checkForMethod.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar reduceBy =\n/*#__PURE__*/\nrequire(\"./reduceBy.js\");\n/**\n * Splits a list into sub-lists stored in an object, based on the result of\n * calling a key-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 * @typedefn Idx = String | Int | Symbol\n * @sig Idx a => (b -> a) -> [b] -> {a: [b]}\n * @param {Function} fn Function :: a -> Idx\n * @param {Array} list The array to group\n * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements\n *         that produced that key when passed to `fn`.\n * @see R.reduceBy, R.transduce, R.indexBy\n * @example\n *\n *      const byGrade = R.groupBy(function(student) {\n *        const score = student.score;\n *        return score < 65 ? 'F' :\n *               score < 70 ? 'D' :\n *               score < 80 ? 'C' :\n *               score < 90 ? 'B' : 'A';\n *      });\n *      const students = [{name: 'Abby', score: 84},\n *                      {name: 'Eddy', score: 58},\n *                      // ...\n *                      {name: 'Jack', score: 69}];\n *      byGrade(students);\n *      // {\n *      //   'A': [{name: 'Dianne', score: 99}],\n *      //   'B': [{name: 'Abby', score: 84}]\n *      //   // ...,\n *      //   'F': [{name: 'Eddy', score: 58}]\n *      // }\n */\n\n\nvar groupBy =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_checkForMethod('groupBy',\n/*#__PURE__*/\nreduceBy(function (acc, item) {\n  acc.push(item);\n  return acc;\n}, [])));\n\nmodule.exports = groupBy;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Takes a list and returns a list of lists where each sublist's elements are\n * all satisfied pairwise comparison according to the provided function.\n * Only adjacent elements are passed to the comparison function.\n *\n * @func\n * @memberOf R\n * @since v0.21.0\n * @category List\n * @sig ((a, a) → Boolean) → [a] → [[a]]\n * @param {Function} fn Function for determining whether two given (adjacent)\n *        elements should be in the same group\n * @param {Array} list The array to group. Also accepts a string, which will be\n *        treated as a list of characters.\n * @return {List} A list that contains sublists of elements,\n *         whose concatenations are equal to the original list.\n * @example\n *\n * R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]]\n *\n * R.groupWith((a, b) => a + 1 === b, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0, 1], [1, 2, 3], [5], [8], [13], [21]]\n *\n * R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21])\n * //=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]]\n *\n * const isVowel = R.test(/^[aeiou]$/i);\n * R.groupWith(R.eqBy(isVowel), 'aestiou')\n * //=> ['ae', 'st', 'iou']\n */\n\n\nvar groupWith =\n/*#__PURE__*/\n_curry2(function (fn, list) {\n  var res = [];\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    var nextidx = idx + 1;\n\n    while (nextidx < len && fn(list[nextidx - 1], list[nextidx])) {\n      nextidx += 1;\n    }\n\n    res.push(list.slice(idx, nextidx));\n    idx = nextidx;\n  }\n\n  return res;\n});\n\nmodule.exports = groupWith;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns `true` if the first argument is greater than the second; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @see R.lt\n * @example\n *\n *      R.gt(2, 1); //=> true\n *      R.gt(2, 2); //=> false\n *      R.gt(2, 3); //=> false\n *      R.gt('a', 'z'); //=> false\n *      R.gt('z', 'a'); //=> true\n */\n\n\nvar gt =\n/*#__PURE__*/\n_curry2(function gt(a, b) {\n  return a > b;\n});\n\nmodule.exports = gt;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns `true` if the first argument is greater than or equal to the second;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {Number} a\n * @param {Number} b\n * @return {Boolean}\n * @see R.lte\n * @example\n *\n *      R.gte(2, 1); //=> true\n *      R.gte(2, 2); //=> true\n *      R.gte(2, 3); //=> false\n *      R.gte('a', 'z'); //=> false\n *      R.gte('z', 'a'); //=> true\n */\n\n\nvar gte =\n/*#__PURE__*/\n_curry2(function gte(a, b) {\n  return a >= b;\n});\n\nmodule.exports = gte;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar hasPath =\n/*#__PURE__*/\nrequire(\"./hasPath.js\");\n/**\n * Returns whether or not an object has an own property with the specified name\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Object\n * @sig s -> {s: x} -> Boolean\n * @param {String} prop The name of the property to check for.\n * @param {Object} obj The object to query.\n * @return {Boolean} Whether the property exists.\n * @example\n *\n *      const hasName = R.has('name');\n *      hasName({name: 'alice'});   //=> true\n *      hasName({name: 'bob'});     //=> true\n *      hasName({});                //=> false\n *\n *      const point = {x: 0, y: 0};\n *      const pointHas = R.has(R.__, point);\n *      pointHas('x');  //=> true\n *      pointHas('y');  //=> true\n *      pointHas('z');  //=> false\n */\n\n\nvar has =\n/*#__PURE__*/\n_curry2(function has(prop, obj) {\n  return hasPath([prop], obj);\n});\n\nmodule.exports = has;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar isNil =\n/*#__PURE__*/\nrequire(\"./isNil.js\");\n/**\n * Returns whether or not an object or its prototype chain has a property with\n * the specified name\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Object\n * @sig s -> {s: x} -> Boolean\n * @param {String} prop The name of the property to check for.\n * @param {Object} obj The object to query.\n * @return {Boolean} Whether the property exists.\n * @example\n *\n *      function Rectangle(width, height) {\n *        this.width = width;\n *        this.height = height;\n *      }\n *      Rectangle.prototype.area = function() {\n *        return this.width * this.height;\n *      };\n *\n *      const square = new Rectangle(2, 2);\n *      R.hasIn('width', square);  //=> true\n *      R.hasIn('area', square);  //=> true\n */\n\n\nvar hasIn =\n/*#__PURE__*/\n_curry2(function hasIn(prop, obj) {\n  if (isNil(obj)) {\n    return false;\n  }\n\n  return prop in obj;\n});\n\nmodule.exports = hasIn;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n\nvar isNil =\n/*#__PURE__*/\nrequire(\"./isNil.js\");\n/**\n * Returns whether or not a path exists in an object. Only the object's\n * own properties are checked.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @typedefn Idx = String | Int | Symbol\n * @sig [Idx] -> {a} -> Boolean\n * @param {Array} path The path to use.\n * @param {Object} obj The object to check the path in.\n * @return {Boolean} Whether the path exists.\n * @see R.has\n * @example\n *\n *      R.hasPath(['a', 'b'], {a: {b: 2}});         // => true\n *      R.hasPath(['a', 'b'], {a: {b: undefined}}); // => true\n *      R.hasPath(['a', 'b'], {a: {c: 2}});         // => false\n *      R.hasPath(['a', 'b'], {});                  // => false\n */\n\n\nvar hasPath =\n/*#__PURE__*/\n_curry2(function hasPath(_path, obj) {\n  if (_path.length === 0 || isNil(obj)) {\n    return false;\n  }\n\n  var val = obj;\n  var idx = 0;\n\n  while (idx < _path.length) {\n    if (!isNil(val) && _has(_path[idx], val)) {\n      val = val[_path[idx]];\n      idx += 1;\n    } else {\n      return false;\n    }\n  }\n\n  return true;\n});\n\nmodule.exports = hasPath;","var nth =\n/*#__PURE__*/\nrequire(\"./nth.js\");\n/**\n * Returns the first element of the given list or string. In some libraries\n * this function is named `first`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {Array|String} list\n * @return {*}\n * @see R.tail, R.init, R.last\n * @example\n *\n *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n *      R.head([]); //=> undefined\n *\n *      R.head('abc'); //=> 'a'\n *      R.head(''); //=> ''\n */\n\n\nvar head =\n/*#__PURE__*/\nnth(0);\nmodule.exports = head;","var _objectIs =\n/*#__PURE__*/\nrequire(\"./internal/_objectIs.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * Note this is merely a curried version of ES6 `Object.is`.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      const o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\n\n\nvar identical =\n/*#__PURE__*/\n_curry2(_objectIs);\n\nmodule.exports = identical;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _identity =\n/*#__PURE__*/\nrequire(\"./internal/_identity.js\");\n/**\n * A function that does nothing but return the parameter supplied to it. Good\n * as a default or placeholder function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> a\n * @param {*} x The value to return.\n * @return {*} The input value, `x`.\n * @example\n *\n *      R.identity(1); //=> 1\n *\n *      const obj = {};\n *      R.identity(obj) === obj; //=> true\n * @symb R.identity(a) = a\n */\n\n\nvar identity =\n/*#__PURE__*/\n_curry1(_identity);\n\nmodule.exports = identity;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n/**\n * Creates a function that will process either the `onTrue` or the `onFalse`\n * function depending upon the result of the `condition` predicate.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)\n * @param {Function} condition A predicate function\n * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.\n * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.\n * @return {Function} A new function that will process either the `onTrue` or the `onFalse`\n *                    function depending upon the result of the `condition` predicate.\n * @see R.unless, R.when, R.cond\n * @example\n *\n *      const incCount = R.ifElse(\n *        R.has('count'),\n *        R.over(R.lensProp('count'), R.inc),\n *        R.assoc('count', 1)\n *      );\n *      incCount({ count: 1 }); //=> { count: 2 }\n *      incCount({});           //=> { count: 1 }\n */\n\n\nvar ifElse =\n/*#__PURE__*/\n_curry3(function ifElse(condition, onTrue, onFalse) {\n  return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() {\n    return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);\n  });\n});\n\nmodule.exports = ifElse;","var add =\n/*#__PURE__*/\nrequire(\"./add.js\");\n/**\n * Increments its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number} n + 1\n * @see R.dec\n * @example\n *\n *      R.inc(42); //=> 43\n */\n\n\nvar inc =\n/*#__PURE__*/\nadd(1);\nmodule.exports = inc;","var _includes =\n/*#__PURE__*/\nrequire(\"./internal/_includes.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns `true` if the specified value is equal, in [`R.equals`](#equals)\n * terms, to at least one element of the given list; `false` otherwise.\n * Also works with strings.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.\n * @see R.any\n * @example\n *\n *      R.includes(3, [1, 2, 3]); //=> true\n *      R.includes(4, [1, 2, 3]); //=> false\n *      R.includes({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true\n *      R.includes([42], [[42]]); //=> true\n *      R.includes('ba', 'banana'); //=>true\n */\n\n\nvar includes =\n/*#__PURE__*/\n_curry2(_includes);\n\nmodule.exports = includes;","module.exports = {};\nmodule.exports.F =\n/*#__PURE__*/\nrequire(\"./F.js\");\nmodule.exports.T =\n/*#__PURE__*/\nrequire(\"./T.js\");\nmodule.exports.__ =\n/*#__PURE__*/\nrequire(\"./__.js\");\nmodule.exports.add =\n/*#__PURE__*/\nrequire(\"./add.js\");\nmodule.exports.addIndex =\n/*#__PURE__*/\nrequire(\"./addIndex.js\");\nmodule.exports.adjust =\n/*#__PURE__*/\nrequire(\"./adjust.js\");\nmodule.exports.all =\n/*#__PURE__*/\nrequire(\"./all.js\");\nmodule.exports.allPass =\n/*#__PURE__*/\nrequire(\"./allPass.js\");\nmodule.exports.always =\n/*#__PURE__*/\nrequire(\"./always.js\");\nmodule.exports.and =\n/*#__PURE__*/\nrequire(\"./and.js\");\nmodule.exports.any =\n/*#__PURE__*/\nrequire(\"./any.js\");\nmodule.exports.anyPass =\n/*#__PURE__*/\nrequire(\"./anyPass.js\");\nmodule.exports.ap =\n/*#__PURE__*/\nrequire(\"./ap.js\");\nmodule.exports.aperture =\n/*#__PURE__*/\nrequire(\"./aperture.js\");\nmodule.exports.append =\n/*#__PURE__*/\nrequire(\"./append.js\");\nmodule.exports.apply =\n/*#__PURE__*/\nrequire(\"./apply.js\");\nmodule.exports.applySpec =\n/*#__PURE__*/\nrequire(\"./applySpec.js\");\nmodule.exports.applyTo =\n/*#__PURE__*/\nrequire(\"./applyTo.js\");\nmodule.exports.ascend =\n/*#__PURE__*/\nrequire(\"./ascend.js\");\nmodule.exports.assoc =\n/*#__PURE__*/\nrequire(\"./assoc.js\");\nmodule.exports.assocPath =\n/*#__PURE__*/\nrequire(\"./assocPath.js\");\nmodule.exports.binary =\n/*#__PURE__*/\nrequire(\"./binary.js\");\nmodule.exports.bind =\n/*#__PURE__*/\nrequire(\"./bind.js\");\nmodule.exports.both =\n/*#__PURE__*/\nrequire(\"./both.js\");\nmodule.exports.call =\n/*#__PURE__*/\nrequire(\"./call.js\");\nmodule.exports.chain =\n/*#__PURE__*/\nrequire(\"./chain.js\");\nmodule.exports.clamp =\n/*#__PURE__*/\nrequire(\"./clamp.js\");\nmodule.exports.clone =\n/*#__PURE__*/\nrequire(\"./clone.js\");\nmodule.exports.collectBy =\n/*#__PURE__*/\nrequire(\"./collectBy.js\");\nmodule.exports.comparator =\n/*#__PURE__*/\nrequire(\"./comparator.js\");\nmodule.exports.complement =\n/*#__PURE__*/\nrequire(\"./complement.js\");\nmodule.exports.compose =\n/*#__PURE__*/\nrequire(\"./compose.js\");\nmodule.exports.composeWith =\n/*#__PURE__*/\nrequire(\"./composeWith.js\");\nmodule.exports.concat =\n/*#__PURE__*/\nrequire(\"./concat.js\");\nmodule.exports.cond =\n/*#__PURE__*/\nrequire(\"./cond.js\");\nmodule.exports.construct =\n/*#__PURE__*/\nrequire(\"./construct.js\");\nmodule.exports.constructN =\n/*#__PURE__*/\nrequire(\"./constructN.js\");\nmodule.exports.converge =\n/*#__PURE__*/\nrequire(\"./converge.js\");\nmodule.exports.count =\n/*#__PURE__*/\nrequire(\"./count.js\");\nmodule.exports.countBy =\n/*#__PURE__*/\nrequire(\"./countBy.js\");\nmodule.exports.curry =\n/*#__PURE__*/\nrequire(\"./curry.js\");\nmodule.exports.curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\nmodule.exports.dec =\n/*#__PURE__*/\nrequire(\"./dec.js\");\nmodule.exports.defaultTo =\n/*#__PURE__*/\nrequire(\"./defaultTo.js\");\nmodule.exports.descend =\n/*#__PURE__*/\nrequire(\"./descend.js\");\nmodule.exports.difference =\n/*#__PURE__*/\nrequire(\"./difference.js\");\nmodule.exports.differenceWith =\n/*#__PURE__*/\nrequire(\"./differenceWith.js\");\nmodule.exports.dissoc =\n/*#__PURE__*/\nrequire(\"./dissoc.js\");\nmodule.exports.dissocPath =\n/*#__PURE__*/\nrequire(\"./dissocPath.js\");\nmodule.exports.divide =\n/*#__PURE__*/\nrequire(\"./divide.js\");\nmodule.exports.drop =\n/*#__PURE__*/\nrequire(\"./drop.js\");\nmodule.exports.dropLast =\n/*#__PURE__*/\nrequire(\"./dropLast.js\");\nmodule.exports.dropLastWhile =\n/*#__PURE__*/\nrequire(\"./dropLastWhile.js\");\nmodule.exports.dropRepeats =\n/*#__PURE__*/\nrequire(\"./dropRepeats.js\");\nmodule.exports.dropRepeatsWith =\n/*#__PURE__*/\nrequire(\"./dropRepeatsWith.js\");\nmodule.exports.dropWhile =\n/*#__PURE__*/\nrequire(\"./dropWhile.js\");\nmodule.exports.either =\n/*#__PURE__*/\nrequire(\"./either.js\");\nmodule.exports.empty =\n/*#__PURE__*/\nrequire(\"./empty.js\");\nmodule.exports.endsWith =\n/*#__PURE__*/\nrequire(\"./endsWith.js\");\nmodule.exports.eqBy =\n/*#__PURE__*/\nrequire(\"./eqBy.js\");\nmodule.exports.eqProps =\n/*#__PURE__*/\nrequire(\"./eqProps.js\");\nmodule.exports.equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\nmodule.exports.evolve =\n/*#__PURE__*/\nrequire(\"./evolve.js\");\nmodule.exports.filter =\n/*#__PURE__*/\nrequire(\"./filter.js\");\nmodule.exports.find =\n/*#__PURE__*/\nrequire(\"./find.js\");\nmodule.exports.findIndex =\n/*#__PURE__*/\nrequire(\"./findIndex.js\");\nmodule.exports.findLast =\n/*#__PURE__*/\nrequire(\"./findLast.js\");\nmodule.exports.findLastIndex =\n/*#__PURE__*/\nrequire(\"./findLastIndex.js\");\nmodule.exports.flatten =\n/*#__PURE__*/\nrequire(\"./flatten.js\");\nmodule.exports.flip =\n/*#__PURE__*/\nrequire(\"./flip.js\");\nmodule.exports.forEach =\n/*#__PURE__*/\nrequire(\"./forEach.js\");\nmodule.exports.forEachObjIndexed =\n/*#__PURE__*/\nrequire(\"./forEachObjIndexed.js\");\nmodule.exports.fromPairs =\n/*#__PURE__*/\nrequire(\"./fromPairs.js\");\nmodule.exports.groupBy =\n/*#__PURE__*/\nrequire(\"./groupBy.js\");\nmodule.exports.groupWith =\n/*#__PURE__*/\nrequire(\"./groupWith.js\");\nmodule.exports.gt =\n/*#__PURE__*/\nrequire(\"./gt.js\");\nmodule.exports.gte =\n/*#__PURE__*/\nrequire(\"./gte.js\");\nmodule.exports.has =\n/*#__PURE__*/\nrequire(\"./has.js\");\nmodule.exports.hasIn =\n/*#__PURE__*/\nrequire(\"./hasIn.js\");\nmodule.exports.hasPath =\n/*#__PURE__*/\nrequire(\"./hasPath.js\");\nmodule.exports.head =\n/*#__PURE__*/\nrequire(\"./head.js\");\nmodule.exports.identical =\n/*#__PURE__*/\nrequire(\"./identical.js\");\nmodule.exports.identity =\n/*#__PURE__*/\nrequire(\"./identity.js\");\nmodule.exports.ifElse =\n/*#__PURE__*/\nrequire(\"./ifElse.js\");\nmodule.exports.inc =\n/*#__PURE__*/\nrequire(\"./inc.js\");\nmodule.exports.includes =\n/*#__PURE__*/\nrequire(\"./includes.js\");\nmodule.exports.indexBy =\n/*#__PURE__*/\nrequire(\"./indexBy.js\");\nmodule.exports.indexOf =\n/*#__PURE__*/\nrequire(\"./indexOf.js\");\nmodule.exports.init =\n/*#__PURE__*/\nrequire(\"./init.js\");\nmodule.exports.innerJoin =\n/*#__PURE__*/\nrequire(\"./innerJoin.js\");\nmodule.exports.insert =\n/*#__PURE__*/\nrequire(\"./insert.js\");\nmodule.exports.insertAll =\n/*#__PURE__*/\nrequire(\"./insertAll.js\");\nmodule.exports.intersection =\n/*#__PURE__*/\nrequire(\"./intersection.js\");\nmodule.exports.intersperse =\n/*#__PURE__*/\nrequire(\"./intersperse.js\");\nmodule.exports.into =\n/*#__PURE__*/\nrequire(\"./into.js\");\nmodule.exports.invert =\n/*#__PURE__*/\nrequire(\"./invert.js\");\nmodule.exports.invertObj =\n/*#__PURE__*/\nrequire(\"./invertObj.js\");\nmodule.exports.invoker =\n/*#__PURE__*/\nrequire(\"./invoker.js\");\nmodule.exports.is =\n/*#__PURE__*/\nrequire(\"./is.js\");\nmodule.exports.isEmpty =\n/*#__PURE__*/\nrequire(\"./isEmpty.js\");\nmodule.exports.isNil =\n/*#__PURE__*/\nrequire(\"./isNil.js\");\nmodule.exports.join =\n/*#__PURE__*/\nrequire(\"./join.js\");\nmodule.exports.juxt =\n/*#__PURE__*/\nrequire(\"./juxt.js\");\nmodule.exports.keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\nmodule.exports.keysIn =\n/*#__PURE__*/\nrequire(\"./keysIn.js\");\nmodule.exports.last =\n/*#__PURE__*/\nrequire(\"./last.js\");\nmodule.exports.lastIndexOf =\n/*#__PURE__*/\nrequire(\"./lastIndexOf.js\");\nmodule.exports.length =\n/*#__PURE__*/\nrequire(\"./length.js\");\nmodule.exports.lens =\n/*#__PURE__*/\nrequire(\"./lens.js\");\nmodule.exports.lensIndex =\n/*#__PURE__*/\nrequire(\"./lensIndex.js\");\nmodule.exports.lensPath =\n/*#__PURE__*/\nrequire(\"./lensPath.js\");\nmodule.exports.lensProp =\n/*#__PURE__*/\nrequire(\"./lensProp.js\");\nmodule.exports.lift =\n/*#__PURE__*/\nrequire(\"./lift.js\");\nmodule.exports.liftN =\n/*#__PURE__*/\nrequire(\"./liftN.js\");\nmodule.exports.lt =\n/*#__PURE__*/\nrequire(\"./lt.js\");\nmodule.exports.lte =\n/*#__PURE__*/\nrequire(\"./lte.js\");\nmodule.exports.map =\n/*#__PURE__*/\nrequire(\"./map.js\");\nmodule.exports.mapAccum =\n/*#__PURE__*/\nrequire(\"./mapAccum.js\");\nmodule.exports.mapAccumRight =\n/*#__PURE__*/\nrequire(\"./mapAccumRight.js\");\nmodule.exports.mapObjIndexed =\n/*#__PURE__*/\nrequire(\"./mapObjIndexed.js\");\nmodule.exports.match =\n/*#__PURE__*/\nrequire(\"./match.js\");\nmodule.exports.mathMod =\n/*#__PURE__*/\nrequire(\"./mathMod.js\");\nmodule.exports.max =\n/*#__PURE__*/\nrequire(\"./max.js\");\nmodule.exports.maxBy =\n/*#__PURE__*/\nrequire(\"./maxBy.js\");\nmodule.exports.mean =\n/*#__PURE__*/\nrequire(\"./mean.js\");\nmodule.exports.median =\n/*#__PURE__*/\nrequire(\"./median.js\");\nmodule.exports.memoizeWith =\n/*#__PURE__*/\nrequire(\"./memoizeWith.js\");\nmodule.exports.mergeAll =\n/*#__PURE__*/\nrequire(\"./mergeAll.js\");\nmodule.exports.mergeDeepLeft =\n/*#__PURE__*/\nrequire(\"./mergeDeepLeft.js\");\nmodule.exports.mergeDeepRight =\n/*#__PURE__*/\nrequire(\"./mergeDeepRight.js\");\nmodule.exports.mergeDeepWith =\n/*#__PURE__*/\nrequire(\"./mergeDeepWith.js\");\nmodule.exports.mergeDeepWithKey =\n/*#__PURE__*/\nrequire(\"./mergeDeepWithKey.js\");\nmodule.exports.mergeLeft =\n/*#__PURE__*/\nrequire(\"./mergeLeft.js\");\nmodule.exports.mergeRight =\n/*#__PURE__*/\nrequire(\"./mergeRight.js\");\nmodule.exports.mergeWith =\n/*#__PURE__*/\nrequire(\"./mergeWith.js\");\nmodule.exports.mergeWithKey =\n/*#__PURE__*/\nrequire(\"./mergeWithKey.js\");\nmodule.exports.min =\n/*#__PURE__*/\nrequire(\"./min.js\");\nmodule.exports.minBy =\n/*#__PURE__*/\nrequire(\"./minBy.js\");\nmodule.exports.modify =\n/*#__PURE__*/\nrequire(\"./modify.js\");\nmodule.exports.modifyPath =\n/*#__PURE__*/\nrequire(\"./modifyPath.js\");\nmodule.exports.modulo =\n/*#__PURE__*/\nrequire(\"./modulo.js\");\nmodule.exports.move =\n/*#__PURE__*/\nrequire(\"./move.js\");\nmodule.exports.multiply =\n/*#__PURE__*/\nrequire(\"./multiply.js\");\nmodule.exports.nAry =\n/*#__PURE__*/\nrequire(\"./nAry.js\");\nmodule.exports.partialObject =\n/*#__PURE__*/\nrequire(\"./partialObject.js\");\nmodule.exports.negate =\n/*#__PURE__*/\nrequire(\"./negate.js\");\nmodule.exports.none =\n/*#__PURE__*/\nrequire(\"./none.js\");\nmodule.exports.not =\n/*#__PURE__*/\nrequire(\"./not.js\");\nmodule.exports.nth =\n/*#__PURE__*/\nrequire(\"./nth.js\");\nmodule.exports.nthArg =\n/*#__PURE__*/\nrequire(\"./nthArg.js\");\nmodule.exports.o =\n/*#__PURE__*/\nrequire(\"./o.js\");\nmodule.exports.objOf =\n/*#__PURE__*/\nrequire(\"./objOf.js\");\nmodule.exports.of =\n/*#__PURE__*/\nrequire(\"./of.js\");\nmodule.exports.omit =\n/*#__PURE__*/\nrequire(\"./omit.js\");\nmodule.exports.on =\n/*#__PURE__*/\nrequire(\"./on.js\");\nmodule.exports.once =\n/*#__PURE__*/\nrequire(\"./once.js\");\nmodule.exports.or =\n/*#__PURE__*/\nrequire(\"./or.js\");\nmodule.exports.otherwise =\n/*#__PURE__*/\nrequire(\"./otherwise.js\");\nmodule.exports.over =\n/*#__PURE__*/\nrequire(\"./over.js\");\nmodule.exports.pair =\n/*#__PURE__*/\nrequire(\"./pair.js\");\nmodule.exports.partial =\n/*#__PURE__*/\nrequire(\"./partial.js\");\nmodule.exports.partialRight =\n/*#__PURE__*/\nrequire(\"./partialRight.js\");\nmodule.exports.partition =\n/*#__PURE__*/\nrequire(\"./partition.js\");\nmodule.exports.path =\n/*#__PURE__*/\nrequire(\"./path.js\");\nmodule.exports.paths =\n/*#__PURE__*/\nrequire(\"./paths.js\");\nmodule.exports.pathEq =\n/*#__PURE__*/\nrequire(\"./pathEq.js\");\nmodule.exports.pathOr =\n/*#__PURE__*/\nrequire(\"./pathOr.js\");\nmodule.exports.pathSatisfies =\n/*#__PURE__*/\nrequire(\"./pathSatisfies.js\");\nmodule.exports.pick =\n/*#__PURE__*/\nrequire(\"./pick.js\");\nmodule.exports.pickAll =\n/*#__PURE__*/\nrequire(\"./pickAll.js\");\nmodule.exports.pickBy =\n/*#__PURE__*/\nrequire(\"./pickBy.js\");\nmodule.exports.pipe =\n/*#__PURE__*/\nrequire(\"./pipe.js\");\nmodule.exports.pipeWith =\n/*#__PURE__*/\nrequire(\"./pipeWith.js\");\nmodule.exports.pluck =\n/*#__PURE__*/\nrequire(\"./pluck.js\");\nmodule.exports.prepend =\n/*#__PURE__*/\nrequire(\"./prepend.js\");\nmodule.exports.product =\n/*#__PURE__*/\nrequire(\"./product.js\");\nmodule.exports.project =\n/*#__PURE__*/\nrequire(\"./project.js\");\nmodule.exports.promap =\n/*#__PURE__*/\nrequire(\"./promap.js\");\nmodule.exports.prop =\n/*#__PURE__*/\nrequire(\"./prop.js\");\nmodule.exports.propEq =\n/*#__PURE__*/\nrequire(\"./propEq.js\");\nmodule.exports.propIs =\n/*#__PURE__*/\nrequire(\"./propIs.js\");\nmodule.exports.propOr =\n/*#__PURE__*/\nrequire(\"./propOr.js\");\nmodule.exports.propSatisfies =\n/*#__PURE__*/\nrequire(\"./propSatisfies.js\");\nmodule.exports.props =\n/*#__PURE__*/\nrequire(\"./props.js\");\nmodule.exports.range =\n/*#__PURE__*/\nrequire(\"./range.js\");\nmodule.exports.reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\nmodule.exports.reduceBy =\n/*#__PURE__*/\nrequire(\"./reduceBy.js\");\nmodule.exports.reduceRight =\n/*#__PURE__*/\nrequire(\"./reduceRight.js\");\nmodule.exports.reduceWhile =\n/*#__PURE__*/\nrequire(\"./reduceWhile.js\");\nmodule.exports.reduced =\n/*#__PURE__*/\nrequire(\"./reduced.js\");\nmodule.exports.reject =\n/*#__PURE__*/\nrequire(\"./reject.js\");\nmodule.exports.remove =\n/*#__PURE__*/\nrequire(\"./remove.js\");\nmodule.exports.repeat =\n/*#__PURE__*/\nrequire(\"./repeat.js\");\nmodule.exports.replace =\n/*#__PURE__*/\nrequire(\"./replace.js\");\nmodule.exports.reverse =\n/*#__PURE__*/\nrequire(\"./reverse.js\");\nmodule.exports.scan =\n/*#__PURE__*/\nrequire(\"./scan.js\");\nmodule.exports.sequence =\n/*#__PURE__*/\nrequire(\"./sequence.js\");\nmodule.exports.set =\n/*#__PURE__*/\nrequire(\"./set.js\");\nmodule.exports.slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\nmodule.exports.sort =\n/*#__PURE__*/\nrequire(\"./sort.js\");\nmodule.exports.sortBy =\n/*#__PURE__*/\nrequire(\"./sortBy.js\");\nmodule.exports.sortWith =\n/*#__PURE__*/\nrequire(\"./sortWith.js\");\nmodule.exports.split =\n/*#__PURE__*/\nrequire(\"./split.js\");\nmodule.exports.splitAt =\n/*#__PURE__*/\nrequire(\"./splitAt.js\");\nmodule.exports.splitEvery =\n/*#__PURE__*/\nrequire(\"./splitEvery.js\");\nmodule.exports.splitWhen =\n/*#__PURE__*/\nrequire(\"./splitWhen.js\");\nmodule.exports.splitWhenever =\n/*#__PURE__*/\nrequire(\"./splitWhenever.js\");\nmodule.exports.startsWith =\n/*#__PURE__*/\nrequire(\"./startsWith.js\");\nmodule.exports.subtract =\n/*#__PURE__*/\nrequire(\"./subtract.js\");\nmodule.exports.sum =\n/*#__PURE__*/\nrequire(\"./sum.js\");\nmodule.exports.symmetricDifference =\n/*#__PURE__*/\nrequire(\"./symmetricDifference.js\");\nmodule.exports.symmetricDifferenceWith =\n/*#__PURE__*/\nrequire(\"./symmetricDifferenceWith.js\");\nmodule.exports.tail =\n/*#__PURE__*/\nrequire(\"./tail.js\");\nmodule.exports.take =\n/*#__PURE__*/\nrequire(\"./take.js\");\nmodule.exports.takeLast =\n/*#__PURE__*/\nrequire(\"./takeLast.js\");\nmodule.exports.takeLastWhile =\n/*#__PURE__*/\nrequire(\"./takeLastWhile.js\");\nmodule.exports.takeWhile =\n/*#__PURE__*/\nrequire(\"./takeWhile.js\");\nmodule.exports.tap =\n/*#__PURE__*/\nrequire(\"./tap.js\");\nmodule.exports.test =\n/*#__PURE__*/\nrequire(\"./test.js\");\nmodule.exports.andThen =\n/*#__PURE__*/\nrequire(\"./andThen.js\");\nmodule.exports.times =\n/*#__PURE__*/\nrequire(\"./times.js\");\nmodule.exports.toLower =\n/*#__PURE__*/\nrequire(\"./toLower.js\");\nmodule.exports.toPairs =\n/*#__PURE__*/\nrequire(\"./toPairs.js\");\nmodule.exports.toPairsIn =\n/*#__PURE__*/\nrequire(\"./toPairsIn.js\");\nmodule.exports.toString =\n/*#__PURE__*/\nrequire(\"./toString.js\");\nmodule.exports.toUpper =\n/*#__PURE__*/\nrequire(\"./toUpper.js\");\nmodule.exports.transduce =\n/*#__PURE__*/\nrequire(\"./transduce.js\");\nmodule.exports.transpose =\n/*#__PURE__*/\nrequire(\"./transpose.js\");\nmodule.exports.traverse =\n/*#__PURE__*/\nrequire(\"./traverse.js\");\nmodule.exports.trim =\n/*#__PURE__*/\nrequire(\"./trim.js\");\nmodule.exports.tryCatch =\n/*#__PURE__*/\nrequire(\"./tryCatch.js\");\nmodule.exports.type =\n/*#__PURE__*/\nrequire(\"./type.js\");\nmodule.exports.unapply =\n/*#__PURE__*/\nrequire(\"./unapply.js\");\nmodule.exports.unary =\n/*#__PURE__*/\nrequire(\"./unary.js\");\nmodule.exports.uncurryN =\n/*#__PURE__*/\nrequire(\"./uncurryN.js\");\nmodule.exports.unfold =\n/*#__PURE__*/\nrequire(\"./unfold.js\");\nmodule.exports.union =\n/*#__PURE__*/\nrequire(\"./union.js\");\nmodule.exports.unionWith =\n/*#__PURE__*/\nrequire(\"./unionWith.js\");\nmodule.exports.uniq =\n/*#__PURE__*/\nrequire(\"./uniq.js\");\nmodule.exports.uniqBy =\n/*#__PURE__*/\nrequire(\"./uniqBy.js\");\nmodule.exports.uniqWith =\n/*#__PURE__*/\nrequire(\"./uniqWith.js\");\nmodule.exports.unless =\n/*#__PURE__*/\nrequire(\"./unless.js\");\nmodule.exports.unnest =\n/*#__PURE__*/\nrequire(\"./unnest.js\");\nmodule.exports.until =\n/*#__PURE__*/\nrequire(\"./until.js\");\nmodule.exports.unwind =\n/*#__PURE__*/\nrequire(\"./unwind.js\");\nmodule.exports.update =\n/*#__PURE__*/\nrequire(\"./update.js\");\nmodule.exports.useWith =\n/*#__PURE__*/\nrequire(\"./useWith.js\");\nmodule.exports.values =\n/*#__PURE__*/\nrequire(\"./values.js\");\nmodule.exports.valuesIn =\n/*#__PURE__*/\nrequire(\"./valuesIn.js\");\nmodule.exports.view =\n/*#__PURE__*/\nrequire(\"./view.js\");\nmodule.exports.when =\n/*#__PURE__*/\nrequire(\"./when.js\");\nmodule.exports.where =\n/*#__PURE__*/\nrequire(\"./where.js\");\nmodule.exports.whereAny =\n/*#__PURE__*/\nrequire(\"./whereAny.js\");\nmodule.exports.whereEq =\n/*#__PURE__*/\nrequire(\"./whereEq.js\");\nmodule.exports.without =\n/*#__PURE__*/\nrequire(\"./without.js\");\nmodule.exports.xor =\n/*#__PURE__*/\nrequire(\"./xor.js\");\nmodule.exports.xprod =\n/*#__PURE__*/\nrequire(\"./xprod.js\");\nmodule.exports.zip =\n/*#__PURE__*/\nrequire(\"./zip.js\");\nmodule.exports.zipObj =\n/*#__PURE__*/\nrequire(\"./zipObj.js\");\nmodule.exports.zipWith =\n/*#__PURE__*/\nrequire(\"./zipWith.js\");\nmodule.exports.thunkify =\n/*#__PURE__*/\nrequire(\"./thunkify.js\");","var reduceBy =\n/*#__PURE__*/\nrequire(\"./reduceBy.js\");\n/**\n * Given a function that generates a key, turns a list of objects into an\n * object indexing the objects by the given key. Note that if multiple\n * objects generate the same value for the indexing key only the last value\n * will be included in the generated object.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @typedefn Idx = String | Int | Symbol\n * @sig Idx a => (b -> a) -> [b] -> {a: b}\n * @param {Function} fn Function :: a -> Idx\n * @param {Array} array The array of objects to index\n * @return {Object} An object indexing each array element by the given property.\n * @see R.groupBy\n * @example\n *\n *      const list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];\n *      R.indexBy(R.prop('id'), list);\n *      //=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}\n */\n\n\nvar indexBy =\n/*#__PURE__*/\nreduceBy(function (acc, elem) {\n  return elem;\n}, null);\nmodule.exports = indexBy;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _indexOf =\n/*#__PURE__*/\nrequire(\"./internal/_indexOf.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n/**\n * Returns the position of the first occurrence of an item in an array, or -1\n * if the item is not included in the array. [`R.equals`](#equals) is used to\n * determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Number\n * @param {*} target The item to find.\n * @param {Array} xs The array to search in.\n * @return {Number} the index of the target, or -1 if the target is not found.\n * @see R.lastIndexOf, R.findIndex\n * @example\n *\n *      R.indexOf(3, [1,2,3,4]); //=> 2\n *      R.indexOf(10, [1,2,3,4]); //=> -1\n */\n\n\nvar indexOf =\n/*#__PURE__*/\n_curry2(function indexOf(target, xs) {\n  return typeof xs.indexOf === 'function' && !_isArray(xs) ? xs.indexOf(target) : _indexOf(xs, target, 0);\n});\n\nmodule.exports = indexOf;","var slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Returns all but the last element of the given list or string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.last, R.head, R.tail\n * @example\n *\n *      R.init([1, 2, 3]);  //=> [1, 2]\n *      R.init([1, 2]);     //=> [1]\n *      R.init([1]);        //=> []\n *      R.init([]);         //=> []\n *\n *      R.init('abc');  //=> 'ab'\n *      R.init('ab');   //=> 'a'\n *      R.init('a');    //=> ''\n *      R.init('');     //=> ''\n */\n\n\nvar init =\n/*#__PURE__*/\nslice(0, -1);\nmodule.exports = init;","var _includesWith =\n/*#__PURE__*/\nrequire(\"./internal/_includesWith.js\");\n\nvar _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _filter =\n/*#__PURE__*/\nrequire(\"./internal/_filter.js\");\n/**\n * Takes a predicate `pred`, a list `xs`, and a list `ys`, and returns a list\n * `xs'` comprising each of the elements of `xs` which is equal to one or more\n * elements of `ys` according to `pred`.\n *\n * `pred` must be a binary function expecting an element from each list.\n *\n * `xs`, `ys`, and `xs'` are treated as sets, semantically, so ordering should\n * not be significant, but since `xs'` is ordered the implementation guarantees\n * that its values are in the same order as they appear in `xs`. Duplicates are\n * not removed, so `xs'` may contain duplicates if `xs` contains duplicates.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Relation\n * @sig ((a, b) -> Boolean) -> [a] -> [b] -> [a]\n * @param {Function} pred\n * @param {Array} xs\n * @param {Array} ys\n * @return {Array}\n * @see R.intersection\n * @example\n *\n *      R.innerJoin(\n *        (record, id) => record.id === id,\n *        [{id: 824, name: 'Richie Furay'},\n *         {id: 956, name: 'Dewey Martin'},\n *         {id: 313, name: 'Bruce Palmer'},\n *         {id: 456, name: 'Stephen Stills'},\n *         {id: 177, name: 'Neil Young'}],\n *        [177, 456, 999]\n *      );\n *      //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]\n */\n\n\nvar innerJoin =\n/*#__PURE__*/\n_curry3(function innerJoin(pred, xs, ys) {\n  return _filter(function (x) {\n    return _includesWith(pred, x, ys);\n  }, xs);\n});\n\nmodule.exports = innerJoin;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Inserts the supplied element into the list, at the specified `index`. _Note that\n\n * this is not destructive_: it returns a copy of the list with the changes.\n * <small>No lists have been harmed in the application of this function.</small>\n *\n * @func\n * @memberOf R\n * @since v0.2.2\n * @category List\n * @sig Number -> a -> [a] -> [a]\n * @param {Number} index The position to insert the element\n * @param {*} elt The element to insert into the Array\n * @param {Array} list The list to insert into\n * @return {Array} A new Array with `elt` inserted at `index`.\n * @example\n *\n *      R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]\n */\n\n\nvar insert =\n/*#__PURE__*/\n_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\nmodule.exports = insert;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Inserts the sub-list into the list, at the specified `index`. _Note that this is not\n * destructive_: it returns a copy of the list with the changes.\n * <small>No lists have been harmed in the application of this function.</small>\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category List\n * @sig Number -> [a] -> [a] -> [a]\n * @param {Number} index The position to insert the sub-list\n * @param {Array} elts The sub-list to insert into the Array\n * @param {Array} list The list to insert the sub-list into\n * @return {Array} A new Array with `elts` inserted starting at `index`.\n * @example\n *\n *      R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]\n */\n\n\nvar insertAll =\n/*#__PURE__*/\n_curry3(function insertAll(idx, elts, list) {\n  idx = idx < list.length && idx >= 0 ? idx : list.length;\n  return [].concat(Array.prototype.slice.call(list, 0, idx), elts, Array.prototype.slice.call(list, idx));\n});\n\nmodule.exports = insertAll;","var _includes =\n/*#__PURE__*/\nrequire(\"./_includes.js\");\n\nvar _Set =\n/*#__PURE__*/\nfunction () {\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  // @param item The item to check for existence in the Set\n  // @returns {boolean} true if the item exists in the Set, otherwise false\n  //\n\n\n  _Set.prototype.has = function (item) {\n    return hasOrAdd(item, false, this);\n  }; //\n  // Combines the logic for checking whether an item is a member of the set and\n  // for adding a new item to the set.\n  //\n  // @param item       The item to check or add to the Set instance.\n  // @param shouldAdd  If true, the item will be added to the set if it doesn't\n  //                   already exist.\n  // @param set        The set instance to check or add to.\n  // @return {boolean} true if the item already existed, otherwise false.\n  //\n\n\n  return _Set;\n}();\n\nfunction hasOrAdd(item, shouldAdd, set) {\n  var type = typeof item;\n  var prevSize, newSize;\n\n  switch (type) {\n    case 'string':\n    case 'number':\n      // distinguish between +0 and -0\n      if (item === 0 && 1 / item === -Infinity) {\n        if (set._items['-0']) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items['-0'] = true;\n          }\n\n          return false;\n        }\n      } // these types can all utilise the native Set\n\n\n      if (set._nativeSet !== null) {\n        if (shouldAdd) {\n          prevSize = set._nativeSet.size;\n\n          set._nativeSet.add(item);\n\n          newSize = set._nativeSet.size;\n          return newSize === prevSize;\n        } else {\n          return set._nativeSet.has(item);\n        }\n      } else {\n        if (!(type in set._items)) {\n          if (shouldAdd) {\n            set._items[type] = {};\n            set._items[type][item] = true;\n          }\n\n          return false;\n        } else if (item in set._items[type]) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items[type][item] = true;\n          }\n\n          return false;\n        }\n      }\n\n    case 'boolean':\n      // set._items['boolean'] holds a two element array\n      // representing [ falseExists, trueExists ]\n      if (type in set._items) {\n        var bIdx = item ? 1 : 0;\n\n        if (set._items[type][bIdx]) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items[type][bIdx] = true;\n          }\n\n          return false;\n        }\n      } else {\n        if (shouldAdd) {\n          set._items[type] = item ? [false, true] : [true, false];\n        }\n\n        return false;\n      }\n\n    case 'function':\n      // compare functions for reference equality\n      if (set._nativeSet !== null) {\n        if (shouldAdd) {\n          prevSize = set._nativeSet.size;\n\n          set._nativeSet.add(item);\n\n          newSize = set._nativeSet.size;\n          return newSize === prevSize;\n        } else {\n          return set._nativeSet.has(item);\n        }\n      } else {\n        if (!(type in set._items)) {\n          if (shouldAdd) {\n            set._items[type] = [item];\n          }\n\n          return false;\n        }\n\n        if (!_includes(item, set._items[type])) {\n          if (shouldAdd) {\n            set._items[type].push(item);\n          }\n\n          return false;\n        }\n\n        return true;\n      }\n\n    case 'undefined':\n      if (set._items[type]) {\n        return true;\n      } else {\n        if (shouldAdd) {\n          set._items[type] = true;\n        }\n\n        return false;\n      }\n\n    case 'object':\n      if (item === null) {\n        if (!set._items['null']) {\n          if (shouldAdd) {\n            set._items['null'] = true;\n          }\n\n          return false;\n        }\n\n        return true;\n      }\n\n    /* falls through */\n\n    default:\n      // reduce the search size of heterogeneous sets by creating buckets\n      // for each type.\n      type = Object.prototype.toString.call(item);\n\n      if (!(type in set._items)) {\n        if (shouldAdd) {\n          set._items[type] = [item];\n        }\n\n        return false;\n      } // scan through all previously applied items\n\n\n      if (!_includes(item, set._items[type])) {\n        if (shouldAdd) {\n          set._items[type].push(item);\n        }\n\n        return false;\n      }\n\n      return true;\n  }\n} // A simple Set type that honours R.equals semantics\n\n\nmodule.exports = _Set;","function _aperture(n, list) {\n  var idx = 0;\n  var limit = list.length - (n - 1);\n  var acc = new Array(limit >= 0 ? limit : 0);\n\n  while (idx < limit) {\n    acc[idx] = Array.prototype.slice.call(list, idx, idx + n);\n    idx += 1;\n  }\n\n  return acc;\n}\n\nmodule.exports = _aperture;","function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0:\n      return function () {\n        return fn.apply(this, arguments);\n      };\n\n    case 1:\n      return function (a0) {\n        return fn.apply(this, arguments);\n      };\n\n    case 2:\n      return function (a0, a1) {\n        return fn.apply(this, arguments);\n      };\n\n    case 3:\n      return function (a0, a1, a2) {\n        return fn.apply(this, arguments);\n      };\n\n    case 4:\n      return function (a0, a1, a2, a3) {\n        return fn.apply(this, arguments);\n      };\n\n    case 5:\n      return function (a0, a1, a2, a3, a4) {\n        return fn.apply(this, arguments);\n      };\n\n    case 6:\n      return function (a0, a1, a2, a3, a4, a5) {\n        return fn.apply(this, arguments);\n      };\n\n    case 7:\n      return function (a0, a1, a2, a3, a4, a5, a6) {\n        return fn.apply(this, arguments);\n      };\n\n    case 8:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n        return fn.apply(this, arguments);\n      };\n\n    case 9:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n        return fn.apply(this, arguments);\n      };\n\n    case 10:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n        return fn.apply(this, arguments);\n      };\n\n    default:\n      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n}\n\nmodule.exports = _arity;","function _arrayFromIterator(iter) {\n  var list = [];\n  var next;\n\n  while (!(next = iter.next()).done) {\n    list.push(next.value);\n  }\n\n  return list;\n}\n\nmodule.exports = _arrayFromIterator;","var _isFunction =\n/*#__PURE__*/\nrequire(\"./_isFunction.js\");\n\nvar _toString =\n/*#__PURE__*/\nrequire(\"./_toString.js\");\n\nfunction _assertPromise(name, p) {\n  if (p == null || !_isFunction(p.then)) {\n    throw new TypeError('`' + name + '` expected a Promise, received ' + _toString(p, []));\n  }\n}\n\nmodule.exports = _assertPromise;","var _isArray =\n/*#__PURE__*/\nrequire(\"./_isArray.js\");\n\nvar _isInteger =\n/*#__PURE__*/\nrequire(\"./_isInteger.js\");\n/**\n * Makes a shallow clone of an object, setting or overriding the specified\n * property with the given value. Note that this copies and flattens prototype\n * properties onto the new object as well. All non-primitive properties are\n * copied by reference.\n *\n * @private\n * @param {String|Number} prop The property name to set\n * @param {*} val The new value\n * @param {Object|Array} obj The object to clone\n * @return {Object|Array} A new object equivalent to the original except for the changed property.\n */\n\n\nfunction _assoc(prop, val, obj) {\n  if (_isInteger(prop) && _isArray(obj)) {\n    var arr = [].concat(obj);\n    arr[prop] = val;\n    return arr;\n  }\n\n  var result = {};\n\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n\n  result[prop] = val;\n  return result;\n}\n\nmodule.exports = _assoc;","var _isArray =\n/*#__PURE__*/\nrequire(\"./_isArray.js\");\n/**\n * This checks whether a function has a [methodname] function. If it isn't an\n * array it will execute that function otherwise it will default to the ramda\n * implementation.\n *\n * @private\n * @param {Function} fn ramda implementation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\n\n\nfunction _checkForMethod(methodname, fn) {\n  return function () {\n    var length = arguments.length;\n\n    if (length === 0) {\n      return fn();\n    }\n\n    var obj = arguments[length - 1];\n    return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));\n  };\n}\n\nmodule.exports = _checkForMethod;","var _cloneRegExp =\n/*#__PURE__*/\nrequire(\"./_cloneRegExp.js\");\n\nvar type =\n/*#__PURE__*/\nrequire(\"../type.js\");\n/**\n * Copies an object.\n *\n * @private\n * @param {*} value The value to be copied\n * @param {Array} refFrom Array containing the source references\n * @param {Array} refTo Array containing the copied source references\n * @param {Boolean} deep Whether or not to perform deep cloning.\n * @return {*} The copied value.\n */\n\n\nfunction _clone(value, refFrom, refTo, deep) {\n  var copy = function copy(copiedValue) {\n    var len = refFrom.length;\n    var idx = 0;\n\n    while (idx < len) {\n      if (value === refFrom[idx]) {\n        return refTo[idx];\n      }\n\n      idx += 1;\n    }\n\n    refFrom[idx] = value;\n    refTo[idx] = copiedValue;\n\n    for (var key in value) {\n      if (value.hasOwnProperty(key)) {\n        copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key];\n      }\n    }\n\n    return copiedValue;\n  };\n\n  switch (type(value)) {\n    case 'Object':\n      return copy(Object.create(Object.getPrototypeOf(value)));\n\n    case 'Array':\n      return copy([]);\n\n    case 'Date':\n      return new Date(value.valueOf());\n\n    case 'RegExp':\n      return _cloneRegExp(value);\n\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'BigInt64Array':\n    case 'BigUint64Array':\n      return value.slice();\n\n    default:\n      return value;\n  }\n}\n\nmodule.exports = _clone;","function _cloneRegExp(pattern) {\n  return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : ''));\n}\n\nmodule.exports = _cloneRegExp;","function _complement(f) {\n  return function () {\n    return !f.apply(this, arguments);\n  };\n}\n\nmodule.exports = _complement;","/**\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 */\nfunction _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n  idx = 0;\n\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n\n  idx = 0;\n\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n\n  return result;\n}\n\nmodule.exports = _concat;","var _arity =\n/*#__PURE__*/\nrequire(\"./_arity.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nfunction _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\nmodule.exports = _createPartialApplicator;","var _isPlaceholder =\n/*#__PURE__*/\nrequire(\"./_isPlaceholder.js\");\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\n\nfunction _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\nmodule.exports = _curry1;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./_curry1.js\");\n\nvar _isPlaceholder =\n/*#__PURE__*/\nrequire(\"./_isPlaceholder.js\");\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\n\nfunction _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n\n      case 1:\n        return _isPlaceholder(a) ? f2 : _curry1(function (_b) {\n          return fn(a, _b);\n        });\n\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b);\n        }) : fn(a, b);\n    }\n  };\n}\n\nmodule.exports = _curry2;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./_curry1.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _isPlaceholder =\n/*#__PURE__*/\nrequire(\"./_isPlaceholder.js\");\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\n\nfunction _curry3(fn) {\n  return function f3(a, b, c) {\n    switch (arguments.length) {\n      case 0:\n        return f3;\n\n      case 1:\n        return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        });\n\n      case 2:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _curry1(function (_c) {\n          return fn(a, b, _c);\n        });\n\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {\n          return fn(_a, _b, c);\n        }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b, c);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b, c);\n        }) : _isPlaceholder(c) ? _curry1(function (_c) {\n          return fn(a, b, _c);\n        }) : fn(a, b, c);\n    }\n  };\n}\n\nmodule.exports = _curry3;","var _arity =\n/*#__PURE__*/\nrequire(\"./_arity.js\");\n\nvar _isPlaceholder =\n/*#__PURE__*/\nrequire(\"./_isPlaceholder.js\");\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\n\n\nfunction _curryN(length, received, fn) {\n  return function () {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n\n      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n\n      combined[combinedIdx] = result;\n\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n\n      combinedIdx += 1;\n    }\n\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n}\n\nmodule.exports = _curryN;","var _isArray =\n/*#__PURE__*/\nrequire(\"./_isArray.js\");\n\nvar _isTransformer =\n/*#__PURE__*/\nrequire(\"./_isTransformer.js\");\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a function with one of the given method names, it will\n * execute that function (functor case). Otherwise, if it is a transformer,\n * uses transducer created by [transducerCreator] to return a new transformer\n * (transducer case).\n * Otherwise, it will default to executing [fn].\n *\n * @private\n * @param {Array} methodNames properties to check for a custom implementation\n * @param {Function} transducerCreator transducer factory if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\n\n\nfunction _dispatchable(methodNames, transducerCreator, fn) {\n  return function () {\n    if (arguments.length === 0) {\n      return fn();\n    }\n\n    var obj = arguments[arguments.length - 1];\n\n    if (!_isArray(obj)) {\n      var idx = 0;\n\n      while (idx < methodNames.length) {\n        if (typeof obj[methodNames[idx]] === 'function') {\n          return obj[methodNames[idx]].apply(obj, Array.prototype.slice.call(arguments, 0, -1));\n        }\n\n        idx += 1;\n      }\n\n      if (_isTransformer(obj)) {\n        var transducer = transducerCreator.apply(null, Array.prototype.slice.call(arguments, 0, -1));\n        return transducer(obj);\n      }\n    }\n\n    return fn.apply(this, arguments);\n  };\n}\n\nmodule.exports = _dispatchable;","var _isInteger =\n/*#__PURE__*/\nrequire(\"./_isInteger.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./_isArray.js\");\n\nvar remove =\n/*#__PURE__*/\nrequire(\"../remove.js\");\n/**\n * Returns a new object that does not contain a `prop` property.\n *\n * @private\n * @param {String|Number} prop The name of the property to dissociate\n * @param {Object|Array} obj The object to clone\n * @return {Object} A new object equivalent to the original but without the specified property\n */\n\n\nfunction _dissoc(prop, obj) {\n  if (obj == null) {\n    return obj;\n  }\n\n  if (_isInteger(prop) && _isArray(obj)) {\n    return remove(prop, 1, obj);\n  }\n\n  var result = {};\n\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n\n  delete result[prop];\n  return result;\n}\n\nmodule.exports = _dissoc;","var take =\n/*#__PURE__*/\nrequire(\"../take.js\");\n\nfunction dropLast(n, xs) {\n  return take(n < xs.length ? xs.length - n : 0, xs);\n}\n\nmodule.exports = dropLast;","var slice =\n/*#__PURE__*/\nrequire(\"../slice.js\");\n\nfunction dropLastWhile(pred, xs) {\n  var idx = xs.length - 1;\n\n  while (idx >= 0 && pred(xs[idx])) {\n    idx -= 1;\n  }\n\n  return slice(0, idx + 1, xs);\n}\n\nmodule.exports = dropLastWhile;","var _arrayFromIterator =\n/*#__PURE__*/\nrequire(\"./_arrayFromIterator.js\");\n\nvar _includesWith =\n/*#__PURE__*/\nrequire(\"./_includesWith.js\");\n\nvar _functionName =\n/*#__PURE__*/\nrequire(\"./_functionName.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./_has.js\");\n\nvar _objectIs =\n/*#__PURE__*/\nrequire(\"./_objectIs.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"../keys.js\");\n\nvar type =\n/*#__PURE__*/\nrequire(\"../type.js\");\n/**\n * private _uniqContentEquals function.\n * That function is checking equality of 2 iterator contents with 2 assumptions\n * - iterators lengths are the same\n * - iterators values are unique\n *\n * false-positive result will be returned for comparison of, e.g.\n * - [1,2,3] and [1,2,3,4]\n * - [1,1,1] and [1,2,3]\n * */\n\n\nfunction _uniqContentEquals(aIterator, bIterator, stackA, stackB) {\n  var a = _arrayFromIterator(aIterator);\n\n  var b = _arrayFromIterator(bIterator);\n\n  function eq(_a, _b) {\n    return _equals(_a, _b, stackA.slice(), stackB.slice());\n  } // if *a* array contains any element that is not included in *b*\n\n\n  return !_includesWith(function (b, aItem) {\n    return !_includesWith(eq, aItem, b);\n  }, b, a);\n}\n\nfunction _equals(a, b, stackA, stackB) {\n  if (_objectIs(a, b)) {\n    return true;\n  }\n\n  var typeA = type(a);\n\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {\n    return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);\n  }\n\n  if (typeof a.equals === 'function' || typeof b.equals === 'function') {\n    return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);\n  }\n\n  switch (typeA) {\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n      if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {\n        return a === b;\n      }\n\n      break;\n\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n      if (!(typeof a === typeof b && _objectIs(a.valueOf(), b.valueOf()))) {\n        return false;\n      }\n\n      break;\n\n    case 'Date':\n      if (!_objectIs(a.valueOf(), b.valueOf())) {\n        return false;\n      }\n\n      break;\n\n    case 'Error':\n      return a.name === b.name && a.message === b.message;\n\n    case 'RegExp':\n      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {\n        return false;\n      }\n\n      break;\n  }\n\n  var idx = stackA.length - 1;\n\n  while (idx >= 0) {\n    if (stackA[idx] === a) {\n      return stackB[idx] === b;\n    }\n\n    idx -= 1;\n  }\n\n  switch (typeA) {\n    case 'Map':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));\n\n    case 'Set':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));\n\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n    case 'Date':\n    case 'Error':\n    case 'RegExp':\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'ArrayBuffer':\n      break;\n\n    default:\n      // Values of other types are only equal if identical.\n      return false;\n  }\n\n  var keysA = keys(a);\n\n  if (keysA.length !== keys(b).length) {\n    return false;\n  }\n\n  var extendedStackA = stackA.concat([a]);\n  var extendedStackB = stackB.concat([b]);\n  idx = keysA.length - 1;\n\n  while (idx >= 0) {\n    var key = keysA[idx];\n\n    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {\n      return false;\n    }\n\n    idx -= 1;\n  }\n\n  return true;\n}\n\nmodule.exports = _equals;","function _filter(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n\n    idx += 1;\n  }\n\n  return result;\n}\n\nmodule.exports = _filter;","var _forceReduced =\n/*#__PURE__*/\nrequire(\"./_forceReduced.js\");\n\nvar _isArrayLike =\n/*#__PURE__*/\nrequire(\"./_isArrayLike.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./_reduce.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar preservingReduced = function (xf) {\n  return {\n    '@@transducer/init': _xfBase.init,\n    '@@transducer/result': function (result) {\n      return xf['@@transducer/result'](result);\n    },\n    '@@transducer/step': function (result, input) {\n      var ret = xf['@@transducer/step'](result, input);\n      return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;\n    }\n  };\n};\n\nvar _flatCat = function _xcat(xf) {\n  var rxf = preservingReduced(xf);\n  return {\n    '@@transducer/init': _xfBase.init,\n    '@@transducer/result': function (result) {\n      return rxf['@@transducer/result'](result);\n    },\n    '@@transducer/step': function (result, input) {\n      return !_isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);\n    }\n  };\n};\n\nmodule.exports = _flatCat;","function _forceReduced(x) {\n  return {\n    '@@transducer/value': x,\n    '@@transducer/reduced': true\n  };\n}\n\nmodule.exports = _forceReduced;","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\nmodule.exports = _functionName;","function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = _has;","function _identity(x) {\n  return x;\n}\n\nmodule.exports = _identity;","var _indexOf =\n/*#__PURE__*/\nrequire(\"./_indexOf.js\");\n\nfunction _includes(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n}\n\nmodule.exports = _includes;","function _includesWith(pred, x, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (pred(x, list[idx])) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n}\n\nmodule.exports = _includesWith;","var equals =\n/*#__PURE__*/\nrequire(\"../equals.js\");\n\nfunction _indexOf(list, a, idx) {\n  var inf, item; // Array.prototype.indexOf doesn't exist below IE9\n\n  if (typeof list.indexOf === 'function') {\n    switch (typeof a) {\n      case 'number':\n        if (a === 0) {\n          // manually crawl the list to distinguish between +0 and -0\n          inf = 1 / a;\n\n          while (idx < list.length) {\n            item = list[idx];\n\n            if (item === 0 && 1 / item === inf) {\n              return idx;\n            }\n\n            idx += 1;\n          }\n\n          return -1;\n        } else if (a !== a) {\n          // NaN\n          while (idx < list.length) {\n            item = list[idx];\n\n            if (typeof item === 'number' && item !== item) {\n              return idx;\n            }\n\n            idx += 1;\n          }\n\n          return -1;\n        } // non-zero numbers can utilise Set\n\n\n        return list.indexOf(a, idx);\n      // all these types can utilise Set\n\n      case 'string':\n      case 'boolean':\n      case 'function':\n      case 'undefined':\n        return list.indexOf(a, idx);\n\n      case 'object':\n        if (a === null) {\n          // null can utilise Set\n          return list.indexOf(a, idx);\n        }\n\n    }\n  } // anything else not covered above, defer to R.equals\n\n\n  while (idx < list.length) {\n    if (equals(list[idx], a)) {\n      return idx;\n    }\n\n    idx += 1;\n  }\n\n  return -1;\n}\n\nmodule.exports = _indexOf;","var _has =\n/*#__PURE__*/\nrequire(\"./_has.js\");\n\nvar toString = Object.prototype.toString;\n\nvar _isArguments =\n/*#__PURE__*/\nfunction () {\n  return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {\n    return toString.call(x) === '[object Arguments]';\n  } : function _isArguments(x) {\n    return _has('callee', x);\n  };\n}();\n\nmodule.exports = _isArguments;","/**\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 && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n};","var _curry1 =\n/*#__PURE__*/\nrequire(\"./_curry1.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./_isArray.js\");\n\nvar _isString =\n/*#__PURE__*/\nrequire(\"./_isString.js\");\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @private\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      _isArrayLike([]); //=> true\n *      _isArrayLike(true); //=> false\n *      _isArrayLike({}); //=> false\n *      _isArrayLike({length: 10}); //=> false\n *      _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n *      _isArrayLike({nodeType: 1, length: 1}) // => false\n */\n\n\nvar _isArrayLike =\n/*#__PURE__*/\n_curry1(function isArrayLike(x) {\n  if (_isArray(x)) {\n    return true;\n  }\n\n  if (!x) {\n    return false;\n  }\n\n  if (typeof x !== 'object') {\n    return false;\n  }\n\n  if (_isString(x)) {\n    return false;\n  }\n\n  if (x.length === 0) {\n    return true;\n  }\n\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n\n  return false;\n});\n\nmodule.exports = _isArrayLike;","function _isFunction(x) {\n  var type = Object.prototype.toString.call(x);\n  return type === '[object Function]' || type === '[object AsyncFunction]' || type === '[object GeneratorFunction]' || type === '[object AsyncGeneratorFunction]';\n}\n\nmodule.exports = _isFunction;","/**\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};","function _isNumber(x) {\n  return Object.prototype.toString.call(x) === '[object Number]';\n}\n\nmodule.exports = _isNumber;","function _isObject(x) {\n  return Object.prototype.toString.call(x) === '[object Object]';\n}\n\nmodule.exports = _isObject;","function _isPlaceholder(a) {\n  return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}\n\nmodule.exports = _isPlaceholder;","function _isRegExp(x) {\n  return Object.prototype.toString.call(x) === '[object RegExp]';\n}\n\nmodule.exports = _isRegExp;","function _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n}\n\nmodule.exports = _isString;","function _isTransformer(obj) {\n  return obj != null && typeof obj['@@transducer/step'] === 'function';\n}\n\nmodule.exports = _isTransformer;","/**\n * Tests whether or not an object is a typed array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is a typed array, `false` otherwise.\n * @example\n *\n *      _isTypedArray(new Uint8Array([])); //=> true\n *      _isTypedArray(new Float32Array([])); //=> true\n *      _isTypedArray([]); //=> false\n *      _isTypedArray(null); //=> false\n *      _isTypedArray({}); //=> false\n */\nfunction _isTypedArray(val) {\n  var type = Object.prototype.toString.call(val);\n  return type === '[object Uint8ClampedArray]' || type === '[object Int8Array]' || type === '[object Uint8Array]' || type === '[object Int16Array]' || type === '[object Uint16Array]' || type === '[object Int32Array]' || type === '[object Uint32Array]' || type === '[object Float32Array]' || type === '[object Float64Array]' || type === '[object BigInt64Array]' || type === '[object BigUint64Array]';\n}\n\nmodule.exports = _isTypedArray;","var _isArrayLike =\n/*#__PURE__*/\nrequire(\"./_isArrayLike.js\");\n/**\n * `_makeFlat` is a helper function that returns a one-level or fully recursive\n * function based on the flag passed in.\n *\n * @private\n */\n\n\nfunction _makeFlat(recursive) {\n  return function flatt(list) {\n    var value, jlen, j;\n    var result = [];\n    var idx = 0;\n    var ilen = list.length;\n\n    while (idx < ilen) {\n      if (_isArrayLike(list[idx])) {\n        value = recursive ? flatt(list[idx]) : list[idx];\n        j = 0;\n        jlen = value.length;\n\n        while (j < jlen) {\n          result[result.length] = value[j];\n          j += 1;\n        }\n      } else {\n        result[result.length] = list[idx];\n      }\n\n      idx += 1;\n    }\n\n    return result;\n  };\n}\n\nmodule.exports = _makeFlat;","function _map(fn, functor) {\n  var idx = 0;\n  var len = functor.length;\n  var result = Array(len);\n\n  while (idx < len) {\n    result[idx] = fn(functor[idx]);\n    idx += 1;\n  }\n\n  return result;\n}\n\nmodule.exports = _map;","var _isArray =\n/*#__PURE__*/\nrequire(\"./_isArray.js\");\n\nvar _isInteger =\n/*#__PURE__*/\nrequire(\"./_isInteger.js\");\n/**\n * Makes a shallow clone of an object, applying the given fn to 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 * @private\n * @param {String|Number} prop The property name to set\n * @param {Function} fn The function to apply to the property\n * @param {Object|Array} obj The object to clone\n * @return {Object|Array} A new object equivalent to the original except for the changed property.\n */\n\n\nfunction _modify(prop, fn, obj) {\n  if (_isInteger(prop) && _isArray(obj)) {\n    var arr = [].concat(obj);\n    arr[prop] = fn(arr[prop]);\n    return arr;\n  }\n\n  var result = {};\n\n  for (var p in obj) {\n    result[p] = obj[p];\n  }\n\n  result[prop] = fn(result[prop]);\n  return result;\n}\n\nmodule.exports = _modify;","var _has =\n/*#__PURE__*/\nrequire(\"./_has.js\"); // Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n\n\nfunction _objectAssign(target) {\n  if (target == null) {\n    throw new TypeError('Cannot convert undefined or null to object');\n  }\n\n  var output = Object(target);\n  var idx = 1;\n  var length = arguments.length;\n\n  while (idx < length) {\n    var source = arguments[idx];\n\n    if (source != null) {\n      for (var nextKey in source) {\n        if (_has(nextKey, source)) {\n          output[nextKey] = source[nextKey];\n        }\n      }\n    }\n\n    idx += 1;\n  }\n\n  return output;\n}\n\nmodule.exports = typeof Object.assign === 'function' ? Object.assign : _objectAssign;","// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\nfunction _objectIs(a, b) {\n  // SameValue algorithm\n  if (a === b) {\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n}\n\nmodule.exports = typeof Object.is === 'function' ? Object.is : _objectIs;","function _of(x) {\n  return [x];\n}\n\nmodule.exports = _of;","function _pipe(f, g) {\n  return function () {\n    return g.call(this, f.apply(this, arguments));\n  };\n}\n\nmodule.exports = _pipe;","function _promap(f, g, profunctor) {\n  return function (x) {\n    return g(profunctor(f(x)));\n  };\n}\n\nmodule.exports = _promap;","function _quote(s) {\n  var escaped = s.replace(/\\\\/g, '\\\\\\\\').replace(/[\\b]/g, '\\\\b') // \\b matches word boundary; [\\b] matches backspace\n  .replace(/\\f/g, '\\\\f').replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r').replace(/\\t/g, '\\\\t').replace(/\\v/g, '\\\\v').replace(/\\0/g, '\\\\0');\n  return '\"' + escaped.replace(/\"/g, '\\\\\"') + '\"';\n}\n\nmodule.exports = _quote;","var _isArrayLike =\n/*#__PURE__*/\nrequire(\"./_isArrayLike.js\");\n\nvar _xwrap =\n/*#__PURE__*/\nrequire(\"./_xwrap.js\");\n\nvar bind =\n/*#__PURE__*/\nrequire(\"../bind.js\");\n\nfunction _arrayReduce(xf, acc, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    acc = xf['@@transducer/step'](acc, list[idx]);\n\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n\n    idx += 1;\n  }\n\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _iterableReduce(xf, acc, iter) {\n  var step = iter.next();\n\n  while (!step.done) {\n    acc = xf['@@transducer/step'](acc, step.value);\n\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n\n    step = iter.next();\n  }\n\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _methodReduce(xf, acc, obj, methodName) {\n  return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));\n}\n\nvar symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n\nfunction _reduce(fn, acc, list) {\n  if (typeof fn === 'function') {\n    fn = _xwrap(fn);\n  }\n\n  if (_isArrayLike(list)) {\n    return _arrayReduce(fn, acc, list);\n  }\n\n  if (typeof list['fantasy-land/reduce'] === 'function') {\n    return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\n  }\n\n  if (list[symIterator] != null) {\n    return _iterableReduce(fn, acc, list[symIterator]());\n  }\n\n  if (typeof list.next === 'function') {\n    return _iterableReduce(fn, acc, list);\n  }\n\n  if (typeof list.reduce === 'function') {\n    return _methodReduce(fn, acc, list, 'reduce');\n  }\n\n  throw new TypeError('reduce: list must be array or iterable');\n}\n\nmodule.exports = _reduce;","function _reduced(x) {\n  return x && x['@@transducer/reduced'] ? x : {\n    '@@transducer/value': x,\n    '@@transducer/reduced': true\n  };\n}\n\nmodule.exports = _reduced;","var _objectAssign =\n/*#__PURE__*/\nrequire(\"./_objectAssign.js\");\n\nvar _identity =\n/*#__PURE__*/\nrequire(\"./_identity.js\");\n\nvar _isArrayLike =\n/*#__PURE__*/\nrequire(\"./_isArrayLike.js\");\n\nvar _isTransformer =\n/*#__PURE__*/\nrequire(\"./_isTransformer.js\");\n\nvar objOf =\n/*#__PURE__*/\nrequire(\"../objOf.js\");\n\nvar _stepCatArray = {\n  '@@transducer/init': Array,\n  '@@transducer/step': function (xs, x) {\n    xs.push(x);\n    return xs;\n  },\n  '@@transducer/result': _identity\n};\nvar _stepCatString = {\n  '@@transducer/init': String,\n  '@@transducer/step': function (a, b) {\n    return a + b;\n  },\n  '@@transducer/result': _identity\n};\nvar _stepCatObject = {\n  '@@transducer/init': Object,\n  '@@transducer/step': function (result, input) {\n    return _objectAssign(result, _isArrayLike(input) ? objOf(input[0], input[1]) : input);\n  },\n  '@@transducer/result': _identity\n};\n\nfunction _stepCat(obj) {\n  if (_isTransformer(obj)) {\n    return obj;\n  }\n\n  if (_isArrayLike(obj)) {\n    return _stepCatArray;\n  }\n\n  if (typeof obj === 'string') {\n    return _stepCatString;\n  }\n\n  if (typeof obj === 'object') {\n    return _stepCatObject;\n  }\n\n  throw new Error('Cannot create transformer for ' + obj);\n}\n\nmodule.exports = _stepCat;","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nvar pad = function pad(n) {\n  return (n < 10 ? '0' : '') + n;\n};\n\nvar _toISOString = typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n  return d.toISOString();\n} : function _toISOString(d) {\n  return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n};\n\nmodule.exports = _toISOString;","var _includes =\n/*#__PURE__*/\nrequire(\"./_includes.js\");\n\nvar _map =\n/*#__PURE__*/\nrequire(\"./_map.js\");\n\nvar _quote =\n/*#__PURE__*/\nrequire(\"./_quote.js\");\n\nvar _toISOString =\n/*#__PURE__*/\nrequire(\"./_toISOString.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"../keys.js\");\n\nvar reject =\n/*#__PURE__*/\nrequire(\"../reject.js\");\n\nfunction _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _includes(y, xs) ? '<Circular>' : _toString(y, xs);\n  }; //  mapPairs :: (Object, [String]) -> [String]\n\n\n  var mapPairs = function (obj, keys) {\n    return _map(function (k) {\n      return _quote(k) + ': ' + recur(obj[k]);\n    }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {\n        return /^\\d+$/.test(k);\n      }, keys(x)))).join(', ') + ']';\n\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n\n    case '[object Date]':\n      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';\n\n    case '[object Null]':\n      return 'null';\n\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n\n    case '[object Undefined]':\n      return 'undefined';\n\n    default:\n      if (typeof x.toString === 'function') {\n        var repr = x.toString();\n\n        if (repr !== '[object Object]') {\n          return repr;\n        }\n      }\n\n      return '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n}\n\nmodule.exports = _toString;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./_reduced.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XAll =\n/*#__PURE__*/\nfunction () {\n  function XAll(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.all = true;\n  }\n\n  XAll.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAll.prototype['@@transducer/result'] = function (result) {\n    if (this.all) {\n      result = this.xf['@@transducer/step'](result, true);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAll.prototype['@@transducer/step'] = function (result, input) {\n    if (!this.f(input)) {\n      this.all = false;\n      result = _reduced(this.xf['@@transducer/step'](result, false));\n    }\n\n    return result;\n  };\n\n  return XAll;\n}();\n\nvar _xall =\n/*#__PURE__*/\n_curry2(function _xall(f, xf) {\n  return new XAll(f, xf);\n});\n\nmodule.exports = _xall;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./_reduced.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XAny =\n/*#__PURE__*/\nfunction () {\n  function XAny(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.any = false;\n  }\n\n  XAny.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAny.prototype['@@transducer/result'] = function (result) {\n    if (!this.any) {\n      result = this.xf['@@transducer/step'](result, false);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAny.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f(input)) {\n      this.any = true;\n      result = _reduced(this.xf['@@transducer/step'](result, true));\n    }\n\n    return result;\n  };\n\n  return XAny;\n}();\n\nvar _xany =\n/*#__PURE__*/\n_curry2(function _xany(f, xf) {\n  return new XAny(f, xf);\n});\n\nmodule.exports = _xany;","var _concat =\n/*#__PURE__*/\nrequire(\"./_concat.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XAperture =\n/*#__PURE__*/\nfunction () {\n  function XAperture(n, xf) {\n    this.xf = xf;\n    this.pos = 0;\n    this.full = false;\n    this.acc = new Array(n);\n  }\n\n  XAperture.prototype['@@transducer/init'] = _xfBase.init;\n\n  XAperture.prototype['@@transducer/result'] = function (result) {\n    this.acc = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XAperture.prototype['@@transducer/step'] = function (result, input) {\n    this.store(input);\n    return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result;\n  };\n\n  XAperture.prototype.store = function (input) {\n    this.acc[this.pos] = input;\n    this.pos += 1;\n\n    if (this.pos === this.acc.length) {\n      this.pos = 0;\n      this.full = true;\n    }\n  };\n\n  XAperture.prototype.getCopy = function () {\n    return _concat(Array.prototype.slice.call(this.acc, this.pos), Array.prototype.slice.call(this.acc, 0, this.pos));\n  };\n\n  return XAperture;\n}();\n\nvar _xaperture =\n/*#__PURE__*/\n_curry2(function _xaperture(n, xf) {\n  return new XAperture(n, xf);\n});\n\nmodule.exports = _xaperture;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _flatCat =\n/*#__PURE__*/\nrequire(\"./_flatCat.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"../map.js\");\n\nvar _xchain =\n/*#__PURE__*/\n_curry2(function _xchain(f, xf) {\n  return map(f, _flatCat(xf));\n});\n\nmodule.exports = _xchain;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XDrop =\n/*#__PURE__*/\nfunction () {\n  function XDrop(n, xf) {\n    this.xf = xf;\n    this.n = n;\n  }\n\n  XDrop.prototype['@@transducer/init'] = _xfBase.init;\n  XDrop.prototype['@@transducer/result'] = _xfBase.result;\n\n  XDrop.prototype['@@transducer/step'] = function (result, input) {\n    if (this.n > 0) {\n      this.n -= 1;\n      return result;\n    }\n\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return XDrop;\n}();\n\nvar _xdrop =\n/*#__PURE__*/\n_curry2(function _xdrop(n, xf) {\n  return new XDrop(n, xf);\n});\n\nmodule.exports = _xdrop;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XDropLast =\n/*#__PURE__*/\nfunction () {\n  function XDropLast(n, xf) {\n    this.xf = xf;\n    this.pos = 0;\n    this.full = false;\n    this.acc = new Array(n);\n  }\n\n  XDropLast.prototype['@@transducer/init'] = _xfBase.init;\n\n  XDropLast.prototype['@@transducer/result'] = function (result) {\n    this.acc = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XDropLast.prototype['@@transducer/step'] = function (result, input) {\n    if (this.full) {\n      result = this.xf['@@transducer/step'](result, this.acc[this.pos]);\n    }\n\n    this.store(input);\n    return result;\n  };\n\n  XDropLast.prototype.store = function (input) {\n    this.acc[this.pos] = input;\n    this.pos += 1;\n\n    if (this.pos === this.acc.length) {\n      this.pos = 0;\n      this.full = true;\n    }\n  };\n\n  return XDropLast;\n}();\n\nvar _xdropLast =\n/*#__PURE__*/\n_curry2(function _xdropLast(n, xf) {\n  return new XDropLast(n, xf);\n});\n\nmodule.exports = _xdropLast;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./_reduce.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XDropLastWhile =\n/*#__PURE__*/\nfunction () {\n  function XDropLastWhile(fn, xf) {\n    this.f = fn;\n    this.retained = [];\n    this.xf = xf;\n  }\n\n  XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;\n\n  XDropLastWhile.prototype['@@transducer/result'] = function (result) {\n    this.retained = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XDropLastWhile.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.retain(result, input) : this.flush(result, input);\n  };\n\n  XDropLastWhile.prototype.flush = function (result, input) {\n    result = _reduce(this.xf['@@transducer/step'], result, this.retained);\n    this.retained = [];\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  XDropLastWhile.prototype.retain = function (result, input) {\n    this.retained.push(input);\n    return result;\n  };\n\n  return XDropLastWhile;\n}();\n\nvar _xdropLastWhile =\n/*#__PURE__*/\n_curry2(function _xdropLastWhile(fn, xf) {\n  return new XDropLastWhile(fn, xf);\n});\n\nmodule.exports = _xdropLastWhile;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XDropRepeatsWith =\n/*#__PURE__*/\nfunction () {\n  function XDropRepeatsWith(pred, xf) {\n    this.xf = xf;\n    this.pred = pred;\n    this.lastValue = undefined;\n    this.seenFirstValue = false;\n  }\n\n  XDropRepeatsWith.prototype['@@transducer/init'] = _xfBase.init;\n  XDropRepeatsWith.prototype['@@transducer/result'] = _xfBase.result;\n\n  XDropRepeatsWith.prototype['@@transducer/step'] = function (result, input) {\n    var sameAsLast = false;\n\n    if (!this.seenFirstValue) {\n      this.seenFirstValue = true;\n    } else if (this.pred(this.lastValue, input)) {\n      sameAsLast = true;\n    }\n\n    this.lastValue = input;\n    return sameAsLast ? result : this.xf['@@transducer/step'](result, input);\n  };\n\n  return XDropRepeatsWith;\n}();\n\nvar _xdropRepeatsWith =\n/*#__PURE__*/\n_curry2(function _xdropRepeatsWith(pred, xf) {\n  return new XDropRepeatsWith(pred, xf);\n});\n\nmodule.exports = _xdropRepeatsWith;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XDropWhile =\n/*#__PURE__*/\nfunction () {\n  function XDropWhile(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XDropWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XDropWhile.prototype['@@transducer/result'] = _xfBase.result;\n\n  XDropWhile.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f) {\n      if (this.f(input)) {\n        return result;\n      }\n\n      this.f = null;\n    }\n\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return XDropWhile;\n}();\n\nvar _xdropWhile =\n/*#__PURE__*/\n_curry2(function _xdropWhile(f, xf) {\n  return new XDropWhile(f, xf);\n});\n\nmodule.exports = _xdropWhile;","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};","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XFilter =\n/*#__PURE__*/\nfunction () {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n\n  XFilter.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return XFilter;\n}();\n\nvar _xfilter =\n/*#__PURE__*/\n_curry2(function _xfilter(f, xf) {\n  return new XFilter(f, xf);\n});\n\nmodule.exports = _xfilter;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./_reduced.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XFind =\n/*#__PURE__*/\nfunction () {\n  function XFind(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.found = false;\n  }\n\n  XFind.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFind.prototype['@@transducer/result'] = function (result) {\n    if (!this.found) {\n      result = this.xf['@@transducer/step'](result, void 0);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XFind.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f(input)) {\n      this.found = true;\n      result = _reduced(this.xf['@@transducer/step'](result, input));\n    }\n\n    return result;\n  };\n\n  return XFind;\n}();\n\nvar _xfind =\n/*#__PURE__*/\n_curry2(function _xfind(f, xf) {\n  return new XFind(f, xf);\n});\n\nmodule.exports = _xfind;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./_reduced.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XFindIndex =\n/*#__PURE__*/\nfunction () {\n  function XFindIndex(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.idx = -1;\n    this.found = false;\n  }\n\n  XFindIndex.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFindIndex.prototype['@@transducer/result'] = function (result) {\n    if (!this.found) {\n      result = this.xf['@@transducer/step'](result, -1);\n    }\n\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XFindIndex.prototype['@@transducer/step'] = function (result, input) {\n    this.idx += 1;\n\n    if (this.f(input)) {\n      this.found = true;\n      result = _reduced(this.xf['@@transducer/step'](result, this.idx));\n    }\n\n    return result;\n  };\n\n  return XFindIndex;\n}();\n\nvar _xfindIndex =\n/*#__PURE__*/\n_curry2(function _xfindIndex(f, xf) {\n  return new XFindIndex(f, xf);\n});\n\nmodule.exports = _xfindIndex;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XFindLast =\n/*#__PURE__*/\nfunction () {\n  function XFindLast(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XFindLast.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFindLast.prototype['@@transducer/result'] = function (result) {\n    return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));\n  };\n\n  XFindLast.prototype['@@transducer/step'] = function (result, input) {\n    if (this.f(input)) {\n      this.last = input;\n    }\n\n    return result;\n  };\n\n  return XFindLast;\n}();\n\nvar _xfindLast =\n/*#__PURE__*/\n_curry2(function _xfindLast(f, xf) {\n  return new XFindLast(f, xf);\n});\n\nmodule.exports = _xfindLast;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XFindLastIndex =\n/*#__PURE__*/\nfunction () {\n  function XFindLastIndex(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.idx = -1;\n    this.lastIdx = -1;\n  }\n\n  XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;\n\n  XFindLastIndex.prototype['@@transducer/result'] = function (result) {\n    return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));\n  };\n\n  XFindLastIndex.prototype['@@transducer/step'] = function (result, input) {\n    this.idx += 1;\n\n    if (this.f(input)) {\n      this.lastIdx = this.idx;\n    }\n\n    return result;\n  };\n\n  return XFindLastIndex;\n}();\n\nvar _xfindLastIndex =\n/*#__PURE__*/\n_curry2(function _xfindLastIndex(f, xf) {\n  return new XFindLastIndex(f, xf);\n});\n\nmodule.exports = _xfindLastIndex;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XMap =\n/*#__PURE__*/\nfunction () {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n\n  XMap.prototype['@@transducer/step'] = function (result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return XMap;\n}();\n\nvar _xmap =\n/*#__PURE__*/\n_curry2(function _xmap(f, xf) {\n  return new XMap(f, xf);\n});\n\nmodule.exports = _xmap;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./_curry3.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar _promap =\n/*#__PURE__*/\nrequire(\"./_promap.js\");\n\nvar XPromap =\n/*#__PURE__*/\nfunction () {\n  function XPromap(f, g, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.g = g;\n  }\n\n  XPromap.prototype['@@transducer/init'] = _xfBase.init;\n  XPromap.prototype['@@transducer/result'] = _xfBase.result;\n\n  XPromap.prototype['@@transducer/step'] = function (result, input) {\n    return this.xf['@@transducer/step'](result, _promap(this.f, this.g, input));\n  };\n\n  return XPromap;\n}();\n\nvar _xpromap =\n/*#__PURE__*/\n_curry3(function _xpromap(f, g, xf) {\n  return new XPromap(f, g, xf);\n});\n\nmodule.exports = _xpromap;","var _curryN =\n/*#__PURE__*/\nrequire(\"./_curryN.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./_has.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XReduceBy =\n/*#__PURE__*/\nfunction () {\n  function XReduceBy(valueFn, valueAcc, keyFn, xf) {\n    this.valueFn = valueFn;\n    this.valueAcc = valueAcc;\n    this.keyFn = keyFn;\n    this.xf = xf;\n    this.inputs = {};\n  }\n\n  XReduceBy.prototype['@@transducer/init'] = _xfBase.init;\n\n  XReduceBy.prototype['@@transducer/result'] = function (result) {\n    var key;\n\n    for (key in this.inputs) {\n      if (_has(key, this.inputs)) {\n        result = this.xf['@@transducer/step'](result, this.inputs[key]);\n\n        if (result['@@transducer/reduced']) {\n          result = result['@@transducer/value'];\n          break;\n        }\n      }\n    }\n\n    this.inputs = null;\n    return this.xf['@@transducer/result'](result);\n  };\n\n  XReduceBy.prototype['@@transducer/step'] = function (result, input) {\n    var key = this.keyFn(input);\n    this.inputs[key] = this.inputs[key] || [key, this.valueAcc];\n    this.inputs[key][1] = this.valueFn(this.inputs[key][1], input);\n    return result;\n  };\n\n  return XReduceBy;\n}();\n\nvar _xreduceBy =\n/*#__PURE__*/\n_curryN(4, [], function _xreduceBy(valueFn, valueAcc, keyFn, xf) {\n  return new XReduceBy(valueFn, valueAcc, keyFn, xf);\n});\n\nmodule.exports = _xreduceBy;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./_reduced.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XTake =\n/*#__PURE__*/\nfunction () {\n  function XTake(n, xf) {\n    this.xf = xf;\n    this.n = n;\n    this.i = 0;\n  }\n\n  XTake.prototype['@@transducer/init'] = _xfBase.init;\n  XTake.prototype['@@transducer/result'] = _xfBase.result;\n\n  XTake.prototype['@@transducer/step'] = function (result, input) {\n    this.i += 1;\n    var ret = this.n === 0 ? result : this.xf['@@transducer/step'](result, input);\n    return this.n >= 0 && this.i >= this.n ? _reduced(ret) : ret;\n  };\n\n  return XTake;\n}();\n\nvar _xtake =\n/*#__PURE__*/\n_curry2(function _xtake(n, xf) {\n  return new XTake(n, xf);\n});\n\nmodule.exports = _xtake;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./_reduced.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XTakeWhile =\n/*#__PURE__*/\nfunction () {\n  function XTakeWhile(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;\n\n  XTakeWhile.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);\n  };\n\n  return XTakeWhile;\n}();\n\nvar _xtakeWhile =\n/*#__PURE__*/\n_curry2(function _xtakeWhile(f, xf) {\n  return new XTakeWhile(f, xf);\n});\n\nmodule.exports = _xtakeWhile;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XTap =\n/*#__PURE__*/\nfunction () {\n  function XTap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n\n  XTap.prototype['@@transducer/init'] = _xfBase.init;\n  XTap.prototype['@@transducer/result'] = _xfBase.result;\n\n  XTap.prototype['@@transducer/step'] = function (result, input) {\n    this.f(input);\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return XTap;\n}();\n\nvar _xtap =\n/*#__PURE__*/\n_curry2(function _xtap(f, xf) {\n  return new XTap(f, xf);\n});\n\nmodule.exports = _xtap;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _Set =\n/*#__PURE__*/\nrequire(\"./_Set.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XUniqBy =\n/*#__PURE__*/\nfunction () {\n  function XUniqBy(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.set = new _Set();\n  }\n\n  XUniqBy.prototype['@@transducer/init'] = _xfBase.init;\n  XUniqBy.prototype['@@transducer/result'] = _xfBase.result;\n\n  XUniqBy.prototype['@@transducer/step'] = function (result, input) {\n    return this.set.add(this.f(input)) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return XUniqBy;\n}();\n\nvar _xuniqBy =\n/*#__PURE__*/\n_curry2(function _xuniqBy(f, xf) {\n  return new XUniqBy(f, xf);\n});\n\nmodule.exports = _xuniqBy;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./_curry2.js\");\n\nvar _includesWith =\n/*#__PURE__*/\nrequire(\"./_includesWith.js\");\n\nvar _xfBase =\n/*#__PURE__*/\nrequire(\"./_xfBase.js\");\n\nvar XUniqWith =\n/*#__PURE__*/\nfunction () {\n  function XUniqWith(pred, xf) {\n    this.xf = xf;\n    this.pred = pred;\n    this.items = [];\n  }\n\n  XUniqWith.prototype['@@transducer/init'] = _xfBase.init;\n  XUniqWith.prototype['@@transducer/result'] = _xfBase.result;\n\n  XUniqWith.prototype['@@transducer/step'] = function (result, input) {\n    if (_includesWith(this.pred, input, this.items)) {\n      return result;\n    } else {\n      this.items.push(input);\n      return this.xf['@@transducer/step'](result, input);\n    }\n  };\n\n  return XUniqWith;\n}();\n\nvar _xuniqWith =\n/*#__PURE__*/\n_curry2(function _xuniqWith(pred, xf) {\n  return new XUniqWith(pred, xf);\n});\n\nmodule.exports = _xuniqWith;","var XWrap =\n/*#__PURE__*/\nfunction () {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n\n  XWrap.prototype['@@transducer/init'] = function () {\n    throw new Error('init not implemented on XWrap');\n  };\n\n  XWrap.prototype['@@transducer/result'] = function (acc) {\n    return acc;\n  };\n\n  XWrap.prototype['@@transducer/step'] = function (acc, x) {\n    return this.f(acc, x);\n  };\n\n  return XWrap;\n}();\n\nfunction _xwrap(fn) {\n  return new XWrap(fn);\n}\n\nmodule.exports = _xwrap;","var _includes =\n/*#__PURE__*/\nrequire(\"./internal/_includes.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _filter =\n/*#__PURE__*/\nrequire(\"./internal/_filter.js\");\n\nvar flip =\n/*#__PURE__*/\nrequire(\"./flip.js\");\n\nvar uniq =\n/*#__PURE__*/\nrequire(\"./uniq.js\");\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of those\n * elements common to both lists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The list of elements found in both `list1` and `list2`.\n * @see R.innerJoin\n * @example\n *\n *      R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]\n */\n\n\nvar intersection =\n/*#__PURE__*/\n_curry2(function intersection(list1, list2) {\n  var lookupList, filteredList;\n\n  if (list1.length > list2.length) {\n    lookupList = list1;\n    filteredList = list2;\n  } else {\n    lookupList = list2;\n    filteredList = list1;\n  }\n\n  return uniq(_filter(flip(_includes)(lookupList), filteredList));\n});\n\nmodule.exports = intersection;","var _checkForMethod =\n/*#__PURE__*/\nrequire(\"./internal/_checkForMethod.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Creates a new list with the separator interposed between elements.\n *\n * Dispatches to the `intersperse` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} separator The element to add to the list.\n * @param {Array} list The list to be interposed.\n * @return {Array} The new list.\n * @example\n *\n *      R.intersperse('a', ['b', 'n', 'n', 's']); //=> ['b', 'a', 'n', 'a', 'n', 'a', 's']\n */\n\n\nvar intersperse =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_checkForMethod('intersperse', function intersperse(separator, list) {\n  var out = [];\n  var idx = 0;\n  var length = list.length;\n\n  while (idx < length) {\n    if (idx === length - 1) {\n      out.push(list[idx]);\n    } else {\n      out.push(list[idx], separator);\n    }\n\n    idx += 1;\n  }\n\n  return out;\n}));\n\nmodule.exports = intersperse;","var _clone =\n/*#__PURE__*/\nrequire(\"./internal/_clone.js\");\n\nvar _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _isTransformer =\n/*#__PURE__*/\nrequire(\"./internal/_isTransformer.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar _stepCat =\n/*#__PURE__*/\nrequire(\"./internal/_stepCat.js\");\n/**\n * Transforms the items of the list with the transducer and appends the\n * transformed items to the accumulator using an appropriate iterator function\n * based on the accumulator type.\n *\n * The accumulator can be an array, string, object or a transformer. Iterated\n * items will be appended to arrays and concatenated to strings. Objects will\n * be merged directly or 2-item arrays will be merged as key, value pairs.\n *\n * The accumulator can also be a transformer object that provides a 2-arity\n * reducing iterator function, step, 0-arity initial value function, init, and\n * 1-arity result extraction function result. The step function is used as the\n * iterator function in reduce. The result function is used to convert the\n * final accumulator into the return type and in most cases is R.identity. The\n * init function is used to provide the initial accumulator.\n *\n * The iteration is performed with [`R.reduce`](#reduce) after initializing the\n * transducer.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig a -> (b -> b) -> [c] -> a\n * @param {*} acc The initial accumulator value.\n * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.transduce\n * @example\n *\n *      const numbers = [1, 2, 3, 4];\n *      const transducer = R.compose(R.map(R.add(1)), R.take(2));\n *\n *      R.into([], transducer, numbers); //=> [2, 3]\n *\n *      const intoArray = R.into([]);\n *      intoArray(transducer, numbers); //=> [2, 3]\n */\n\n\nvar into =\n/*#__PURE__*/\n_curry3(function into(acc, xf, list) {\n  return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list);\n});\n\nmodule.exports = into;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n/**\n * Same as [`R.invertObj`](#invertObj), however this accounts for objects with\n * duplicate values by putting the values into an array.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {s: x} -> {x: [ s, ... ]}\n * @param {Object} obj The object or array to invert\n * @return {Object} out A new object with keys in an array.\n * @see R.invertObj\n * @example\n *\n *      const raceResultsByFirstName = {\n *        first: 'alice',\n *        second: 'jake',\n *        third: 'alice',\n *      };\n *      R.invert(raceResultsByFirstName);\n *      //=> { 'alice': ['first', 'third'], 'jake':['second'] }\n */\n\n\nvar invert =\n/*#__PURE__*/\n_curry1(function invert(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var idx = 0;\n  var out = {};\n\n  while (idx < len) {\n    var key = props[idx];\n    var val = obj[key];\n    var list = _has(val, out) ? out[val] : out[val] = [];\n    list[list.length] = key;\n    idx += 1;\n  }\n\n  return out;\n});\n\nmodule.exports = invert;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n/**\n * Returns a new object with the keys of the given object as values, and the\n * values of the given object, which are coerced to strings, as keys. Note\n * that the last key found is preferred when handling the same value.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig {s: x} -> {x: s}\n * @param {Object} obj The object or array to invert\n * @return {Object} out A new object\n * @see R.invert\n * @example\n *\n *      const raceResults = {\n *        first: 'alice',\n *        second: 'jake'\n *      };\n *      R.invertObj(raceResults);\n *      //=> { 'alice': 'first', 'jake':'second' }\n *\n *      // Alternatively:\n *      const raceResults = ['alice', 'jake'];\n *      R.invertObj(raceResults);\n *      //=> { 'alice': '0', 'jake':'1' }\n */\n\n\nvar invertObj =\n/*#__PURE__*/\n_curry1(function invertObj(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var idx = 0;\n  var out = {};\n\n  while (idx < len) {\n    var key = props[idx];\n    out[obj[key]] = key;\n    idx += 1;\n  }\n\n  return out;\n});\n\nmodule.exports = invertObj;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isFunction =\n/*#__PURE__*/\nrequire(\"./internal/_isFunction.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar toString =\n/*#__PURE__*/\nrequire(\"./toString.js\");\n/**\n * Turns a named method with a specified arity into a function that can be\n * called directly supplied with arguments and a target object.\n *\n * The returned function is curried and accepts `arity + 1` parameters where\n * the final parameter is the target object.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)\n * @param {Number} arity Number of arguments the returned function should take\n *        before the target object.\n * @param {String} method Name of any of the target object's methods to call.\n * @return {Function} A new curried function.\n * @see R.construct\n * @example\n *\n *      const sliceFrom = R.invoker(1, 'slice');\n *      sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'\n *      const sliceFrom6 = R.invoker(2, 'slice')(6);\n *      sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'\n *\n *      const dog = {\n *        speak: async () => 'Woof!'\n *      };\n *      const speak = R.invoker(0, 'speak');\n *      speak(dog).then(console.log) //~> 'Woof!'\n *\n * @symb R.invoker(0, 'method')(o) = o['method']()\n * @symb R.invoker(1, 'method')(a, o) = o['method'](a)\n * @symb R.invoker(2, 'method')(a, b, o) = o['method'](a, b)\n */\n\n\nvar invoker =\n/*#__PURE__*/\n_curry2(function invoker(arity, method) {\n  return curryN(arity + 1, function () {\n    var target = arguments[arity];\n\n    if (target != null && _isFunction(target[method])) {\n      return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));\n    }\n\n    throw new TypeError(toString(target) + ' does not have a method named \"' + method + '\"');\n  });\n});\n\nmodule.exports = invoker;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * See if an object (i.e. `val`) is an instance of the supplied constructor. This\n * function will check up the inheritance chain, if any.\n * If `val` was created using `Object.create`, `R.is(Object, val) === true`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Type\n * @sig (* -> {*}) -> a -> Boolean\n * @param {Object} ctor A constructor\n * @param {*} val The value to test\n * @return {Boolean}\n * @example\n *\n *      R.is(Object, {}); //=> true\n *      R.is(Number, 1); //=> true\n *      R.is(Object, 1); //=> false\n *      R.is(String, 's'); //=> true\n *      R.is(String, new String('')); //=> true\n *      R.is(Object, new String('')); //=> true\n *      R.is(Object, 's'); //=> false\n *      R.is(Number, {}); //=> false\n */\n\n\nvar is =\n/*#__PURE__*/\n_curry2(function is(Ctor, val) {\n  return val instanceof Ctor || val != null && (val.constructor === Ctor || Ctor.name === 'Object' && typeof val === 'object');\n});\n\nmodule.exports = is;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar empty =\n/*#__PURE__*/\nrequire(\"./empty.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n/**\n * Returns `true` if the given value is its type's empty value; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> Boolean\n * @param {*} x\n * @return {Boolean}\n * @see R.empty\n * @example\n *\n *      R.isEmpty([1, 2, 3]);           //=> false\n *      R.isEmpty([]);                  //=> true\n *      R.isEmpty('');                  //=> true\n *      R.isEmpty(null);                //=> false\n *      R.isEmpty({});                  //=> true\n *      R.isEmpty({length: 0});         //=> false\n *      R.isEmpty(Uint8Array.from('')); //=> true\n */\n\n\nvar isEmpty =\n/*#__PURE__*/\n_curry1(function isEmpty(x) {\n  return x != null && equals(x, empty(x));\n});\n\nmodule.exports = isEmpty;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Checks if the input value is `null` or `undefined`.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Type\n * @sig * -> Boolean\n * @param {*} x The value to test.\n * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n * @example\n *\n *      R.isNil(null); //=> true\n *      R.isNil(undefined); //=> true\n *      R.isNil(0); //=> false\n *      R.isNil([]); //=> false\n */\n\n\nvar isNil =\n/*#__PURE__*/\n_curry1(function isNil(x) {\n  return x == null;\n});\n\nmodule.exports = isNil;","var invoker =\n/*#__PURE__*/\nrequire(\"./invoker.js\");\n/**\n * Returns a string made by inserting the `separator` between each element and\n * concatenating all the elements into a single string.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig String -> [a] -> String\n * @param {Number|String} separator The string used to separate the elements.\n * @param {Array} xs The elements to join into a string.\n * @return {String} str The string made by concatenating `xs` with `separator`.\n * @see R.split\n * @example\n *\n *      const spacer = R.join(' ');\n *      spacer(['a', 2, 3.4]);   //=> 'a 2 3.4'\n *      R.join('|', [1, 2, 3]);    //=> '1|2|3'\n */\n\n\nvar join =\n/*#__PURE__*/\ninvoker(1, 'join');\nmodule.exports = join;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar converge =\n/*#__PURE__*/\nrequire(\"./converge.js\");\n/**\n * juxt applies a list of functions to a list of values.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Function\n * @sig [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n])\n * @param {Array} fns An array of functions\n * @return {Function} A function that returns a list of values after applying each of the original `fns` to its parameters.\n * @see R.applySpec\n * @example\n *\n *      const getRange = R.juxt([Math.min, Math.max]);\n *      getRange(3, 4, 9, -3); //=> [-3, 9]\n * @symb R.juxt([f, g, h])(a, b) = [f(a, b), g(a, b), h(a, b)]\n */\n\n\nvar juxt =\n/*#__PURE__*/\n_curry1(function juxt(fns) {\n  return converge(function () {\n    return Array.prototype.slice.call(arguments, 0);\n  }, fns);\n});\n\nmodule.exports = juxt;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n\nvar _isArguments =\n/*#__PURE__*/\nrequire(\"./internal/_isArguments.js\"); // cover IE < 9 keys issues\n\n\nvar hasEnumBug = !\n/*#__PURE__*/\n{\n  toString: null\n}.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString']; // Safari bug\n\nvar hasArgsEnumBug =\n/*#__PURE__*/\nfunction () {\n  'use strict';\n\n  return arguments.propertyIsEnumerable('length');\n}();\n\nvar contains = function contains(list, item) {\n  var idx = 0;\n\n  while (idx < list.length) {\n    if (list[idx] === item) {\n      return true;\n    }\n\n    idx += 1;\n  }\n\n  return false;\n};\n/**\n * Returns a list containing the names of all the enumerable own properties of\n * the supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @see R.keysIn, R.values, R.toPairs\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\n\n\nvar keys = typeof Object.keys === 'function' && !hasArgsEnumBug ?\n/*#__PURE__*/\n_curry1(function keys(obj) {\n  return Object(obj) !== obj ? [] : Object.keys(obj);\n}) :\n/*#__PURE__*/\n_curry1(function keys(obj) {\n  if (Object(obj) !== obj) {\n    return [];\n  }\n\n  var prop, nIdx;\n  var ks = [];\n\n  var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n\n  for (prop in obj) {\n    if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n      ks[ks.length] = prop;\n    }\n  }\n\n  if (hasEnumBug) {\n    nIdx = nonEnumerableProps.length - 1;\n\n    while (nIdx >= 0) {\n      prop = nonEnumerableProps[nIdx];\n\n      if (_has(prop, obj) && !contains(ks, prop)) {\n        ks[ks.length] = prop;\n      }\n\n      nIdx -= 1;\n    }\n  }\n\n  return ks;\n});\nmodule.exports = keys;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Returns a list containing the names of all the properties of the supplied\n * object, including prototype properties.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own and prototype properties.\n * @see R.keys, R.valuesIn\n * @example\n *\n *      const F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      const f = new F();\n *      R.keysIn(f); //=> ['x', 'y']\n */\n\n\nvar keysIn =\n/*#__PURE__*/\n_curry1(function keysIn(obj) {\n  var prop;\n  var ks = [];\n\n  for (prop in obj) {\n    ks[ks.length] = prop;\n  }\n\n  return ks;\n});\n\nmodule.exports = keysIn;","var nth =\n/*#__PURE__*/\nrequire(\"./nth.js\");\n/**\n * Returns the last element of the given list or string.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.init, R.head, R.tail\n * @example\n *\n *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n *      R.last([]); //=> undefined\n *\n *      R.last('abc'); //=> 'c'\n *      R.last(''); //=> ''\n */\n\n\nvar last =\n/*#__PURE__*/\nnth(-1);\nmodule.exports = last;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n/**\n * Returns the position of the last occurrence of an item in an array, or -1 if\n * the item is not included in the array. [`R.equals`](#equals) is used to\n * determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Number\n * @param {*} target The item to find.\n * @param {Array} xs The array to search in.\n * @return {Number} the index of the target, or -1 if the target is not found.\n * @see R.indexOf, R.findLastIndex\n * @example\n *\n *      R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6\n *      R.lastIndexOf(10, [1,2,3,4]); //=> -1\n */\n\n\nvar lastIndexOf =\n/*#__PURE__*/\n_curry2(function lastIndexOf(target, xs) {\n  if (typeof xs.lastIndexOf === 'function' && !_isArray(xs)) {\n    return xs.lastIndexOf(target);\n  } else {\n    var idx = xs.length - 1;\n\n    while (idx >= 0) {\n      if (equals(xs[idx], target)) {\n        return idx;\n      }\n\n      idx -= 1;\n    }\n\n    return -1;\n  }\n});\n\nmodule.exports = lastIndexOf;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _isNumber =\n/*#__PURE__*/\nrequire(\"./internal/_isNumber.js\");\n/**\n * Returns the number of elements in the array by returning `list.length`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [a] -> Number\n * @param {Array} list The array to inspect.\n * @return {Number} The length of the array.\n * @example\n *\n *      R.length([]); //=> 0\n *      R.length([1, 2, 3]); //=> 3\n */\n\n\nvar length =\n/*#__PURE__*/\n_curry1(function length(list) {\n  return list != null && _isNumber(list.length) ? list.length : NaN;\n});\n\nmodule.exports = length;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n/**\n * Returns a lens for the given getter and setter functions. The getter \"gets\"\n * the value of the focus; the setter \"sets\" the value of the focus. The setter\n * should not mutate the data structure.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig (s -> a) -> ((a, s) -> s) -> Lens s a\n * @param {Function} getter\n * @param {Function} setter\n * @return {Lens}\n * @see R.view, R.set, R.over, R.lensIndex, R.lensProp\n * @example\n *\n *      const xLens = R.lens(R.prop('x'), R.assoc('x'));\n *\n *      R.view(xLens, {x: 1, y: 2});            //=> 1\n *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n */\n\n\nvar lens =\n/*#__PURE__*/\n_curry2(function lens(getter, setter) {\n  return function (toFunctorFn) {\n    return function (target) {\n      return map(function (focus) {\n        return setter(focus, target);\n      }, toFunctorFn(getter(target)));\n    };\n  };\n});\n\nmodule.exports = lens;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar lens =\n/*#__PURE__*/\nrequire(\"./lens.js\");\n\nvar nth =\n/*#__PURE__*/\nrequire(\"./nth.js\");\n\nvar update =\n/*#__PURE__*/\nrequire(\"./update.js\");\n/**\n * Returns a lens whose focus is the specified index.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Number -> Lens s a\n * @param {Number} n\n * @return {Lens}\n * @see R.view, R.set, R.over, R.nth\n * @example\n *\n *      const headLens = R.lensIndex(0);\n *\n *      R.view(headLens, ['a', 'b', 'c']);            //=> 'a'\n *      R.set(headLens, 'x', ['a', 'b', 'c']);        //=> ['x', 'b', 'c']\n *      R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']\n */\n\n\nvar lensIndex =\n/*#__PURE__*/\n_curry1(function lensIndex(n) {\n  return lens(nth(n), update(n));\n});\n\nmodule.exports = lensIndex;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar assocPath =\n/*#__PURE__*/\nrequire(\"./assocPath.js\");\n\nvar lens =\n/*#__PURE__*/\nrequire(\"./lens.js\");\n\nvar path =\n/*#__PURE__*/\nrequire(\"./path.js\");\n/**\n * Returns a lens whose focus is the specified path.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @typedefn Idx = String | Int | Symbol\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig [Idx] -> Lens s a\n * @param {Array} path The path to use.\n * @return {Lens}\n * @see R.view, R.set, R.over\n * @example\n *\n *      const xHeadYLens = R.lensPath(['x', 0, 'y']);\n *\n *      R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n *      //=> 2\n *      R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n *      //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}\n *      R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});\n *      //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}\n */\n\n\nvar lensPath =\n/*#__PURE__*/\n_curry1(function lensPath(p) {\n  return lens(path(p), assocPath(p));\n});\n\nmodule.exports = lensPath;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar assoc =\n/*#__PURE__*/\nrequire(\"./assoc.js\");\n\nvar lens =\n/*#__PURE__*/\nrequire(\"./lens.js\");\n\nvar prop =\n/*#__PURE__*/\nrequire(\"./prop.js\");\n/**\n * Returns a lens whose focus is the specified property.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig String -> Lens s a\n * @param {String} k\n * @return {Lens}\n * @see R.view, R.set, R.over\n * @example\n *\n *      const xLens = R.lensProp('x');\n *\n *      R.view(xLens, {x: 1, y: 2});            //=> 1\n *      R.set(xLens, 4, {x: 1, y: 2});          //=> {x: 4, y: 2}\n *      R.over(xLens, R.negate, {x: 1, y: 2});  //=> {x: -1, y: 2}\n */\n\n\nvar lensProp =\n/*#__PURE__*/\n_curry1(function lensProp(k) {\n  return lens(prop(k), assoc(k));\n});\n\nmodule.exports = lensProp;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar liftN =\n/*#__PURE__*/\nrequire(\"./liftN.js\");\n/**\n * \"lifts\" a function of arity >= 1 so that it may \"map over\" a list, Function or other\n * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.liftN\n * @example\n *\n *      const madd3 = R.lift((a, b, c) => a + b + c);\n *\n *      madd3([100, 200], [30, 40], [5, 6, 7]); //=> [135, 136, 137, 145, 146, 147, 235, 236, 237, 245, 246, 247]\n *\n *      const madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e);\n *\n *      madd5([10, 20], [1], [2, 3], [4], [100, 200]); //=> [117, 217, 118, 218, 127, 227, 128, 228]\n */\n\n\nvar lift =\n/*#__PURE__*/\n_curry1(function lift(fn) {\n  return liftN(fn.length, fn);\n});\n\nmodule.exports = lift;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar ap =\n/*#__PURE__*/\nrequire(\"./ap.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n/**\n * \"lifts\" a function to be the specified arity, so that it may \"map over\" that\n * many lists, Functions or other objects that satisfy the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig Number -> (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.lift, R.ap\n * @example\n *\n *      const madd3 = R.liftN(3, (...args) => R.sum(args));\n *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n */\n\n\nvar liftN =\n/*#__PURE__*/\n_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\nmodule.exports = liftN;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns `true` if the first argument is less than the second; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @see R.gt\n * @example\n *\n *      R.lt(2, 1); //=> false\n *      R.lt(2, 2); //=> false\n *      R.lt(2, 3); //=> true\n *      R.lt('a', 'z'); //=> true\n *      R.lt('z', 'a'); //=> false\n */\n\n\nvar lt =\n/*#__PURE__*/\n_curry2(function lt(a, b) {\n  return a < b;\n});\n\nmodule.exports = lt;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns `true` if the first argument is less than or equal to the second;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> Boolean\n * @param {Number} a\n * @param {Number} b\n * @return {Boolean}\n * @see R.gte\n * @example\n *\n *      R.lte(2, 1); //=> false\n *      R.lte(2, 2); //=> true\n *      R.lte(2, 3); //=> true\n *      R.lte('a', 'z'); //=> true\n *      R.lte('z', 'a'); //=> false\n */\n\n\nvar lte =\n/*#__PURE__*/\n_curry2(function lte(a, b) {\n  return a <= b;\n});\n\nmodule.exports = lte;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _map =\n/*#__PURE__*/\nrequire(\"./internal/_map.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar _xmap =\n/*#__PURE__*/\nrequire(\"./internal/_xmap.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n/**\n * Takes a function and\n * a [functor](https://github.com/fantasyland/fantasy-land#functor),\n * applies the function to each of the functor's values, and returns\n * a functor of the same shape.\n *\n * Ramda provides suitable `map` implementations for `Array` and `Object`,\n * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.\n *\n * Dispatches to the `map` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * Also treats functions as functors and will compose them together.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => (a -> b) -> f a -> f b\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @see R.transduce, R.addIndex, R.pluck, R.project\n * @example\n *\n *      const double = x => x * 2;\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n *\n *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}\n * @symb R.map(f, [a, b]) = [f(a), f(b)]\n * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }\n * @symb R.map(f, functor_o) = functor_o.map(f)\n */\n\n\nvar map =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {\n  switch (Object.prototype.toString.call(functor)) {\n    case '[object Function]':\n      return curryN(functor.length, function () {\n        return fn.call(this, functor.apply(this, arguments));\n      });\n\n    case '[object Object]':\n      return _reduce(function (acc, key) {\n        acc[key] = fn(functor[key]);\n        return acc;\n      }, {}, keys(functor));\n\n    default:\n      return _map(fn, functor);\n  }\n}));\n\nmodule.exports = map;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * The `mapAccum` function behaves like a combination of map and reduce; it\n * applies a function to each element of a list, passing an accumulating\n * parameter from left to right, and returning a final value of this\n * accumulator together with the new list.\n *\n * The iterator function receives two arguments, *acc* and *value*, and should\n * return a tuple *[acc, value]*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.scan, R.addIndex, R.mapAccumRight\n * @example\n *\n *      const digits = ['1', '2', '3', '4'];\n *      const appender = (a, b) => [a + b, a + b];\n *\n *      R.mapAccum(appender, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]\n * @symb R.mapAccum(f, a, [b, c, d]) = [\n *   f(f(f(a, b)[0], c)[0], d)[0],\n *   [\n *     f(a, b)[1],\n *     f(f(a, b)[0], c)[1],\n *     f(f(f(a, b)[0], c)[0], d)[1]\n *   ]\n * ]\n */\n\n\nvar mapAccum =\n/*#__PURE__*/\n_curry3(function mapAccum(fn, acc, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n  var tuple = [acc];\n\n  while (idx < len) {\n    tuple = fn(tuple[0], list[idx]);\n    result[idx] = tuple[1];\n    idx += 1;\n  }\n\n  return [tuple[0], result];\n});\n\nmodule.exports = mapAccum;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * The `mapAccumRight` function behaves like a combination of map and reduce; it\n * applies a function to each element of a list, passing an accumulating\n * parameter from right to left, and returning a final value of this\n * accumulator together with the new list.\n *\n * Similar to [`mapAccum`](#mapAccum), except moves through the input list from\n * the right to the left.\n *\n * The iterator function receives two arguments, *acc* and *value*, and should\n * return a tuple *[acc, value]*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y])\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.addIndex, R.mapAccum\n * @example\n *\n *      const digits = ['1', '2', '3', '4'];\n *      const appender = (a, b) => [b + a, b + a];\n *\n *      R.mapAccumRight(appender, 5, digits); //=> ['12345', ['12345', '2345', '345', '45']]\n * @symb R.mapAccumRight(f, a, [b, c, d]) = [\n *   f(f(f(a, d)[0], c)[0], b)[0],\n *   [\n *     f(a, d)[1],\n *     f(f(a, d)[0], c)[1],\n *     f(f(f(a, d)[0], c)[0], b)[1]\n *   ]\n * ]\n */\n\n\nvar mapAccumRight =\n/*#__PURE__*/\n_curry3(function mapAccumRight(fn, acc, list) {\n  var idx = list.length - 1;\n  var result = [];\n  var tuple = [acc];\n\n  while (idx >= 0) {\n    tuple = fn(tuple[0], list[idx]);\n    result[idx] = tuple[1];\n    idx -= 1;\n  }\n\n  return [tuple[0], result];\n});\n\nmodule.exports = mapAccumRight;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n/**\n * An Object-specific version of [`map`](#map). The function is applied to three\n * arguments: *(value, key, obj)*. If only the value is significant, use\n * [`map`](#map) instead.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Object\n * @sig ((*, String, Object) -> *) -> Object -> Object\n * @param {Function} fn\n * @param {Object} obj\n * @return {Object}\n * @see R.map\n * @example\n *\n *      const xyz = { x: 1, y: 2, z: 3 };\n *      const prependKeyAndDouble = (num, key, obj) => key + (num * 2);\n *\n *      R.mapObjIndexed(prependKeyAndDouble, xyz); //=> { x: 'x2', y: 'y4', z: 'z6' }\n */\n\n\nvar mapObjIndexed =\n/*#__PURE__*/\n_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\nmodule.exports = mapObjIndexed;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Tests a regular expression against a String. Note that this function will\n * return an empty array when there are no matches. This differs from\n * [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)\n * which returns `null` when there are no matches.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category String\n * @sig RegExp -> String -> [String | Undefined]\n * @param {RegExp} rx A regular expression.\n * @param {String} str The string to match against\n * @return {Array} The list of matches or empty array.\n * @see R.test\n * @example\n *\n *      R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']\n *      R.match(/a/, 'b'); //=> []\n *      R.match(/a/, null); //=> TypeError: null does not have a method named \"match\"\n */\n\n\nvar match =\n/*#__PURE__*/\n_curry2(function match(rx, str) {\n  return str.match(rx) || [];\n});\n\nmodule.exports = match;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isInteger =\n/*#__PURE__*/\nrequire(\"./internal/_isInteger.js\");\n/**\n * `mathMod` behaves like the modulo operator should mathematically, unlike the\n * `%` operator (and by extension, [`R.modulo`](#modulo)). So while\n * `-17 % 5` is `-2`, `mathMod(-17, 5)` is `3`. `mathMod` requires Integer\n * arguments, and returns NaN when the modulus is zero or negative.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} m The dividend.\n * @param {Number} p the modulus.\n * @return {Number} The result of `b mod a`.\n * @see R.modulo\n * @example\n *\n *      R.mathMod(-17, 5);  //=> 3\n *      R.mathMod(17, 5);   //=> 2\n *      R.mathMod(17, -5);  //=> NaN\n *      R.mathMod(17, 0);   //=> NaN\n *      R.mathMod(17.2, 5); //=> NaN\n *      R.mathMod(17, 5.3); //=> NaN\n *\n *      const clock = R.mathMod(R.__, 12);\n *      clock(15); //=> 3\n *      clock(24); //=> 0\n *\n *      const seventeenMod = R.mathMod(17);\n *      seventeenMod(3);  //=> 2\n *      seventeenMod(4);  //=> 1\n *      seventeenMod(10); //=> 7\n */\n\n\nvar mathMod =\n/*#__PURE__*/\n_curry2(function mathMod(m, p) {\n  if (!_isInteger(m)) {\n    return NaN;\n  }\n\n  if (!_isInteger(p) || p < 1) {\n    return NaN;\n  }\n\n  return (m % p + p) % p;\n});\n\nmodule.exports = mathMod;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns the larger of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.maxBy, R.min\n * @example\n *\n *      R.max(789, 123); //=> 789\n *      R.max('a', 'b'); //=> 'b'\n */\n\n\nvar max =\n/*#__PURE__*/\n_curry2(function max(a, b) {\n  return b > a ? b : a;\n});\n\nmodule.exports = max;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Takes a function and two values, and returns whichever value produces the\n * larger result when passed to the provided function.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Relation\n * @sig Ord b => (a -> b) -> a -> a -> a\n * @param {Function} f\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.max, R.minBy\n * @example\n *\n *      //  square :: Number -> Number\n *      const square = n => n * n;\n *\n *      R.maxBy(square, -3, 2); //=> -3\n *\n *      R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5\n *      R.reduce(R.maxBy(square), 0, []); //=> 0\n */\n\n\nvar maxBy =\n/*#__PURE__*/\n_curry3(function maxBy(f, a, b) {\n  return f(b) > f(a) ? b : a;\n});\n\nmodule.exports = maxBy;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar sum =\n/*#__PURE__*/\nrequire(\"./sum.js\");\n/**\n * Returns the mean of the given list of numbers.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list\n * @return {Number}\n * @see R.median\n * @example\n *\n *      R.mean([2, 7, 9]); //=> 6\n *      R.mean([]); //=> NaN\n */\n\n\nvar mean =\n/*#__PURE__*/\n_curry1(function mean(list) {\n  return sum(list) / list.length;\n});\n\nmodule.exports = mean;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar mean =\n/*#__PURE__*/\nrequire(\"./mean.js\");\n/**\n * Returns the median of the given list of numbers.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list\n * @return {Number}\n * @see R.mean\n * @example\n *\n *      R.median([2, 9, 7]); //=> 7\n *      R.median([7, 2, 10, 9]); //=> 8\n *      R.median([]); //=> NaN\n */\n\n\nvar median =\n/*#__PURE__*/\n_curry1(function median(list) {\n  var len = list.length;\n\n  if (len === 0) {\n    return NaN;\n  }\n\n  var width = 2 - len % 2;\n  var idx = (len - width) / 2;\n  return mean(Array.prototype.slice.call(list, 0).sort(function (a, b) {\n    return a < b ? -1 : a > b ? 1 : 0;\n  }).slice(idx, idx + width));\n});\n\nmodule.exports = median;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n/**\n * Creates a new function that, when invoked, caches the result of calling `fn`\n * for a given argument set and returns the result. Subsequent calls to the\n * memoized `fn` with the same argument set will not result in an additional\n * call to `fn`; instead, the cached result for that set of arguments will be\n * returned.\n *\n * Care must be taken when implementing key generation to avoid key collision,\n * or if tracking references, memory leaks and mutating arguments.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Function\n * @sig (*... -> String) -> (*... -> a) -> (*... -> a)\n * @param {Function} fn The function to generate the cache key.\n * @param {Function} fn The function to memoize.\n * @return {Function} Memoized version of `fn`.\n * @example\n *\n *      let count = 0;\n *      const factorial = R.memoizeWith(Number, n => {\n *        count += 1;\n *        return R.product(R.range(1, n + 1));\n *      });\n *      factorial(5); //=> 120\n *      factorial(5); //=> 120\n *      factorial(5); //=> 120\n *      count; //=> 1\n */\n\n\nvar memoizeWith =\n/*#__PURE__*/\n_curry2(function memoizeWith(mFn, fn) {\n  var cache = {};\n  return _arity(fn.length, function () {\n    var key = mFn.apply(this, arguments);\n\n    if (!_has(key, cache)) {\n      cache[key] = fn.apply(this, arguments);\n    }\n\n    return cache[key];\n  });\n});\n\nmodule.exports = memoizeWith;","var _objectAssign =\n/*#__PURE__*/\nrequire(\"./internal/_objectAssign.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Creates one new object with the own properties from a list of objects.\n * If a key exists in more than one object, the value from the last\n * object it exists in will be used.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig [{k: v}] -> {k: v}\n * @param {Array} list An array of objects\n * @return {Object} A merged object.\n * @see R.reduce\n * @example\n *\n *      R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}\n *      R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}\n * @symb R.mergeAll([{ x: 1 }, { y: 2 }, { z: 3 }]) = { x: 1, y: 2, z: 3 }\n */\n\n\nvar mergeAll =\n/*#__PURE__*/\n_curry1(function mergeAll(list) {\n  return _objectAssign.apply(null, [{}].concat(list));\n});\n\nmodule.exports = mergeAll;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar mergeDeepWithKey =\n/*#__PURE__*/\nrequire(\"./mergeDeepWithKey.js\");\n/**\n * Creates a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects:\n * - and both values are objects, the two values will be recursively merged\n * - otherwise the value from the first object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig {a} -> {a} -> {a}\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.merge, R.mergeDeepRight, R.mergeDeepWith, R.mergeDeepWithKey\n * @example\n *\n *      R.mergeDeepLeft({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},\n *                      { age: 40, contact: { email: 'baa@example.com' }});\n *      //=> { name: 'fred', age: 10, contact: { email: 'moo@example.com' }}\n */\n\n\nvar mergeDeepLeft =\n/*#__PURE__*/\n_curry2(function mergeDeepLeft(lObj, rObj) {\n  return mergeDeepWithKey(function (k, lVal, rVal) {\n    return lVal;\n  }, lObj, rObj);\n});\n\nmodule.exports = mergeDeepLeft;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar mergeDeepWithKey =\n/*#__PURE__*/\nrequire(\"./mergeDeepWithKey.js\");\n/**\n * Creates a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects:\n * - and both values are objects, the two values will be recursively merged\n * - otherwise the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig {a} -> {a} -> {a}\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.merge, R.mergeDeepLeft, R.mergeDeepWith, R.mergeDeepWithKey\n * @example\n *\n *      R.mergeDeepRight({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }},\n *                       { age: 40, contact: { email: 'baa@example.com' }});\n *      //=> { name: 'fred', age: 40, contact: { email: 'baa@example.com' }}\n */\n\n\nvar mergeDeepRight =\n/*#__PURE__*/\n_curry2(function mergeDeepRight(lObj, rObj) {\n  return mergeDeepWithKey(function (k, lVal, rVal) {\n    return rVal;\n  }, lObj, rObj);\n});\n\nmodule.exports = mergeDeepRight;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar mergeDeepWithKey =\n/*#__PURE__*/\nrequire(\"./mergeDeepWithKey.js\");\n/**\n * Creates a new object with the own properties of the two provided objects.\n * If a key exists in both objects:\n * - and both associated values are also objects then the values will be\n *   recursively merged.\n * - otherwise the provided function is applied to associated values using the\n *   resulting value as the new value associated with the key.\n * If a key only exists in one object, the value will be associated with the key\n * of the resulting object.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig ((a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.mergeWith, R.mergeDeepWithKey\n * @example\n *\n *      R.mergeDeepWith(R.concat,\n *                      { a: true, c: { values: [10, 20] }},\n *                      { b: true, c: { values: [15, 35] }});\n *      //=> { a: true, b: true, c: { values: [10, 20, 15, 35] }}\n */\n\n\nvar mergeDeepWith =\n/*#__PURE__*/\n_curry3(function mergeDeepWith(fn, lObj, rObj) {\n  return mergeDeepWithKey(function (k, lVal, rVal) {\n    return fn(lVal, rVal);\n  }, lObj, rObj);\n});\n\nmodule.exports = mergeDeepWith;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _isObject =\n/*#__PURE__*/\nrequire(\"./internal/_isObject.js\");\n\nvar mergeWithKey =\n/*#__PURE__*/\nrequire(\"./mergeWithKey.js\");\n/**\n * Creates a new object with the own properties of the two provided objects.\n * If a key exists in both objects:\n * - and both associated values are also objects then the values will be\n *   recursively merged.\n * - otherwise the provided function is applied to the key and associated values\n *   using the resulting value as the new value associated with the key.\n * If a key only exists in one object, the value will be associated with the key\n * of the resulting object.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Object\n * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} lObj\n * @param {Object} rObj\n * @return {Object}\n * @see R.mergeWithKey, R.mergeDeepWith\n * @example\n *\n *      let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r\n *      R.mergeDeepWithKey(concatValues,\n *                         { a: true, c: { thing: 'foo', values: [10, 20] }},\n *                         { b: true, c: { thing: 'bar', values: [15, 35] }});\n *      //=> { a: true, b: true, c: { thing: 'bar', values: [10, 20, 15, 35] }}\n */\n\n\nvar mergeDeepWithKey =\n/*#__PURE__*/\n_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\nmodule.exports = mergeDeepWithKey;","var _objectAssign =\n/*#__PURE__*/\nrequire(\"./internal/_objectAssign.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the first object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeRight, R.mergeDeepLeft, R.mergeWith, R.mergeWithKey\n * @example\n *\n *      R.mergeLeft({ 'age': 40 }, { 'name': 'fred', 'age': 10 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      const resetToDefault = R.mergeLeft({x: 0});\n *      resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}\n * @symb R.mergeLeft(a, b) = {...b, ...a}\n */\n\n\nvar mergeLeft =\n/*#__PURE__*/\n_curry2(function mergeLeft(l, r) {\n  return _objectAssign({}, r, l);\n});\n\nmodule.exports = mergeLeft;","var _objectAssign =\n/*#__PURE__*/\nrequire(\"./internal/_objectAssign.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Create a new object with the own properties of the first object merged with\n * the own properties of the second object. If a key exists in both objects,\n * the value from the second object will be used.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Object\n * @sig {k: v} -> {k: v} -> {k: v}\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeLeft, R.mergeDeepRight, R.mergeWith, R.mergeWithKey\n * @example\n *\n *      R.mergeRight({ 'name': 'fred', 'age': 10 }, { 'age': 40 });\n *      //=> { 'name': 'fred', 'age': 40 }\n *\n *      const withDefaults = R.mergeRight({x: 0, y: 0});\n *      withDefaults({y: 2}); //=> {x: 0, y: 2}\n * @symb R.mergeRight(a, b) = {...a, ...b}\n */\n\n\nvar mergeRight =\n/*#__PURE__*/\n_curry2(function mergeRight(l, r) {\n  return _objectAssign({}, l, r);\n});\n\nmodule.exports = mergeRight;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar mergeWithKey =\n/*#__PURE__*/\nrequire(\"./mergeWithKey.js\");\n/**\n * Creates a new object with the own properties of the two provided objects. If\n * a key exists in both objects, the provided function is applied to the values\n * associated with the key in each object, with the result being used as the\n * value associated with the key in the returned object.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @sig ((a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeDeepWith, R.merge, R.mergeWithKey\n * @example\n *\n *      R.mergeWith(R.concat,\n *                  { a: true, values: [10, 20] },\n *                  { b: true, values: [15, 35] });\n *      //=> { a: true, b: true, values: [10, 20, 15, 35] }\n */\n\n\nvar mergeWith =\n/*#__PURE__*/\n_curry3(function mergeWith(fn, l, r) {\n  return mergeWithKey(function (_, _l, _r) {\n    return fn(_l, _r);\n  }, l, r);\n});\n\nmodule.exports = mergeWith;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n/**\n * Creates a new object with the own properties of the two provided objects. If\n * a key exists in both objects, the provided function is applied to the key\n * and the values associated with the key in each object, with the result being\n * used as the value associated with the key in the returned object.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Object\n * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a}\n * @param {Function} fn\n * @param {Object} l\n * @param {Object} r\n * @return {Object}\n * @see R.mergeDeepWithKey, R.merge, R.mergeWith\n * @example\n *\n *      let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r\n *      R.mergeWithKey(concatValues,\n *                     { a: true, thing: 'foo', values: [10, 20] },\n *                     { b: true, thing: 'bar', values: [15, 35] });\n *      //=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] }\n * @symb R.mergeWithKey(f, { x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: f('y', 2, 5), z: 3 }\n */\n\n\nvar mergeWithKey =\n/*#__PURE__*/\n_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\nmodule.exports = mergeWithKey;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns the smaller of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.minBy, R.max\n * @example\n *\n *      R.min(789, 123); //=> 123\n *      R.min('a', 'b'); //=> 'a'\n */\n\n\nvar min =\n/*#__PURE__*/\n_curry2(function min(a, b) {\n  return b < a ? b : a;\n});\n\nmodule.exports = min;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Takes a function and two values, and returns whichever value produces the\n * smaller result when passed to the provided function.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Relation\n * @sig Ord b => (a -> b) -> a -> a -> a\n * @param {Function} f\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.min, R.maxBy\n * @example\n *\n *      //  square :: Number -> Number\n *      const square = n => n * n;\n *\n *      R.minBy(square, -3, 2); //=> 2\n *\n *      R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1\n *      R.reduce(R.minBy(square), Infinity, []); //=> Infinity\n */\n\n\nvar minBy =\n/*#__PURE__*/\n_curry3(function minBy(f, a, b) {\n  return f(b) < f(a) ? b : a;\n});\n\nmodule.exports = minBy;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar modifyPath =\n/*#__PURE__*/\nrequire(\"./modifyPath.js\");\n/**\n * Creates a copy of the passed object by applying an `fn` function to the given `prop` property.\n *\n * The function will not be invoked, and the object will not change\n * if its corresponding property does not exist in the object.\n * All non-primitive properties are copied to the new object by reference.\n *\n * @func\n * @memberOf R\n * @since v0.28.0\n * @category Object\n * @sig Idx -> (v -> v) -> {k: v} -> {k: v}\n * @param {String|Number} prop The property to be modified.\n * @param {Function} fn The function to apply to the property.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      const person = {name: 'James', age: 20, pets: ['dog', 'cat']};\n *      R.modify('age', R.add(1), person); //=> {name: 'James', age: 21, pets: ['dog', 'cat']}\n *      R.modify('pets', R.append('turtle'), person); //=> {name: 'James', age: 20, pets: ['dog', 'cat', 'turtle']}\n */\n\n\nvar modify =\n/*#__PURE__*/\n_curry3(function modify(prop, fn, object) {\n  return modifyPath([prop], fn, object);\n});\n\nmodule.exports = modify;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar _isObject =\n/*#__PURE__*/\nrequire(\"./internal/_isObject.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n\nvar _assoc =\n/*#__PURE__*/\nrequire(\"./internal/_assoc.js\");\n\nvar _modify =\n/*#__PURE__*/\nrequire(\"./internal/_modify.js\");\n/**\n * Creates a shallow clone of the passed object by applying an `fn` function\n * to the value at the given path.\n *\n * The function will not be invoked, and the object will not change\n * if its corresponding path does not exist in the object.\n * All non-primitive properties are copied to the new object by reference.\n *\n * @func\n * @memberOf R\n * @since v0.28.0\n * @category Object\n * @sig [Idx] -> (v -> v) -> {k: v} -> {k: v}\n * @param {Array} path The path to be modified.\n * @param {Function} fn The function to apply to the path.\n * @param {Object} object The object to be transformed.\n * @return {Object} The transformed object.\n * @example\n *\n *      const person = {name: 'James', address: { zipCode: '90216' }};\n *      R.modifyPath(['address', 'zipCode'], R.reverse, person); //=> {name: 'James', address: { zipCode: '61209' }}\n *\n *      // Can handle arrays too\n *      const person = {name: 'James', addresses: [{ zipCode: '90216' }]};\n *      R.modifyPath(['addresses', 0, 'zipCode'], R.reverse, person); //=> {name: 'James', addresses: [{ zipCode: '61209' }]}\n */\n\n\nvar modifyPath =\n/*#__PURE__*/\n_curry3(function modifyPath(path, fn, object) {\n  if (!_isObject(object) && !_isArray(object) || path.length === 0) {\n    return object;\n  }\n\n  var idx = path[0];\n\n  if (!_has(idx, object)) {\n    return object;\n  }\n\n  if (path.length === 1) {\n    return _modify(idx, fn, object);\n  }\n\n  var val = modifyPath(Array.prototype.slice.call(path, 1), fn, object[idx]);\n\n  if (val === object[idx]) {\n    return object;\n  }\n\n  return _assoc(idx, val, object);\n});\n\nmodule.exports = modifyPath;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Divides the first parameter by the second and returns the remainder. Note\n * that this function preserves the JavaScript-style behavior for modulo. For\n * mathematical modulo see [`mathMod`](#mathMod).\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The value to the divide.\n * @param {Number} b The pseudo-modulus\n * @return {Number} The result of `b % a`.\n * @see R.mathMod\n * @example\n *\n *      R.modulo(17, 3); //=> 2\n *      // JS behavior:\n *      R.modulo(-17, 3); //=> -2\n *      R.modulo(17, -3); //=> 2\n *\n *      const isOdd = R.modulo(R.__, 2);\n *      isOdd(42); //=> 0\n *      isOdd(21); //=> 1\n */\n\n\nvar modulo =\n/*#__PURE__*/\n_curry2(function modulo(a, b) {\n  return a % b;\n});\n\nmodule.exports = modulo;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Move an item, at index `from`, to index `to`, in a list of elements.\n * A new list will be created containing the new elements order.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @param {Number} from The source index\n * @param {Number} to The destination index\n * @param {Array} list The list which will serve to realise the move\n * @return {Array} The new list reordered\n * @example\n *\n *      R.move(0, 2, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['b', 'c', 'a', 'd', 'e', 'f']\n *      R.move(-1, 0, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['f', 'a', 'b', 'c', 'd', 'e'] list rotation\n */\n\n\nvar move =\n/*#__PURE__*/\n_curry3(function (from, to, list) {\n  var length = list.length;\n  var result = list.slice();\n  var positiveFrom = from < 0 ? length + from : from;\n  var positiveTo = to < 0 ? length + to : to;\n  var item = result.splice(positiveFrom, 1);\n  return positiveFrom < 0 || positiveFrom >= list.length || positiveTo < 0 || positiveTo >= list.length ? list : [].concat(result.slice(0, positiveTo)).concat(item).concat(result.slice(positiveTo, list.length));\n});\n\nmodule.exports = move;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Multiplies two numbers. Equivalent to `a * b` but curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a * b`.\n * @see R.divide\n * @example\n *\n *      const double = R.multiply(2);\n *      const triple = R.multiply(3);\n *      double(3);       //=>  6\n *      triple(4);       //=> 12\n *      R.multiply(2, 5);  //=> 10\n */\n\n\nvar multiply =\n/*#__PURE__*/\n_curry2(function multiply(a, b) {\n  return a * b;\n});\n\nmodule.exports = multiply;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly `n` parameters. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} n The desired arity of the new function.\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n *         arity `n`.\n * @see R.binary, R.unary\n * @example\n *\n *      const takesTwoArgs = (a, b) => [a, b];\n *\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      const takesOneArg = R.nAry(1, takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // Only `n` arguments are passed to the wrapped function\n *      takesOneArg(1, 2); //=> [1, undefined]\n * @symb R.nAry(0, f)(a, b) = f()\n * @symb R.nAry(1, f)(a, b) = f(a)\n * @symb R.nAry(2, f)(a, b) = f(a, b)\n */\n\n\nvar nAry =\n/*#__PURE__*/\n_curry2(function nAry(n, fn) {\n  switch (n) {\n    case 0:\n      return function () {\n        return fn.call(this);\n      };\n\n    case 1:\n      return function (a0) {\n        return fn.call(this, a0);\n      };\n\n    case 2:\n      return function (a0, a1) {\n        return fn.call(this, a0, a1);\n      };\n\n    case 3:\n      return function (a0, a1, a2) {\n        return fn.call(this, a0, a1, a2);\n      };\n\n    case 4:\n      return function (a0, a1, a2, a3) {\n        return fn.call(this, a0, a1, a2, a3);\n      };\n\n    case 5:\n      return function (a0, a1, a2, a3, a4) {\n        return fn.call(this, a0, a1, a2, a3, a4);\n      };\n\n    case 6:\n      return function (a0, a1, a2, a3, a4, a5) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5);\n      };\n\n    case 7:\n      return function (a0, a1, a2, a3, a4, a5, a6) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6);\n      };\n\n    case 8:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);\n      };\n\n    case 9:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);\n      };\n\n    case 10:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n        return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n      };\n\n    default:\n      throw new Error('First argument to nAry must be a non-negative integer no greater than ten');\n  }\n});\n\nmodule.exports = nAry;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Negates its argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Math\n * @sig Number -> Number\n * @param {Number} n\n * @return {Number}\n * @example\n *\n *      R.negate(42); //=> -42\n */\n\n\nvar negate =\n/*#__PURE__*/\n_curry1(function negate(n) {\n  return -n;\n});\n\nmodule.exports = negate;","var _complement =\n/*#__PURE__*/\nrequire(\"./internal/_complement.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar all =\n/*#__PURE__*/\nrequire(\"./all.js\");\n/**\n * Returns `true` if no elements of the list match the predicate, `false`\n * otherwise.\n *\n * Dispatches to the `all` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> Boolean\n * @param {Function} fn The predicate function.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.\n * @see R.all, R.any\n * @example\n *\n *      const isEven = n => n % 2 === 0;\n *      const isOdd = n => n % 2 !== 0;\n *\n *      R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true\n *      R.none(isOdd, [1, 3, 5, 7, 8, 11]); //=> false\n */\n\n\nvar none =\n/*#__PURE__*/\n_curry2(function none(fn, input) {\n  return all(_complement(fn), input);\n});\n\nmodule.exports = none;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * A function that returns the `!` of its argument. It will return `true` when\n * passed false-y value, and `false` when passed a truth-y one.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig * -> Boolean\n * @param {*} a any value\n * @return {Boolean} the logical inverse of passed argument.\n * @see R.complement\n * @example\n *\n *      R.not(true); //=> false\n *      R.not(false); //=> true\n *      R.not(0); //=> true\n *      R.not(1); //=> false\n */\n\n\nvar not =\n/*#__PURE__*/\n_curry1(function not(a) {\n  return !a;\n});\n\nmodule.exports = not;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isString =\n/*#__PURE__*/\nrequire(\"./internal/_isString.js\");\n/**\n * Returns the nth element of the given list or string. If n is negative the\n * element at index length + n is returned.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> a | Undefined\n * @sig Number -> String -> String\n * @param {Number} offset\n * @param {*} list\n * @return {*}\n * @example\n *\n *      const list = ['foo', 'bar', 'baz', 'quux'];\n *      R.nth(1, list); //=> 'bar'\n *      R.nth(-1, list); //=> 'quux'\n *      R.nth(-99, list); //=> undefined\n *\n *      R.nth(2, 'abc'); //=> 'c'\n *      R.nth(3, 'abc'); //=> ''\n * @symb R.nth(-1, [a, b, c]) = c\n * @symb R.nth(0, [a, b, c]) = a\n * @symb R.nth(1, [a, b, c]) = b\n */\n\n\nvar nth =\n/*#__PURE__*/\n_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\nmodule.exports = nth;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar nth =\n/*#__PURE__*/\nrequire(\"./nth.js\");\n/**\n * Returns a function which returns its nth argument.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig Number -> *... -> *\n * @param {Number} n\n * @return {Function}\n * @example\n *\n *      R.nthArg(1)('a', 'b', 'c'); //=> 'b'\n *      R.nthArg(-1)('a', 'b', 'c'); //=> 'c'\n * @symb R.nthArg(-1)(a, b, c) = c\n * @symb R.nthArg(0)(a, b, c) = a\n * @symb R.nthArg(1)(a, b, c) = b\n */\n\n\nvar nthArg =\n/*#__PURE__*/\n_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\nmodule.exports = nthArg;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * `o` is a curried composition function that returns a unary function.\n * Like [`compose`](#compose), `o` performs right-to-left function composition.\n * Unlike [`compose`](#compose), the rightmost function passed to `o` will be\n * invoked with only one argument. Also, unlike [`compose`](#compose), `o` is\n * limited to accepting only 2 unary functions. The name o was chosen because\n * of its similarity to the mathematical composition operator ∘.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category Function\n * @sig (b -> c) -> (a -> b) -> a -> c\n * @param {Function} f\n * @param {Function} g\n * @return {Function}\n * @see R.compose, R.pipe\n * @example\n *\n *      const classyGreeting = name => \"The name's \" + name.last + \", \" + name.first + \" \" + name.last\n *      const yellGreeting = R.o(R.toUpper, classyGreeting);\n *      yellGreeting({first: 'James', last: 'Bond'}); //=> \"THE NAME'S BOND, JAMES BOND\"\n *\n *      R.o(R.multiply(10), R.add(10))(-4) //=> 60\n *\n * @symb R.o(f, g, x) = f(g(x))\n */\n\n\nvar o =\n/*#__PURE__*/\n_curry3(function o(f, g, x) {\n  return f(g(x));\n});\n\nmodule.exports = o;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Creates an object containing a single key:value pair.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Object\n * @sig String -> a -> {String:a}\n * @param {String} key\n * @param {*} val\n * @return {Object}\n * @see R.pair\n * @example\n *\n *      const matchPhrases = R.compose(\n *        R.objOf('must'),\n *        R.map(R.objOf('match_phrase'))\n *      );\n *      matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}\n */\n\n\nvar objOf =\n/*#__PURE__*/\n_curry2(function objOf(key, val) {\n  var obj = {};\n  obj[key] = val;\n  return obj;\n});\n\nmodule.exports = objOf;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _of =\n/*#__PURE__*/\nrequire(\"./internal/_of.js\");\n/**\n * Returns a singleton array containing the value provided.\n *\n * Note this `of` is different from the ES6 `of`; See\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig a -> [a]\n * @param {*} x any value\n * @return {Array} An array wrapping `x`.\n * @example\n *\n *      R.of(null); //=> [null]\n *      R.of([42]); //=> [[42]]\n */\n\n\nvar of =\n/*#__PURE__*/\n_curry1(_of);\n\nmodule.exports = of;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns a partial copy of an object omitting the keys specified.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [String] -> {String: *} -> {String: *}\n * @param {Array} names an array of String property names to omit from the new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with properties from `names` not on it.\n * @see R.pick\n * @example\n *\n *      R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}\n */\n\n\nvar omit =\n/*#__PURE__*/\n_curry2(function omit(names, obj) {\n  var result = {};\n  var index = {};\n  var idx = 0;\n  var len = names.length;\n\n  while (idx < len) {\n    index[names[idx]] = 1;\n    idx += 1;\n  }\n\n  for (var prop in obj) {\n    if (!index.hasOwnProperty(prop)) {\n      result[prop] = obj[prop];\n    }\n  }\n\n  return result;\n});\n\nmodule.exports = omit;","var curryN =\n/*#__PURE__*/\nrequire(\"./internal/_curryN.js\");\n/**\n * Takes a binary function `f`, a unary function `g`, and two values.\n * Applies `g` to each value, then applies the result of each to `f`.\n *\n * Also known as the P combinator.\n *\n * @func\n * @memberOf R\n * @since v0.28.0\n * @category Function\n * @sig ((a, a) -> b) -> (c -> a) -> c -> c -> b\n * @param {Function} f a binary function\n * @param {Function} g a unary function\n * @param {any} a any value\n * @param {any} b any value\n * @return {any} The result of `f`\n * @example\n *\n *      const eqBy = R.on((a, b) => a === b);\n *      eqBy(R.prop('a'), {b:0, a:1}, {a:1}) //=> true;\n *\n *      const containsInsensitive = R.on(R.contains, R.toLower);\n *      containsInsensitive('o', 'FOO'); //=> true\n * @symb R.on(f, g, a, b) = f(g(a), g(b))\n */\n\n\nvar on =\n/*#__PURE__*/\ncurryN(4, [], function on(f, g, a, b) {\n  return f(g(a), g(b));\n});\nmodule.exports = on;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Accepts a function `fn` and returns a function that guards invocation of\n * `fn` such that `fn` can only ever be called once, no matter how many times\n * the returned function is invoked. The first value calculated is returned in\n * subsequent invocations.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (a... -> b) -> (a... -> b)\n * @param {Function} fn The function to wrap in a call-only-once wrapper.\n * @return {Function} The wrapped function.\n * @example\n *\n *      const addOneOnce = R.once(x => x + 1);\n *      addOneOnce(10); //=> 11\n *      addOneOnce(addOneOnce(50)); //=> 11\n */\n\n\nvar once =\n/*#__PURE__*/\n_curry1(function once(fn) {\n  var called = false;\n  var result;\n  return _arity(fn.length, function () {\n    if (called) {\n      return result;\n    }\n\n    called = true;\n    result = fn.apply(this, arguments);\n    return result;\n  });\n});\n\nmodule.exports = once;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns the first argument if it is truthy, otherwise the second argument.\n * Acts as the boolean `or` statement if both inputs are `Boolean`s.\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}\n * @see R.either, R.and\n * @example\n *\n *      R.or(true, true); //=> true\n *      R.or(true, false); //=> true\n *      R.or(false, true); //=> true\n *      R.or(false, false); //=> false\n */\n\n\nvar or =\n/*#__PURE__*/\n_curry2(function or(a, b) {\n  return a || b;\n});\n\nmodule.exports = or;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _assertPromise =\n/*#__PURE__*/\nrequire(\"./internal/_assertPromise.js\");\n/**\n * Returns the result of applying the onFailure function to the value inside\n * a failed promise. This is useful for handling rejected promises\n * inside function compositions.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig (e -> b) -> (Promise e a) -> (Promise e b)\n * @sig (e -> (Promise f b)) -> (Promise e a) -> (Promise f b)\n * @param {Function} onFailure The function to apply. Can return a value or a promise of a value.\n * @param {Promise} p\n * @return {Promise} The result of calling `p.then(null, onFailure)`\n * @see R.andThen\n * @example\n *\n *      const failedFetch = id => Promise.reject('bad ID');\n *      const useDefault = () => ({ firstName: 'Bob', lastName: 'Loblaw' });\n *\n *      //recoverFromFailure :: String -> Promise ({ firstName, lastName })\n *      const recoverFromFailure = R.pipe(\n *        failedFetch,\n *        R.otherwise(useDefault),\n *        R.andThen(R.pick(['firstName', 'lastName'])),\n *      );\n *      recoverFromFailure(12345).then(console.log);\n */\n\n\nvar otherwise =\n/*#__PURE__*/\n_curry2(function otherwise(f, p) {\n  _assertPromise('otherwise', p);\n\n  return p.then(null, f);\n});\n\nmodule.exports = otherwise;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\"); // `Identity` is a functor that holds a single value, where `map` simply\n// transforms the held value with the provided function.\n\n\nvar Identity = function (x) {\n  return {\n    value: x,\n    map: function (f) {\n      return Identity(f(x));\n    }\n  };\n};\n/**\n * Returns the result of \"setting\" the portion of the given data structure\n * focused by the given lens to the result of applying the given function to\n * the focused value.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> (a -> a) -> s -> s\n * @param {Lens} lens\n * @param {*} v\n * @param {*} x\n * @return {*}\n * @see R.view, R.set, R.lens, R.lensIndex, R.lensProp, R.lensPath\n * @example\n *\n *      const headLens = R.lensIndex(0);\n *\n *      R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']\n */\n\n\nvar over =\n/*#__PURE__*/\n_curry3(function over(lens, f, x) {\n  // The value returned by the getter function is first transformed with `f`,\n  // then set as the value of an `Identity`. This is then mapped over with the\n  // setter function of the lens.\n  return lens(function (y) {\n    return Identity(f(y));\n  })(x).value;\n});\n\nmodule.exports = over;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Takes two arguments, `fst` and `snd`, and returns `[fst, snd]`.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category List\n * @sig a -> b -> (a,b)\n * @param {*} fst\n * @param {*} snd\n * @return {Array}\n * @see R.objOf, R.of\n * @example\n *\n *      R.pair('foo', 'bar'); //=> ['foo', 'bar']\n */\n\n\nvar pair =\n/*#__PURE__*/\n_curry2(function pair(fst, snd) {\n  return [fst, snd];\n});\n\nmodule.exports = pair;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _createPartialApplicator =\n/*#__PURE__*/\nrequire(\"./internal/_createPartialApplicator.js\");\n/**\n * Takes a function `f` and a list of arguments, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the arguments\n * provided initially followed by the arguments provided to `g`.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)\n * @param {Function} f\n * @param {Array} args\n * @return {Function}\n * @see R.partialRight, R.curry\n * @example\n *\n *      const multiply2 = (a, b) => a * b;\n *      const double = R.partial(multiply2, [2]);\n *      double(3); //=> 6\n *\n *      const greet = (salutation, title, firstName, lastName) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      const sayHello = R.partial(greet, ['Hello']);\n *      const sayHelloToMs = R.partial(sayHello, ['Ms.']);\n *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partial(f, [a, b])(c, d) = f(a, b, c, d)\n */\n\n\nvar partial =\n/*#__PURE__*/\n_createPartialApplicator(_concat);\n\nmodule.exports = partial;","var mergeDeepRight =\n/*#__PURE__*/\nrequire(\"./mergeDeepRight.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Takes a function `f` and an object, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the object\n * provided initially merged deeply (right) with the object provided as an argument to `g`.\n *\n * @func\n * @memberOf R\n * @since v0.28.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 {Object} props\n * @return {Function}\n * @see R.partial, R.partialRight, R.curry, R.mergeDeepRight\n * @example\n *\n *      const multiply2 = ({ a, b }) => a * b;\n *      const double = R.partialObject(multiply2, { a: 2 });\n *      double({ b: 2 }); //=> 4\n *\n *      const greet = ({ salutation, title, firstName, lastName }) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      const sayHello = R.partialObject(greet, { salutation: 'Hello' });\n *      const sayHelloToMs = R.partialObject(sayHello, { title: 'Ms.' });\n *      sayHelloToMs({ firstName: 'Jane', lastName: 'Jones' }); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partialObject(f, { a, b })({ c, d }) = f({ a, b, c, d })\n */\n\n\nmodule.exports =\n/*#__PURE__*/\n_curry2((f, o) => props => f.call(this, mergeDeepRight(o, props)));","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _createPartialApplicator =\n/*#__PURE__*/\nrequire(\"./internal/_createPartialApplicator.js\");\n\nvar flip =\n/*#__PURE__*/\nrequire(\"./flip.js\");\n/**\n * Takes a function `f` and a list of arguments, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the arguments\n * provided to `g` followed by the arguments provided initially.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x)\n * @param {Function} f\n * @param {Array} args\n * @return {Function}\n * @see R.partial\n * @example\n *\n *      const greet = (salutation, title, firstName, lastName) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      const greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);\n *\n *      greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partialRight(f, [a, b])(c, d) = f(c, d, a, b)\n */\n\n\nvar partialRight =\n/*#__PURE__*/\n_createPartialApplicator(\n/*#__PURE__*/\nflip(_concat));\n\nmodule.exports = partialRight;","var filter =\n/*#__PURE__*/\nrequire(\"./filter.js\");\n\nvar juxt =\n/*#__PURE__*/\nrequire(\"./juxt.js\");\n\nvar reject =\n/*#__PURE__*/\nrequire(\"./reject.js\");\n/**\n * Takes a predicate and a list or other `Filterable` object and returns the\n * pair of filterable objects of the same type of elements which do and do not\n * satisfy, the predicate, respectively. Filterable objects include plain objects or any object\n * that has a filter method such as `Array`.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> [f a, f a]\n * @param {Function} pred A predicate to determine which side the element belongs to.\n * @param {Array} filterable the list (or other filterable) to partition.\n * @return {Array} An array, containing first the subset of elements that satisfy the\n *         predicate, and second the subset of elements that do not satisfy.\n * @see R.filter, R.reject\n * @example\n *\n *      R.partition(R.includes('s'), ['sss', 'ttt', 'foo', 'bars']);\n *      // => [ [ 'sss', 'bars' ],  [ 'ttt', 'foo' ] ]\n *\n *      R.partition(R.includes('s'), { a: 'sss', b: 'ttt', foo: 'bars' });\n *      // => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' }  ]\n */\n\n\nvar partition =\n/*#__PURE__*/\njuxt([filter, reject]);\nmodule.exports = partition;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar paths =\n/*#__PURE__*/\nrequire(\"./paths.js\");\n/**\n * Retrieve the value at a given path.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @typedefn Idx = String | Int | Symbol\n * @sig [Idx] -> {a} -> a | Undefined\n * @param {Array} path The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path`.\n * @see R.prop, R.nth\n * @example\n *\n *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n *      R.path(['a', 'b', 0], {a: {b: [1, 2, 3]}}); //=> 1\n *      R.path(['a', 'b', -2], {a: {b: [1, 2, 3]}}); //=> 2\n */\n\n\nvar path =\n/*#__PURE__*/\n_curry2(function path(pathAr, obj) {\n  return paths([pathAr], obj)[0];\n});\n\nmodule.exports = path;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n\nvar path =\n/*#__PURE__*/\nrequire(\"./path.js\");\n/**\n * Determines whether a nested path on an object has a specific value, in\n * [`R.equals`](#equals) terms. Most likely used to filter a list.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Relation\n * @typedefn Idx = String | Int | Symbol\n * @sig [Idx] -> a -> {a} -> Boolean\n * @param {Array} path The path of the nested property to use\n * @param {*} val The value to compare the nested property with\n * @param {Object} obj The object to check the nested property in\n * @return {Boolean} `true` if the value equals the nested object property,\n *         `false` otherwise.\n * @example\n *\n *      const user1 = { address: { zipCode: 90210 } };\n *      const user2 = { address: { zipCode: 55555 } };\n *      const user3 = { name: 'Bob' };\n *      const users = [ user1, user2, user3 ];\n *      const isFamous = R.pathEq(['address', 'zipCode'], 90210);\n *      R.filter(isFamous, users); //=> [ user1 ]\n */\n\n\nvar pathEq =\n/*#__PURE__*/\n_curry3(function pathEq(_path, val, obj) {\n  return equals(path(_path, obj), val);\n});\n\nmodule.exports = pathEq;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar defaultTo =\n/*#__PURE__*/\nrequire(\"./defaultTo.js\");\n\nvar path =\n/*#__PURE__*/\nrequire(\"./path.js\");\n/**\n * If the given, non-null object has a value at the given path, returns the\n * value at that path. Otherwise returns the provided default value.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Object\n * @typedefn Idx = String | Int | Symbol\n * @sig a -> [Idx] -> {a} -> a\n * @param {*} d The default value.\n * @param {Array} p The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path` of the supplied object or the default value.\n * @example\n *\n *      R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2\n *      R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> \"N/A\"\n */\n\n\nvar pathOr =\n/*#__PURE__*/\n_curry3(function pathOr(d, p, obj) {\n  return defaultTo(d, path(p, obj));\n});\n\nmodule.exports = pathOr;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar path =\n/*#__PURE__*/\nrequire(\"./path.js\");\n/**\n * Returns `true` if the specified object property at given path satisfies the\n * given predicate; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Logic\n * @typedefn Idx = String | Int | Symbol\n * @sig (a -> Boolean) -> [Idx] -> {a} -> Boolean\n * @param {Function} pred\n * @param {Array} propPath\n * @param {*} obj\n * @return {Boolean}\n * @see R.propSatisfies, R.path\n * @example\n *\n *      R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true\n *      R.pathSatisfies(R.is(Object), [], {x: {y: 2}}); //=> true\n */\n\n\nvar pathSatisfies =\n/*#__PURE__*/\n_curry3(function pathSatisfies(pred, propPath, obj) {\n  return pred(path(propPath, obj));\n});\n\nmodule.exports = pathSatisfies;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isInteger =\n/*#__PURE__*/\nrequire(\"./internal/_isInteger.js\");\n\nvar nth =\n/*#__PURE__*/\nrequire(\"./nth.js\");\n/**\n * Retrieves the values at given paths of an object.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Object\n * @typedefn Idx = [String | Int | Symbol]\n * @sig [Idx] -> {a} -> [a | Undefined]\n * @param {Array} pathsArray The array of paths to be fetched.\n * @param {Object} obj The object to retrieve the nested properties from.\n * @return {Array} A list consisting of values at paths specified by \"pathsArray\".\n * @see R.path\n * @example\n *\n *      R.paths([['a', 'b'], ['p', 0, 'q']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3]\n *      R.paths([['a', 'b'], ['p', 'r']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined]\n */\n\n\nvar paths =\n/*#__PURE__*/\n_curry2(function paths(pathsArray, obj) {\n  return pathsArray.map(function (paths) {\n    var val = obj;\n    var idx = 0;\n    var p;\n\n    while (idx < paths.length) {\n      if (val == null) {\n        return;\n      }\n\n      p = paths[idx];\n      val = _isInteger(p) ? nth(p, val) : val[p];\n      idx += 1;\n    }\n\n    return val;\n  });\n});\n\nmodule.exports = paths;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns a partial copy of an object containing only the keys specified. If\n * the key does not exist, the property is ignored.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> {k: v}\n * @param {Array} names an array of String property names to copy onto a new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties from `names` on it.\n * @see R.omit, R.props\n * @example\n *\n *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n */\n\n\nvar pick =\n/*#__PURE__*/\n_curry2(function pick(names, obj) {\n  var result = {};\n  var idx = 0;\n\n  while (idx < names.length) {\n    if (names[idx] in obj) {\n      result[names[idx]] = obj[names[idx]];\n    }\n\n    idx += 1;\n  }\n\n  return result;\n});\n\nmodule.exports = pick;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Similar to `pick` except that this one includes a `key: undefined` pair for\n * properties that don't exist.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> {k: v}\n * @param {Array} names an array of String property names to copy onto a new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties from `names` on it.\n * @see R.pick\n * @example\n *\n *      R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n *      R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}\n */\n\n\nvar pickAll =\n/*#__PURE__*/\n_curry2(function pickAll(names, obj) {\n  var result = {};\n  var idx = 0;\n  var len = names.length;\n\n  while (idx < len) {\n    var name = names[idx];\n    result[name] = obj[name];\n    idx += 1;\n  }\n\n  return result;\n});\n\nmodule.exports = pickAll;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns a partial copy of an object containing only the keys that satisfy\n * the supplied predicate.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Object\n * @sig ((v, k) -> Boolean) -> {k: v} -> {k: v}\n * @param {Function} pred A predicate to determine whether or not a key\n *        should be included on the output object.\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties that satisfy `pred`\n *         on it.\n * @see R.pick, R.filter\n * @example\n *\n *      const isUpperCase = (val, key) => key.toUpperCase() === key;\n *      R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}\n */\n\n\nvar pickBy =\n/*#__PURE__*/\n_curry2(function pickBy(test, obj) {\n  var result = {};\n\n  for (var prop in obj) {\n    if (test(obj[prop], prop, obj)) {\n      result[prop] = obj[prop];\n    }\n  }\n\n  return result;\n});\n\nmodule.exports = pickBy;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _pipe =\n/*#__PURE__*/\nrequire(\"./internal/_pipe.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n\nvar tail =\n/*#__PURE__*/\nrequire(\"./tail.js\");\n/**\n * Performs left-to-right function composition. The first argument may have\n * any arity; the remaining arguments must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * **Note:** The result of pipe is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      const f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))\n * @symb R.pipe(f, g, h)(a)(b) = h(g(f(a)))(b)\n */\n\n\nfunction pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n\n  return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n}\n\nmodule.exports = pipe;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar head =\n/*#__PURE__*/\nrequire(\"./head.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar tail =\n/*#__PURE__*/\nrequire(\"./tail.js\");\n\nvar identity =\n/*#__PURE__*/\nrequire(\"./identity.js\");\n/**\n * Performs left-to-right function composition using transforming function. The first function may have\n * any arity; the remaining functions must be unary.\n *\n * **Note:** The result of pipeWith is not automatically curried. Transforming function is not used on the\n * first argument.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig ((* -> *), [((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)]) -> ((a, b, ..., n) -> z)\n * @param {Function} transformer The transforming function\n * @param {Array} functions The functions to pipe\n * @return {Function}\n * @see R.composeWith, R.pipe\n * @example\n *\n *      const pipeWhileNotNil = R.pipeWith((f, res) => R.isNil(res) ? res : f(res));\n *      const f = pipeWhileNotNil([Math.pow, R.negate, R.inc])\n *\n *      f(3, 4); // -(3^4) + 1\n * @symb R.pipeWith(f)([g, h, i])(...args) = f(i, f(h, g(...args)))\n */\n\n\nvar pipeWith =\n/*#__PURE__*/\n_curry2(function pipeWith(xf, list) {\n  if (list.length <= 0) {\n    return identity;\n  }\n\n  var headList = head(list);\n  var tailList = tail(list);\n  return _arity(headList.length, function () {\n    return _reduce(function (result, f) {\n      return xf.call(this, f, result);\n    }, headList.apply(this, arguments), tailList);\n  });\n});\n\nmodule.exports = pipeWith;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n\nvar prop =\n/*#__PURE__*/\nrequire(\"./prop.js\");\n/**\n * Returns a new list by plucking the same named property off all objects in\n * the list supplied.\n *\n * `pluck` will work on\n * any [functor](https://github.com/fantasyland/fantasy-land#functor) in\n * addition to arrays, as it is equivalent to `R.map(R.prop(k), f)`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => k -> f {k: v} -> f v\n * @param {Number|String} key The key name to pluck off of each object.\n * @param {Array} f The array or functor to consider.\n * @return {Array} The list of values for the given key.\n * @see R.project, R.prop, R.props\n * @example\n *\n *      var getAges = R.pluck('age');\n *      getAges([{name: 'fred', age: 29}, {name: 'wilma', age: 27}]); //=> [29, 27]\n *\n *      R.pluck(0, [[1, 2], [3, 4]]);               //=> [1, 3]\n *      R.pluck('val', {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5}\n * @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5]\n * @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5]\n */\n\n\nvar pluck =\n/*#__PURE__*/\n_curry2(function pluck(p, list) {\n  return map(prop(p), list);\n});\n\nmodule.exports = pluck;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns a new list with the given element at the front, followed by the\n * contents of the list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The item to add to the head of the output list.\n * @param {Array} list The array to add to the tail of the output list.\n * @return {Array} A new array.\n * @see R.append\n * @example\n *\n *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n */\n\n\nvar prepend =\n/*#__PURE__*/\n_curry2(function prepend(el, list) {\n  return _concat([el], list);\n});\n\nmodule.exports = prepend;","var multiply =\n/*#__PURE__*/\nrequire(\"./multiply.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n/**\n * Multiplies together all the elements of a list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list An array of numbers\n * @return {Number} The product of all the numbers in the list.\n * @see R.reduce\n * @example\n *\n *      R.product([2,4,6,8,100,1]); //=> 38400\n */\n\n\nvar product =\n/*#__PURE__*/\nreduce(multiply, 1);\nmodule.exports = product;","var _map =\n/*#__PURE__*/\nrequire(\"./internal/_map.js\");\n\nvar identity =\n/*#__PURE__*/\nrequire(\"./identity.js\");\n\nvar pickAll =\n/*#__PURE__*/\nrequire(\"./pickAll.js\");\n\nvar useWith =\n/*#__PURE__*/\nrequire(\"./useWith.js\");\n/**\n * Reasonable analog to SQL `select` statement.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @category Relation\n * @sig [k] -> [{k: v}] -> [{k: v}]\n * @param {Array} props The property names to project\n * @param {Array} objs The objects to query\n * @return {Array} An array of objects with just the `props` properties.\n * @see R.pluck, R.props, R.prop\n * @example\n *\n *      const abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};\n *      const fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};\n *      const kids = [abby, fred];\n *      R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]\n */\n\n\nvar project =\n/*#__PURE__*/\nuseWith(_map, [pickAll, identity]); // passing `identity` gives correct arity\n\nmodule.exports = project;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _promap =\n/*#__PURE__*/\nrequire(\"./internal/_promap.js\");\n\nvar _xpromap =\n/*#__PURE__*/\nrequire(\"./internal/_xpromap.js\");\n/**\n * Takes two functions as pre- and post- processors respectively for a third function,\n * i.e. `promap(f, g, h)(x) === g(h(f(x)))`.\n *\n * Dispatches to the `promap` method of the third argument, if present,\n * according to the [FantasyLand Profunctor spec](https://github.com/fantasyland/fantasy-land#profunctor).\n *\n * Acts as a transducer if a transformer is given in profunctor position.\n *\n * @func\n * @memberOf R\n * @since v0.28.0\n * @category Function\n * @sig (a -> b) -> (c -> d) -> (b -> c) -> (a -> d)\n * @sig Profunctor p => (a -> b) -> (c -> d) -> p b c -> p a d\n * @param {Function} f The preprocessor function, a -> b\n * @param {Function} g The postprocessor function, c -> d\n * @param {Profunctor} profunctor The profunctor instance to be promapped, e.g. b -> c\n * @return {Profunctor} The new profunctor instance, e.g. a -> d\n * @see R.transduce\n * @example\n *\n *      const decodeChar = R.promap(s => s.charCodeAt(), String.fromCharCode, R.add(-8))\n *      const decodeString = R.promap(R.split(''), R.join(''), R.map(decodeChar))\n *      decodeString(\"ziuli\") //=> \"ramda\"\n *\n * @symb R.promap(f, g, h) = x => g(h(f(x)))\n * @symb R.promap(f, g, profunctor) = profunctor.promap(f, g)\n */\n\n\nvar promap =\n/*#__PURE__*/\n_curry3(\n/*#__PURE__*/\n_dispatchable(['fantasy-land/promap', 'promap'], _xpromap, _promap));\n\nmodule.exports = promap;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isInteger =\n/*#__PURE__*/\nrequire(\"./internal/_isInteger.js\");\n\nvar nth =\n/*#__PURE__*/\nrequire(\"./nth.js\");\n/**\n * Returns a function that when supplied an object returns the indicated\n * property of that object, if it exists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @typedefn Idx = String | Int | Symbol\n * @sig Idx -> {s: a} -> a | Undefined\n * @param {String|Number} p The property name or array index\n * @param {Object} obj The object to query\n * @return {*} The value at `obj.p`.\n * @see R.path, R.props, R.pluck, R.project, R.nth\n * @example\n *\n *      R.prop('x', {x: 100}); //=> 100\n *      R.prop('x', {}); //=> undefined\n *      R.prop(0, [100]); //=> 100\n *      R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4\n */\n\n\nvar prop =\n/*#__PURE__*/\n_curry2(function prop(p, obj) {\n  if (obj == null) {\n    return;\n  }\n\n  return _isInteger(p) ? nth(p, obj) : obj[p];\n});\n\nmodule.exports = prop;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar prop =\n/*#__PURE__*/\nrequire(\"./prop.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n/**\n * Returns `true` if the specified object property is equal, in\n * [`R.equals`](#equals) terms, to the given value; `false` otherwise.\n * You can test multiple properties with [`R.whereEq`](#whereEq).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig String -> a -> Object -> Boolean\n * @param {String} name\n * @param {*} val\n * @param {*} obj\n * @return {Boolean}\n * @see R.whereEq, R.propSatisfies, R.equals\n * @example\n *\n *      const abby = {name: 'Abby', age: 7, hair: 'blond'};\n *      const fred = {name: 'Fred', age: 12, hair: 'brown'};\n *      const rusty = {name: 'Rusty', age: 10, hair: 'brown'};\n *      const alois = {name: 'Alois', age: 15, disposition: 'surly'};\n *      const kids = [abby, fred, rusty, alois];\n *      const hasBrownHair = R.propEq('hair', 'brown');\n *      R.filter(hasBrownHair, kids); //=> [fred, rusty]\n */\n\n\nvar propEq =\n/*#__PURE__*/\n_curry3(function propEq(name, val, obj) {\n  return equals(val, prop(name, obj));\n});\n\nmodule.exports = propEq;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar prop =\n/*#__PURE__*/\nrequire(\"./prop.js\");\n\nvar is =\n/*#__PURE__*/\nrequire(\"./is.js\");\n/**\n * Returns `true` if the specified object property is of the given type;\n * `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Type\n * @sig Type -> String -> Object -> Boolean\n * @param {Function} type\n * @param {String} name\n * @param {*} obj\n * @return {Boolean}\n * @see R.is, R.propSatisfies\n * @example\n *\n *      R.propIs(Number, 'x', {x: 1, y: 2});  //=> true\n *      R.propIs(Number, 'x', {x: 'foo'});    //=> false\n *      R.propIs(Number, 'x', {});            //=> false\n */\n\n\nvar propIs =\n/*#__PURE__*/\n_curry3(function propIs(type, name, obj) {\n  return is(type, prop(name, obj));\n});\n\nmodule.exports = propIs;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar defaultTo =\n/*#__PURE__*/\nrequire(\"./defaultTo.js\");\n\nvar prop =\n/*#__PURE__*/\nrequire(\"./prop.js\");\n/**\n * Return the specified property of the given non-null object if the property\n * is present and it's value is not `null`, `undefined` or `NaN`.\n *\n * Otherwise the first argument is returned.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Object\n * @sig a -> String -> Object -> a\n * @param {*} val The default value.\n * @param {String} p The name of the property to return.\n * @param {Object} obj The object to query.\n * @return {*} The value of given property of the supplied object or the default value.\n * @example\n *\n *      const alice = {\n *        name: 'ALICE',\n *        age: 101\n *      };\n *      const favorite = R.prop('favoriteLibrary');\n *      const favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');\n *\n *      favorite(alice);  //=> undefined\n *      favoriteWithDefault(alice);  //=> 'Ramda'\n */\n\n\nvar propOr =\n/*#__PURE__*/\n_curry3(function propOr(val, p, obj) {\n  return defaultTo(val, prop(p, obj));\n});\n\nmodule.exports = propOr;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar prop =\n/*#__PURE__*/\nrequire(\"./prop.js\");\n/**\n * Returns `true` if the specified object property satisfies the given\n * predicate; `false` otherwise. You can test multiple properties with\n * [`R.where`](#where).\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Logic\n * @sig (a -> Boolean) -> String -> {String: a} -> Boolean\n * @param {Function} pred\n * @param {String} name\n * @param {*} obj\n * @return {Boolean}\n * @see R.where, R.propEq, R.propIs\n * @example\n *\n *      R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true\n */\n\n\nvar propSatisfies =\n/*#__PURE__*/\n_curry3(function propSatisfies(pred, name, obj) {\n  return pred(prop(name, obj));\n});\n\nmodule.exports = propSatisfies;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar path =\n/*#__PURE__*/\nrequire(\"./path.js\");\n/**\n * Acts as multiple `prop`: array of keys in, array of values out. Preserves\n * order.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> [v]\n * @param {Array} ps The property names to fetch\n * @param {Object} obj The object to query\n * @return {Array} The corresponding values or partially applied function.\n * @see R.prop, R.pluck, R.project\n * @example\n *\n *      R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]\n *      R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]\n *\n *      const fullName = R.compose(R.join(' '), R.props(['first', 'last']));\n *      fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'\n */\n\n\nvar props =\n/*#__PURE__*/\n_curry2(function props(ps, obj) {\n  return ps.map(function (p) {\n    return path([p], obj);\n  });\n});\n\nmodule.exports = props;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isNumber =\n/*#__PURE__*/\nrequire(\"./internal/_isNumber.js\");\n/**\n * Returns a list of numbers from `from` (inclusive) to `to` (exclusive).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> Number -> [Number]\n * @param {Number} from The first number in the list.\n * @param {Number} to One more than the last number in the list.\n * @return {Array} The list of numbers in the set `[a, b)`.\n * @example\n *\n *      R.range(1, 5);    //=> [1, 2, 3, 4]\n *      R.range(50, 53);  //=> [50, 51, 52]\n */\n\n\nvar range =\n/*#__PURE__*/\n_curry2(function range(from, to) {\n  if (!(_isNumber(from) && _isNumber(to))) {\n    throw new TypeError('Both arguments to range must be numbers');\n  }\n\n  var result = [];\n  var n = from;\n\n  while (n < to) {\n    result.push(n);\n    n += 1;\n  }\n\n  return result;\n});\n\nmodule.exports = range;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It may use\n * [`R.reduced`](#reduced) to shortcut the iteration.\n *\n * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function\n * is *(value, acc)*.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduce` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n *\n * Dispatches to the `reduce` method of the third argument, if present. When\n * doing so, it is up to the user to handle the [`R.reduced`](#reduced)\n * shortcuting, as this is not implemented by `reduce`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduced, R.addIndex, R.reduceRight\n * @example\n *\n *      R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10\n *      //          -               -10\n *      //         / \\              / \\\n *      //        -   4           -6   4\n *      //       / \\              / \\\n *      //      -   3   ==>     -3   3\n *      //     / \\              / \\\n *      //    -   2           -1   2\n *      //   / \\              / \\\n *      //  0   1            0   1\n *\n * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)\n */\n\n\nvar reduce =\n/*#__PURE__*/\n_curry3(_reduce);\n\nmodule.exports = reduce;","var _clone =\n/*#__PURE__*/\nrequire(\"./internal/_clone.js\");\n\nvar _curryN =\n/*#__PURE__*/\nrequire(\"./internal/_curryN.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./internal/_reduced.js\");\n\nvar _xreduceBy =\n/*#__PURE__*/\nrequire(\"./internal/_xreduceBy.js\");\n/**\n * Groups the elements of the list according to the result of calling\n * the String-returning function `keyFn` on each element and reduces the elements\n * of each group to a single value via the reducer function `valueFn`.\n *\n * The value function receives two values: *(acc, value)*. It may use\n * [`R.reduced`](#reduced) to short circuit the iteration.\n *\n * This function is basically a more general [`groupBy`](#groupBy) function.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category List\n * @sig ((a, b) -> a) -> a -> (b -> String) -> [b] -> {String: a}\n * @param {Function} valueFn The function that reduces the elements of each group to a single\n *        value. Receives two values, accumulator for a particular group and the current element.\n * @param {*} acc The (initial) accumulator value for each group.\n * @param {Function} keyFn The function that maps the list's element into a key.\n * @param {Array} list The array to group.\n * @return {Object} An object with the output of `keyFn` for keys, mapped to the output of\n *         `valueFn` for elements which produced that key when passed to `keyFn`.\n * @see R.groupBy, R.reduce, R.reduced\n * @example\n *\n *      const groupNames = (acc, {name}) => acc.concat(name)\n *      const toGrade = ({score}) =>\n *        score < 65 ? 'F' :\n *        score < 70 ? 'D' :\n *        score < 80 ? 'C' :\n *        score < 90 ? 'B' : 'A'\n *\n *      var students = [\n *        {name: 'Abby', score: 83},\n *        {name: 'Bart', score: 62},\n *        {name: 'Curt', score: 88},\n *        {name: 'Dora', score: 92},\n *      ]\n *\n *      reduceBy(groupNames, [], toGrade, students)\n *      //=> {\"A\": [\"Dora\"], \"B\": [\"Abby\", \"Curt\"], \"F\": [\"Bart\"]}\n */\n\n\nvar reduceBy =\n/*#__PURE__*/\n_curryN(4, [],\n/*#__PURE__*/\n_dispatchable([], _xreduceBy, function reduceBy(valueFn, valueAcc, keyFn, list) {\n  return _reduce(function (acc, elt) {\n    var key = keyFn(elt);\n    var value = valueFn(_has(key, acc) ? acc[key] : _clone(valueAcc, [], [], false), elt);\n\n    if (value && value['@@transducer/reduced']) {\n      return _reduced(acc);\n    }\n\n    acc[key] = value;\n    return acc;\n  }, {}, list);\n}));\n\nmodule.exports = reduceBy;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * Similar to [`reduce`](#reduce), except moves through the input list from the\n * right to the left.\n *\n * The iterator function receives two values: *(value, acc)*, while the arguments'\n * order of `reduce`'s iterator function is *(acc, value)*. `reduceRight` may use [`reduced`](#reduced)\n * to short circuit the iteration.\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, R.reduced\n * @example\n *\n *      R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2\n *      //    -               -2\n *      //   / \\              / \\\n *      //  1   -            1   3\n *      //     / \\              / \\\n *      //    2   -     ==>    2  -1\n *      //       / \\              / \\\n *      //      3   -            3   4\n *      //         / \\              / \\\n *      //        4   0            4   0\n *\n * @symb R.reduceRight(f, a, [b, c, d]) = f(b, f(c, f(d, a)))\n */\n\n\nvar reduceRight =\n/*#__PURE__*/\n_curry3(function reduceRight(fn, acc, list) {\n  var idx = list.length - 1;\n\n  while (idx >= 0) {\n    acc = fn(list[idx], acc);\n\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n\n    idx -= 1;\n  }\n\n  return acc;\n});\n\nmodule.exports = reduceRight;","var _curryN =\n/*#__PURE__*/\nrequire(\"./internal/_curryN.js\");\n\nvar _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./internal/_reduced.js\");\n/**\n * Like [`reduce`](#reduce), `reduceWhile` returns a single item by iterating\n * through the list, successively calling the iterator function. `reduceWhile`\n * also takes a predicate that is evaluated before each step. If the predicate\n * returns `false`, it \"short-circuits\" the iteration and returns the current\n * value of the accumulator. `reduceWhile` may alternatively be short-circuited\n * via [`reduced`](#reduced).\n *\n * @func\n * @memberOf R\n * @since v0.22.0\n * @category List\n * @sig ((a, b) -> Boolean) -> ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} pred The predicate. It is passed the accumulator and the\n *        current element.\n * @param {Function} fn The iterator function. Receives two values, the\n *        accumulator and the current element.\n * @param {*} a The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.reduced\n * @example\n *\n *      const isOdd = (acc, x) => x % 2 !== 0;\n *      const xs = [1, 3, 5, 60, 777, 800];\n *      R.reduceWhile(isOdd, R.add, 0, xs); //=> 9\n *\n *      const ys = [2, 4, 6]\n *      R.reduceWhile(isOdd, R.add, 111, ys); //=> 111\n */\n\n\nvar reduceWhile =\n/*#__PURE__*/\n_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\nmodule.exports = reduceWhile;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _reduced =\n/*#__PURE__*/\nrequire(\"./internal/_reduced.js\");\n/**\n * Returns a value wrapped to indicate that it is the final value of the reduce\n * and transduce functions. The returned value should be considered a black\n * box: the internal structure is not guaranteed to be stable.\n *\n * This optimization is available to the below functions:\n * - [`reduce`](#reduce)\n * - [`reduceWhile`](#reduceWhile)\n * - [`reduceBy`](#reduceBy)\n * - [`reduceRight`](#reduceRight)\n * - [`transduce`](#transduce)\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category List\n * @sig a -> *\n * @param {*} x The final value of the reduce.\n * @return {*} The wrapped value.\n * @see R.reduce, R.reduceWhile, R.reduceBy, R.reduceRight, 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\n\nvar reduced =\n/*#__PURE__*/\n_curry1(_reduced);\n\nmodule.exports = reduced;","var _complement =\n/*#__PURE__*/\nrequire(\"./internal/_complement.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar filter =\n/*#__PURE__*/\nrequire(\"./filter.js\");\n/**\n * The complement of [`filter`](#filter).\n *\n * Acts as a transducer if a transformer is given in list position. Filterable\n * objects include plain objects or any object that has a filter method such\n * as `Array`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array}\n * @see R.filter, R.transduce, R.addIndex\n * @example\n *\n *      const isOdd = (n) => n % 2 !== 0;\n *\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\n\n\nvar reject =\n/*#__PURE__*/\n_curry2(function reject(pred, filterable) {\n  return filter(_complement(pred), filterable);\n});\n\nmodule.exports = reject;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Removes the sub-list of `list` starting at index `start` and containing\n * `count` elements. _Note that this is not destructive_: it returns a copy of\n * the list with the changes.\n * <small>No lists have been harmed in the application of this function.</small>\n *\n * @func\n * @memberOf R\n * @since v0.2.2\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @param {Number} start The position to start removing elements\n * @param {Number} count The number of elements to remove\n * @param {Array} list The list to remove from\n * @return {Array} A new Array with `count` elements from `start` removed.\n * @see R.without\n * @example\n *\n *      R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]\n */\n\n\nvar remove =\n/*#__PURE__*/\n_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\nmodule.exports = remove;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar always =\n/*#__PURE__*/\nrequire(\"./always.js\");\n\nvar times =\n/*#__PURE__*/\nrequire(\"./times.js\");\n/**\n * Returns a fixed list of size `n` containing a specified identical value.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig a -> n -> [a]\n * @param {*} value The value to repeat.\n * @param {Number} n The desired size of the output list.\n * @return {Array} A new array containing `n` `value`s.\n * @see R.times\n * @example\n *\n *      R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']\n *\n *      const obj = {};\n *      const repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]\n *      repeatedObjs[0] === repeatedObjs[1]; //=> true\n * @symb R.repeat(a, 0) = []\n * @symb R.repeat(a, 1) = [a]\n * @symb R.repeat(a, 2) = [a, a]\n */\n\n\nvar repeat =\n/*#__PURE__*/\n_curry2(function repeat(value, n) {\n  return times(always(value), n);\n});\n\nmodule.exports = repeat;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Replace a substring or regex match in a string with a replacement.\n *\n * The first two parameters correspond to the parameters of the\n * `String.prototype.replace()` function, so the second parameter can also be a\n * function.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category String\n * @sig RegExp|String -> String -> String -> String\n * @param {RegExp|String} pattern A regular expression or a substring to match.\n * @param {String} replacement The string to replace the matches with.\n * @param {String} str The String to do the search and replacement in.\n * @return {String} The result.\n * @example\n *\n *      R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'\n *      R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'\n *\n *      // Use the \"g\" (global) flag to replace all occurrences:\n *      R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'\n */\n\n\nvar replace =\n/*#__PURE__*/\n_curry3(function replace(regex, replacement, str) {\n  return str.replace(regex, replacement);\n});\n\nmodule.exports = replace;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _isString =\n/*#__PURE__*/\nrequire(\"./internal/_isString.js\");\n/**\n * Returns a new list or string with the elements or characters in reverse\n * order.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {Array|String} list\n * @return {Array|String}\n * @example\n *\n *      R.reverse([1, 2, 3]);  //=> [3, 2, 1]\n *      R.reverse([1, 2]);     //=> [2, 1]\n *      R.reverse([1]);        //=> [1]\n *      R.reverse([]);         //=> []\n *\n *      R.reverse('abc');      //=> 'cba'\n *      R.reverse('ab');       //=> 'ba'\n *      R.reverse('a');        //=> 'a'\n *      R.reverse('');         //=> ''\n */\n\n\nvar reverse =\n/*#__PURE__*/\n_curry1(function reverse(list) {\n  return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse();\n});\n\nmodule.exports = reverse;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Scan is similar to [`reduce`](#reduce), but returns a list of successively\n * reduced values from the left\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> [a]\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {Array} A list of all intermediately reduced values.\n * @see R.reduce, R.mapAccum\n * @example\n *\n *      const numbers = [1, 2, 3, 4];\n *      const factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]\n * @symb R.scan(f, a, [b, c]) = [a, f(a, b), f(f(a, b), c)]\n */\n\n\nvar scan =\n/*#__PURE__*/\n_curry3(function scan(fn, acc, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [acc];\n\n  while (idx < len) {\n    acc = fn(acc, list[idx]);\n    result[idx + 1] = acc;\n    idx += 1;\n  }\n\n  return result;\n});\n\nmodule.exports = scan;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar ap =\n/*#__PURE__*/\nrequire(\"./ap.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n\nvar prepend =\n/*#__PURE__*/\nrequire(\"./prepend.js\");\n\nvar reduceRight =\n/*#__PURE__*/\nrequire(\"./reduceRight.js\");\n/**\n * Transforms a [Traversable](https://github.com/fantasyland/fantasy-land#traversable)\n * of [Applicative](https://github.com/fantasyland/fantasy-land#applicative) into an\n * Applicative of Traversable.\n *\n * Dispatches to the `sequence` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (Applicative f, Traversable t) => (a -> f a) -> t (f a) -> f (t a)\n * @param {Function} of\n * @param {*} traversable\n * @return {*}\n * @see R.traverse\n * @example\n *\n *      R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]);   //=> Just([1, 2, 3])\n *      R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()\n *\n *      R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)]\n *      R.sequence(R.of, Nothing());       //=> [Nothing()]\n */\n\n\nvar sequence =\n/*#__PURE__*/\n_curry2(function sequence(of, traversable) {\n  return typeof traversable.sequence === 'function' ? traversable.sequence(of) : reduceRight(function (x, acc) {\n    return ap(map(prepend, x), acc);\n  }, of([]), traversable);\n});\n\nmodule.exports = sequence;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar always =\n/*#__PURE__*/\nrequire(\"./always.js\");\n\nvar over =\n/*#__PURE__*/\nrequire(\"./over.js\");\n/**\n * Returns the result of \"setting\" the portion of the given data structure\n * focused by the given lens to the given value.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> a -> s -> s\n * @param {Lens} lens\n * @param {*} v\n * @param {*} x\n * @return {*}\n * @see R.view, R.over, R.lens, R.lensIndex, R.lensProp, R.lensPath\n * @example\n *\n *      const xLens = R.lensProp('x');\n *\n *      R.set(xLens, 4, {x: 1, y: 2});  //=> {x: 4, y: 2}\n *      R.set(xLens, 8, {x: 1, y: 2});  //=> {x: 8, y: 2}\n */\n\n\nvar set =\n/*#__PURE__*/\n_curry3(function set(lens, v, x) {\n  return over(lens, always(v), x);\n});\n\nmodule.exports = set;","var _checkForMethod =\n/*#__PURE__*/\nrequire(\"./internal/_checkForMethod.js\");\n\nvar _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * Dispatches to the `slice` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\n\n\nvar slice =\n/*#__PURE__*/\n_curry3(\n/*#__PURE__*/\n_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\n\nmodule.exports = slice;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Returns a copy of the list, sorted according to the comparator function,\n * which should accept two values at a time and return a negative number if the\n * first value is smaller, a positive number if it's larger, and zero if they\n * are equal. Please note that this is a **copy** of the list. It does not\n * modify the original.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, a) -> Number) -> [a] -> [a]\n * @param {Function} comparator A sorting function :: a -> b -> Int\n * @param {Array} list The list to sort\n * @return {Array} a new array with its elements sorted by the comparator function.\n * @see R.ascend, R.descend\n * @example\n *\n *      const diff = function(a, b) { return a - b; };\n *      R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]\n */\n\n\nvar sort =\n/*#__PURE__*/\n_curry2(function sort(comparator, list) {\n  return Array.prototype.slice.call(list, 0).sort(comparator);\n});\n\nmodule.exports = sort;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Sorts the list according to the supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord b => (a -> b) -> [a] -> [a]\n * @param {Function} fn\n * @param {Array} list The list to sort.\n * @return {Array} A new list sorted by the keys generated by `fn`.\n * @example\n *\n *      const sortByFirstItem = R.sortBy(R.prop(0));\n *      const pairs = [[-1, 1], [-2, 2], [-3, 3]];\n *      sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]\n *\n *      const sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));\n *      const alice = {\n *        name: 'ALICE',\n *        age: 101\n *      };\n *      const bob = {\n *        name: 'Bob',\n *        age: -10\n *      };\n *      const clara = {\n *        name: 'clara',\n *        age: 314.159\n *      };\n *      const people = [clara, bob, alice];\n *      sortByNameCaseInsensitive(people); //=> [alice, bob, clara]\n */\n\n\nvar sortBy =\n/*#__PURE__*/\n_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\nmodule.exports = sortBy;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Sorts a list according to a list of comparators.\n *\n * @func\n * @memberOf R\n * @since v0.23.0\n * @category Relation\n * @sig [(a, a) -> Number] -> [a] -> [a]\n * @param {Array} functions A list of comparator functions.\n * @param {Array} list The list to sort.\n * @return {Array} A new list sorted according to the comarator functions.\n * @see R.ascend, R.descend\n * @example\n *\n *      const alice = {\n *        name: 'alice',\n *        age: 40\n *      };\n *      const bob = {\n *        name: 'bob',\n *        age: 30\n *      };\n *      const clara = {\n *        name: 'clara',\n *        age: 40\n *      };\n *      const people = [clara, bob, alice];\n *      const ageNameSort = R.sortWith([\n *        R.descend(R.prop('age')),\n *        R.ascend(R.prop('name'))\n *      ]);\n *      ageNameSort(people); //=> [alice, clara, bob]\n */\n\n\nvar sortWith =\n/*#__PURE__*/\n_curry2(function sortWith(fns, list) {\n  return Array.prototype.slice.call(list, 0).sort(function (a, b) {\n    var result = 0;\n    var i = 0;\n\n    while (result === 0 && i < fns.length) {\n      result = fns[i](a, b);\n      i += 1;\n    }\n\n    return result;\n  });\n});\n\nmodule.exports = sortWith;","var invoker =\n/*#__PURE__*/\nrequire(\"./invoker.js\");\n/**\n * Splits a string into an array of strings based on the given\n * separator.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category String\n * @sig (String | RegExp) -> String -> [String]\n * @param {String|RegExp} sep The pattern.\n * @param {String} str The string to separate into an array.\n * @return {Array} The array of strings from `str` separated by `sep`.\n * @see R.join\n * @example\n *\n *      const pathComponents = R.split('/');\n *      R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']\n *\n *      R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']\n */\n\n\nvar split =\n/*#__PURE__*/\ninvoker(1, 'split');\nmodule.exports = split;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar length =\n/*#__PURE__*/\nrequire(\"./length.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Splits a given list or string at a given index.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig Number -> [a] -> [[a], [a]]\n * @sig Number -> String -> [String, String]\n * @param {Number} index The index where the array/string is split.\n * @param {Array|String} array The array/string to be split.\n * @return {Array}\n * @example\n *\n *      R.splitAt(1, [1, 2, 3]);          //=> [[1], [2, 3]]\n *      R.splitAt(5, 'hello world');      //=> ['hello', ' world']\n *      R.splitAt(-1, 'foobar');          //=> ['fooba', 'r']\n */\n\n\nvar splitAt =\n/*#__PURE__*/\n_curry2(function splitAt(index, array) {\n  return [slice(0, index, array), slice(index, length(array), array)];\n});\n\nmodule.exports = splitAt;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Splits a collection into slices of the specified length.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [[a]]\n * @sig Number -> String -> [String]\n * @param {Number} n\n * @param {Array} list\n * @return {Array}\n * @example\n *\n *      R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]\n *      R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']\n */\n\n\nvar splitEvery =\n/*#__PURE__*/\n_curry2(function splitEvery(n, list) {\n  if (n <= 0) {\n    throw new Error('First argument to splitEvery must be a positive integer');\n  }\n\n  var result = [];\n  var idx = 0;\n\n  while (idx < list.length) {\n    result.push(slice(idx, idx += n, list));\n  }\n\n  return result;\n});\n\nmodule.exports = splitEvery;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Takes a list and a predicate and returns a pair of lists with the following properties:\n *\n *  - the result of concatenating the two output lists is equivalent to the input list;\n *  - none of the elements of the first output list satisfies the predicate; and\n *  - if the second output list is non-empty, its first element satisfies the predicate.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [[a], [a]]\n * @param {Function} pred The predicate that determines where the array is split.\n * @param {Array} list The array to be split.\n * @return {Array}\n * @example\n *\n *      R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]);   //=> [[1], [2, 3, 1, 2, 3]]\n */\n\n\nvar splitWhen =\n/*#__PURE__*/\n_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\nmodule.exports = splitWhen;","var _curryN =\n/*#__PURE__*/\nrequire(\"./internal/_curryN.js\");\n/**\n * Splits an array into slices on every occurrence of a value.\n *\n * @func\n * @memberOf R\n * @since v0.26.1\n * @category List\n * @sig (a -> Boolean) -> [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.splitWhenever(R.equals(2), [1, 2, 3, 2, 4, 5, 2, 6, 7]); //=> [[1], [3], [4, 5], [6, 7]]\n */\n\n\nvar splitWhenever =\n/*#__PURE__*/\n_curryN(2, [], function splitWhenever(pred, list) {\n  var acc = [];\n  var curr = [];\n\n  for (var i = 0; i < list.length; i = i + 1) {\n    if (!pred(list[i])) {\n      curr.push(list[i]);\n    }\n\n    if ((i < list.length - 1 && pred(list[i + 1]) || i === list.length - 1) && curr.length > 0) {\n      acc.push(curr);\n      curr = [];\n    }\n  }\n\n  return acc;\n});\n\nmodule.exports = splitWhenever;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n\nvar take =\n/*#__PURE__*/\nrequire(\"./take.js\");\n/**\n * Checks if a list starts with the provided sublist.\n *\n * Similarly, checks if a string starts with the provided substring.\n *\n * @func\n * @memberOf R\n * @since v0.24.0\n * @category List\n * @sig [a] -> [a] -> Boolean\n * @sig String -> String -> Boolean\n * @param {*} prefix\n * @param {*} list\n * @return {Boolean}\n * @see R.endsWith\n * @example\n *\n *      R.startsWith('a', 'abc')                //=> true\n *      R.startsWith('b', 'abc')                //=> false\n *      R.startsWith(['a'], ['a', 'b', 'c'])    //=> true\n *      R.startsWith(['b'], ['a', 'b', 'c'])    //=> false\n */\n\n\nvar startsWith =\n/*#__PURE__*/\n_curry2(function (prefix, list) {\n  return equals(take(prefix.length, list), prefix);\n});\n\nmodule.exports = startsWith;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Subtracts its second argument from its first argument.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a - b`.\n * @see R.add\n * @example\n *\n *      R.subtract(10, 8); //=> 2\n *\n *      const minus5 = R.subtract(R.__, 5);\n *      minus5(17); //=> 12\n *\n *      const complementaryAngle = R.subtract(90);\n *      complementaryAngle(30); //=> 60\n *      complementaryAngle(72); //=> 18\n */\n\n\nvar subtract =\n/*#__PURE__*/\n_curry2(function subtract(a, b) {\n  return Number(a) - Number(b);\n});\n\nmodule.exports = subtract;","var add =\n/*#__PURE__*/\nrequire(\"./add.js\");\n\nvar reduce =\n/*#__PURE__*/\nrequire(\"./reduce.js\");\n/**\n * Adds together all the elements of a list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig [Number] -> Number\n * @param {Array} list An array of numbers\n * @return {Number} The sum of all the numbers in the list.\n * @see R.reduce\n * @example\n *\n *      R.sum([2,4,6,8,100,1]); //=> 121\n */\n\n\nvar sum =\n/*#__PURE__*/\nreduce(add, 0);\nmodule.exports = sum;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar concat =\n/*#__PURE__*/\nrequire(\"./concat.js\");\n\nvar difference =\n/*#__PURE__*/\nrequire(\"./difference.js\");\n/**\n * Finds the set (i.e. no duplicates) of all elements contained in the first or\n * second list, but not both.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` or `list2`, but not both.\n * @see R.symmetricDifferenceWith, R.difference, R.differenceWith\n * @example\n *\n *      R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5]\n *      R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2]\n */\n\n\nvar symmetricDifference =\n/*#__PURE__*/\n_curry2(function symmetricDifference(list1, list2) {\n  return concat(difference(list1, list2), difference(list2, list1));\n});\n\nmodule.exports = symmetricDifference;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar concat =\n/*#__PURE__*/\nrequire(\"./concat.js\");\n\nvar differenceWith =\n/*#__PURE__*/\nrequire(\"./differenceWith.js\");\n/**\n * Finds the set (i.e. no duplicates) of all elements contained in the first or\n * second list, but not both. Duplication is determined according to the value\n * returned by applying the supplied predicate to two list elements.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The elements in `list1` or `list2`, but not both.\n * @see R.symmetricDifference, R.difference, R.differenceWith\n * @example\n *\n *      const eqA = R.eqBy(R.prop('a'));\n *      const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];\n *      const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];\n *      R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]\n */\n\n\nvar symmetricDifferenceWith =\n/*#__PURE__*/\n_curry3(function symmetricDifferenceWith(pred, list1, list2) {\n  return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1));\n});\n\nmodule.exports = symmetricDifferenceWith;","var _checkForMethod =\n/*#__PURE__*/\nrequire(\"./internal/_checkForMethod.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * Dispatches to the `slice` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.head, R.init, R.last\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\n\n\nvar tail =\n/*#__PURE__*/\n_curry1(\n/*#__PURE__*/\n_checkForMethod('tail',\n/*#__PURE__*/\nslice(1, Infinity)));\n\nmodule.exports = tail;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xtake =\n/*#__PURE__*/\nrequire(\"./internal/_xtake.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Returns the first `n` elements of the given list, string, or\n * transducer/transformer (or object with a `take` method).\n *\n * Dispatches to the `take` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n\n * @param {*} list\n * @return {*}\n * @see R.drop\n * @example\n *\n *      R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']\n *      R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']\n *      R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.take(3, 'ramda');               //=> 'ram'\n *\n *      const personnel = [\n *        'Dave Brubeck',\n *        'Paul Desmond',\n *        'Eugene Wright',\n *        'Joe Morello',\n *        'Gerry Mulligan',\n *        'Bob Bates',\n *        'Joe Dodge',\n *        'Ron Crotty'\n *      ];\n *\n *      const takeFive = R.take(5);\n *      takeFive(personnel);\n *      //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']\n * @symb R.take(-1, [a, b]) = [a, b]\n * @symb R.take(0, [a, b]) = []\n * @symb R.take(1, [a, b]) = [a]\n * @symb R.take(2, [a, b]) = [a, b]\n */\n\n\nvar take =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['take'], _xtake, function take(n, xs) {\n  return slice(0, n < 0 ? Infinity : n, xs);\n}));\n\nmodule.exports = take;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar drop =\n/*#__PURE__*/\nrequire(\"./drop.js\");\n/**\n * Returns a new list containing the last `n` elements of the given list.\n * If `n > list.length`, returns a list of `list.length` elements.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig Number -> [a] -> [a]\n * @sig Number -> String -> String\n * @param {Number} n The number of elements to return.\n * @param {Array} xs The collection to consider.\n * @return {Array}\n * @see R.dropLast\n * @example\n *\n *      R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']\n *      R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']\n *      R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']\n *      R.takeLast(3, 'ramda');               //=> 'mda'\n */\n\n\nvar takeLast =\n/*#__PURE__*/\n_curry2(function takeLast(n, xs) {\n  return drop(n >= 0 ? xs.length - n : 0, xs);\n});\n\nmodule.exports = takeLast;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Returns a new list containing the last `n` elements of a given list, passing\n * each value to the supplied predicate function, and terminating when the\n * predicate function returns `false`. Excludes the element that caused the\n * predicate function to fail. The predicate function is passed one argument:\n * *(value)*.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropLastWhile, R.addIndex\n * @example\n *\n *      const isNotOne = x => x !== 1;\n *\n *      R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]\n *\n *      R.takeLastWhile(x => x !== 'R' , 'Ramda'); //=> 'amda'\n */\n\n\nvar takeLastWhile =\n/*#__PURE__*/\n_curry2(function takeLastWhile(fn, xs) {\n  var idx = xs.length - 1;\n\n  while (idx >= 0 && fn(xs[idx])) {\n    idx -= 1;\n  }\n\n  return slice(idx + 1, Infinity, xs);\n});\n\nmodule.exports = takeLastWhile;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xtakeWhile =\n/*#__PURE__*/\nrequire(\"./internal/_xtakeWhile.js\");\n\nvar slice =\n/*#__PURE__*/\nrequire(\"./slice.js\");\n/**\n * Returns a new list containing the first `n` elements of a given list,\n * passing each value to the supplied predicate function, and terminating when\n * the predicate function returns `false`. Excludes the element that caused the\n * predicate function to fail. The predicate function is passed one argument:\n * *(value)*.\n *\n * Dispatches to the `takeWhile` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> [a]\n * @sig (a -> Boolean) -> String -> String\n * @param {Function} fn The function called per iteration.\n * @param {Array} xs The collection to iterate over.\n * @return {Array} A new array.\n * @see R.dropWhile, R.transduce, R.addIndex\n * @example\n *\n *      const isNotFour = x => x !== 4;\n *\n *      R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]\n *\n *      R.takeWhile(x => x !== 'd' , 'Ramda'); //=> 'Ram'\n */\n\n\nvar takeWhile =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable(['takeWhile'], _xtakeWhile, function takeWhile(fn, xs) {\n  var idx = 0;\n  var len = xs.length;\n\n  while (idx < len && fn(xs[idx])) {\n    idx += 1;\n  }\n\n  return slice(0, idx, xs);\n}));\n\nmodule.exports = takeWhile;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xtap =\n/*#__PURE__*/\nrequire(\"./internal/_xtap.js\");\n/**\n * Runs the given function with the supplied object, then returns the object.\n *\n * Acts as a transducer if a transformer is given as second parameter.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (a -> *) -> a -> a\n * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n * @param {*} x\n * @return {*} `x`.\n * @example\n *\n *      const sayX = x => console.log('x is ' + x);\n *      R.tap(sayX, 100); //=> 100\n *      // logs 'x is 100'\n * @symb R.tap(f, a) = a\n */\n\n\nvar tap =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xtap, function tap(fn, x) {\n  fn(x);\n  return x;\n}));\n\nmodule.exports = tap;","var _cloneRegExp =\n/*#__PURE__*/\nrequire(\"./internal/_cloneRegExp.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isRegExp =\n/*#__PURE__*/\nrequire(\"./internal/_isRegExp.js\");\n\nvar toString =\n/*#__PURE__*/\nrequire(\"./toString.js\");\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @see R.match\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\n\n\nvar test =\n/*#__PURE__*/\n_curry2(function test(pattern, str) {\n  if (!_isRegExp(pattern)) {\n    throw new TypeError('‘test’ requires a value of type RegExp as its first argument; received ' + toString(pattern));\n  }\n\n  return _cloneRegExp(pattern).test(str);\n});\n\nmodule.exports = test;","var curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n\nvar _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Creates a thunk out of a function. A thunk delays a calculation until\n * its result is needed, providing lazy evaluation of arguments.\n *\n * @func\n * @memberOf R\n * @since v0.26.0\n * @category Function\n * @sig ((a, b, ..., j) -> k) -> (a, b, ..., j) -> (() -> k)\n * @param {Function} fn A function to wrap in a thunk\n * @return {Function} Expects arguments for `fn` and returns a new function\n *  that, when called, applies those arguments to `fn`.\n * @see R.partial, R.partialRight\n * @example\n *\n *      R.thunkify(R.identity)(42)(); //=> 42\n *      R.thunkify((a, b) => a + b)(25, 17)(); //=> 42\n */\n\n\nvar thunkify =\n/*#__PURE__*/\n_curry1(function thunkify(fn) {\n  return curryN(fn.length, function createThunk() {\n    var fnArgs = arguments;\n    return function invokeThunk() {\n      return fn.apply(this, fnArgs);\n    };\n  });\n});\n\nmodule.exports = thunkify;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Calls an input function `n` times, returning an array containing the results\n * of those function calls.\n *\n * `fn` is passed one argument: The current value of `n`, which begins at `0`\n * and is gradually incremented to `n - 1`.\n *\n * @func\n * @memberOf R\n * @since v0.2.3\n * @category List\n * @sig (Number -> a) -> Number -> [a]\n * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.\n * @param {Number} n A value between `0` and `n - 1`. Increments after each function call.\n * @return {Array} An array containing the return values of all calls to `fn`.\n * @see R.repeat\n * @example\n *\n *      R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]\n * @symb R.times(f, 0) = []\n * @symb R.times(f, 1) = [f(0)]\n * @symb R.times(f, 2) = [f(0), f(1)]\n */\n\n\nvar times =\n/*#__PURE__*/\n_curry2(function times(fn, n) {\n  var len = Number(n);\n  var idx = 0;\n  var list;\n\n  if (len < 0 || isNaN(len)) {\n    throw new RangeError('n must be a non-negative number');\n  }\n\n  list = new Array(len);\n\n  while (idx < len) {\n    list[idx] = fn(idx);\n    idx += 1;\n  }\n\n  return list;\n});\n\nmodule.exports = times;","var invoker =\n/*#__PURE__*/\nrequire(\"./invoker.js\");\n/**\n * The lower case version of a string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to lower case.\n * @return {String} The lower case version of `str`.\n * @see R.toUpper\n * @example\n *\n *      R.toLower('XYZ'); //=> 'xyz'\n */\n\n\nvar toLower =\n/*#__PURE__*/\ninvoker(0, 'toLowerCase');\nmodule.exports = toLower;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n/**\n * Converts an object into an array of key, value arrays. Only the object's\n * own properties are used.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Object\n * @sig {String: *} -> [[String,*]]\n * @param {Object} obj The object to extract from\n * @return {Array} An array of key, value arrays from the object's own properties.\n * @see R.fromPairs, R.keys, R.values\n * @example\n *\n *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n */\n\n\nvar toPairs =\n/*#__PURE__*/\n_curry1(function toPairs(obj) {\n  var pairs = [];\n\n  for (var prop in obj) {\n    if (_has(prop, obj)) {\n      pairs[pairs.length] = [prop, obj[prop]];\n    }\n  }\n\n  return pairs;\n});\n\nmodule.exports = toPairs;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Converts an object into an array of key, value arrays. The object's own\n * properties and prototype properties are used. Note that the order of the\n * output array is not guaranteed to be consistent across different JS\n * platforms.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Object\n * @sig {String: *} -> [[String,*]]\n * @param {Object} obj The object to extract from\n * @return {Array} An array of key, value arrays from the object's own\n *         and prototype properties.\n * @example\n *\n *      const F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      const f = new F();\n *      R.toPairsIn(f); //=> [['x','X'], ['y','Y']]\n */\n\n\nvar toPairsIn =\n/*#__PURE__*/\n_curry1(function toPairsIn(obj) {\n  var pairs = [];\n\n  for (var prop in obj) {\n    pairs[pairs.length] = [prop, obj[prop]];\n  }\n\n  return pairs;\n});\n\nmodule.exports = toPairsIn;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar _toString =\n/*#__PURE__*/\nrequire(\"./internal/_toString.js\");\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\n\n\nvar toString =\n/*#__PURE__*/\n_curry1(function toString(val) {\n  return _toString(val, []);\n});\n\nmodule.exports = toString;","var invoker =\n/*#__PURE__*/\nrequire(\"./invoker.js\");\n/**\n * The upper case version of a string.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to upper case.\n * @return {String} The upper case version of `str`.\n * @see R.toLower\n * @example\n *\n *      R.toUpper('abc'); //=> 'ABC'\n */\n\n\nvar toUpper =\n/*#__PURE__*/\ninvoker(0, 'toUpperCase');\nmodule.exports = toUpper;","var _reduce =\n/*#__PURE__*/\nrequire(\"./internal/_reduce.js\");\n\nvar _xwrap =\n/*#__PURE__*/\nrequire(\"./internal/_xwrap.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n/**\n * Initializes a transducer using supplied iterator function. Returns a single\n * item by iterating through the list, successively calling the transformed\n * iterator function and passing it an accumulator value and the current value\n * from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It will be\n * wrapped as a transformer to initialize the transducer. A transformer can be\n * passed directly in place of an iterator function. In both cases, iteration\n * may be stopped early with the [`R.reduced`](#reduced) function.\n *\n * A transducer is a function that accepts a transformer and returns a\n * transformer and can be composed directly.\n *\n * A transformer is an object that provides a 2-arity reducing iterator\n * function, step, 0-arity initial value function, init, and 1-arity result\n * extraction function, result. The step function is used as the iterator\n * function in reduce. The result function is used to convert the final\n * accumulator into the return type and in most cases is\n * [`R.identity`](#identity). The init function can be used to provide an\n * initial accumulator, but is ignored by transduce.\n *\n * The iteration is performed with [`R.reduce`](#reduce) after initializing the transducer.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig (c -> c) -> ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array. Wrapped as transformer, if necessary, and used to\n *        initialize the transducer\n * @param {*} acc The initial accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduce, R.reduced, R.into\n * @example\n *\n *      const numbers = [1, 2, 3, 4];\n *      const transducer = R.compose(R.map(R.add(1)), R.take(2));\n *      R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]\n *\n *      const isOdd = (x) => x % 2 !== 0;\n *      const firstOddTransducer = R.compose(R.filter(isOdd), R.take(1));\n *      R.transduce(firstOddTransducer, R.flip(R.append), [], R.range(0, 100)); //=> [1]\n */\n\n\nvar transduce =\n/*#__PURE__*/\ncurryN(4, function transduce(xf, fn, acc, list) {\n  return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);\n});\nmodule.exports = transduce;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Transposes the rows and columns of a 2D list.\n * When passed a list of `n` lists of length `x`,\n * returns a list of `x` lists of length `n`.\n *\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig [[a]] -> [[a]]\n * @param {Array} list A 2D list\n * @return {Array} A 2D list\n * @example\n *\n *      R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']]\n *      R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n *\n *      // If some of the rows are shorter than the following rows, their elements are skipped:\n *      R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]\n * @symb R.transpose([[a], [b], [c]]) = [a, b, c]\n * @symb R.transpose([[a, b], [c, d]]) = [[a, c], [b, d]]\n * @symb R.transpose([[a, b], [c]]) = [[a, c], [b]]\n */\n\n\nvar transpose =\n/*#__PURE__*/\n_curry1(function transpose(outerlist) {\n  var i = 0;\n  var result = [];\n\n  while (i < outerlist.length) {\n    var innerlist = outerlist[i];\n    var j = 0;\n\n    while (j < innerlist.length) {\n      if (typeof result[j] === 'undefined') {\n        result[j] = [];\n      }\n\n      result[j].push(innerlist[j]);\n      j += 1;\n    }\n\n    i += 1;\n  }\n\n  return result;\n});\n\nmodule.exports = transpose;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n\nvar sequence =\n/*#__PURE__*/\nrequire(\"./sequence.js\");\n/**\n * Maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning\n * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),\n * then uses [`sequence`](#sequence) to transform the resulting Traversable of Applicative\n * into an Applicative of Traversable.\n *\n * Dispatches to the `traverse` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig (Applicative f, Traversable t) => (a -> f a) -> (a -> f b) -> t a -> f (t b)\n * @param {Function} of\n * @param {Function} f\n * @param {*} traversable\n * @return {*}\n * @see R.sequence\n * @example\n *\n *      // Returns `Maybe.Nothing` if the given divisor is `0`\n *      const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d)\n *\n *      R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Maybe.Just([5, 2.5, 2])\n *      R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Maybe.Nothing\n */\n\n\nvar traverse =\n/*#__PURE__*/\n_curry3(function traverse(of, f, traversable) {\n  return typeof traversable['fantasy-land/traverse'] === 'function' ? traversable['fantasy-land/traverse'](f, of) : typeof traversable.traverse === 'function' ? traversable.traverse(f, of) : sequence(of, map(f, traversable));\n});\n\nmodule.exports = traverse;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar ws = '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\nvar zeroWidth = '\\u200b';\nvar hasProtoTrim = typeof String.prototype.trim === 'function';\n/**\n * Removes (strips) whitespace from both ends of the string.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to trim.\n * @return {String} Trimmed version of `str`.\n * @example\n *\n *      R.trim('   xyz  '); //=> 'xyz'\n *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n */\n\nvar trim = !hasProtoTrim ||\n/*#__PURE__*/\nws.trim() || !\n/*#__PURE__*/\nzeroWidth.trim() ?\n/*#__PURE__*/\n_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/*#__PURE__*/\n_curry1(function trim(str) {\n  return str.trim();\n});\nmodule.exports = trim;","var _arity =\n/*#__PURE__*/\nrequire(\"./internal/_arity.js\");\n\nvar _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * `tryCatch` takes two functions, a `tryer` and a `catcher`. The returned\n * function evaluates the `tryer`; if it does not throw, it simply returns the\n * result. If the `tryer` *does* throw, the returned function evaluates the\n * `catcher` function and returns its result. Note that for effective\n * composition with this function, both the `tryer` and `catcher` functions\n * must return the same type of results.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Function\n * @sig (...x -> a) -> ((e, ...x) -> a) -> (...x -> a)\n * @param {Function} tryer The function that may throw.\n * @param {Function} catcher The function that will be evaluated if `tryer` throws.\n * @return {Function} A new function that will catch exceptions and send them to the catcher.\n * @example\n *\n *      R.tryCatch(R.prop('x'), R.F)({x: true}); //=> true\n *      R.tryCatch(() => { throw 'foo'}, R.always('caught'))('bar') // =>\n *      'caught'\n *      R.tryCatch(R.times(R.identity), R.always([]))('s') // => []\n *      R.tryCatch(() => { throw 'this is not a valid value'}, (err, value)=>({error : err,  value }))('bar') // => {'error': 'this is not a valid value', 'value': 'bar'}\n */\n\n\nvar tryCatch =\n/*#__PURE__*/\n_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\nmodule.exports = tryCatch;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Gives a single-word string description of the (native) type of a value,\n * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not\n * attempt to distinguish user Object types any further, reporting them all as\n * 'Object'.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n *      R.type(() => {}); //=> \"Function\"\n *      R.type(undefined); //=> \"Undefined\"\n */\n\n\nvar type =\n/*#__PURE__*/\n_curry1(function type(val) {\n  return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n});\n\nmodule.exports = type;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Takes a function `fn`, which takes a single array argument, and returns a\n * function which:\n *\n *   - takes any number of positional arguments;\n *   - passes these arguments to `fn` as an array; and\n *   - returns the result.\n *\n * In other words, `R.unapply` derives a variadic function from a function which\n * takes an array. `R.unapply` is the inverse of [`R.apply`](#apply).\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Function\n * @sig ([*...] -> a) -> (*... -> a)\n * @param {Function} fn\n * @return {Function}\n * @see R.apply\n * @example\n *\n *      R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'\n * @symb R.unapply(f)(a, b) = f([a, b])\n */\n\n\nvar unapply =\n/*#__PURE__*/\n_curry1(function unapply(fn) {\n  return function () {\n    return fn(Array.prototype.slice.call(arguments, 0));\n  };\n});\n\nmodule.exports = unapply;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar nAry =\n/*#__PURE__*/\nrequire(\"./nAry.js\");\n/**\n * Wraps a function of any arity (including nullary) in a function that accepts\n * exactly 1 parameter. Any extraneous parameters will not be passed to the\n * supplied function.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Function\n * @sig (a -> b -> c -> ... -> z) -> (a -> z)\n * @param {Function} fn The function to wrap.\n * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of\n *         arity 1.\n * @see R.binary, R.nAry\n * @example\n *\n *      const takesTwoArgs = function(a, b) {\n *        return [a, b];\n *      };\n *      takesTwoArgs.length; //=> 2\n *      takesTwoArgs(1, 2); //=> [1, 2]\n *\n *      const takesOneArg = R.unary(takesTwoArgs);\n *      takesOneArg.length; //=> 1\n *      // Only 1 argument is passed to the wrapped function\n *      takesOneArg(1, 2); //=> [1, undefined]\n * @symb R.unary(f)(a, b, c) = f(a)\n */\n\n\nvar unary =\n/*#__PURE__*/\n_curry1(function unary(fn) {\n  return nAry(1, fn);\n});\n\nmodule.exports = unary;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n/**\n * Returns a function of arity `n` from a (manually) curried function.\n * Note that, the returned function is actually a ramda style\n * curryied function, which can accept one or more arguments in each\n * function calling.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Function\n * @sig Number -> (a -> b -> c ... -> z) -> ((a -> b -> c ...) -> z)\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, R.curryN\n * @example\n *\n *      const addFour = a => b => c => d => a + b + c + d;\n *\n *      const uncurriedAddFour = R.uncurryN(4, addFour);\n *      uncurriedAddFour(1, 2, 3, 4); //=> 10\n */\n\n\nvar uncurryN =\n/*#__PURE__*/\n_curry2(function uncurryN(depth, fn) {\n  return curryN(depth, function () {\n    var currentDepth = 1;\n    var value = fn;\n    var idx = 0;\n    var endIdx;\n\n    while (currentDepth <= depth && typeof value === 'function') {\n      endIdx = currentDepth === depth ? arguments.length : idx + value.length;\n      value = value.apply(this, Array.prototype.slice.call(arguments, idx, endIdx));\n      currentDepth += 1;\n      idx = endIdx;\n    }\n\n    return value;\n  });\n});\n\nmodule.exports = uncurryN;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Builds a list from a seed value. Accepts an iterator function, which returns\n * either false to stop iteration or an array of length 2 containing the value\n * to add to the resulting list and the seed to be used in the next call to the\n * iterator function.\n *\n * The iterator function receives one argument: *(seed)*.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category List\n * @sig (a -> [b]) -> * -> [b]\n * @param {Function} fn The iterator function. receives one argument, `seed`, and returns\n *        either false to quit iteration or an array of length two to proceed. The element\n *        at index 0 of this array will be added to the resulting array, and the element\n *        at index 1 will be passed to the next call to `fn`.\n * @param {*} seed The seed value.\n * @return {Array} The final list.\n * @example\n *\n *      const f = n => n > 50 ? false : [-n, n + 10];\n *      R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]\n * @symb R.unfold(f, x) = [f(x)[0], f(f(x)[1])[0], f(f(f(x)[1])[1])[0], ...]\n */\n\n\nvar unfold =\n/*#__PURE__*/\n_curry2(function unfold(fn, seed) {\n  var pair = fn(seed);\n  var result = [];\n\n  while (pair && pair.length) {\n    result[result.length] = pair[0];\n    pair = fn(pair[1]);\n  }\n\n  return result;\n});\n\nmodule.exports = unfold;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar compose =\n/*#__PURE__*/\nrequire(\"./compose.js\");\n\nvar uniq =\n/*#__PURE__*/\nrequire(\"./uniq.js\");\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of the elements\n * of each list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig [*] -> [*] -> [*]\n * @param {Array} as The first list.\n * @param {Array} bs The second list.\n * @return {Array} The first and second lists concatenated, with\n *         duplicates removed.\n * @example\n *\n *      R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]\n */\n\n\nvar union =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\ncompose(uniq, _concat));\n\nmodule.exports = union;","var _concat =\n/*#__PURE__*/\nrequire(\"./internal/_concat.js\");\n\nvar _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar uniqWith =\n/*#__PURE__*/\nrequire(\"./uniqWith.js\");\n/**\n * Combines two lists into a set (i.e. no duplicates) composed of the elements\n * of each list. Duplication is determined according to the value returned by\n * applying the supplied predicate to two list elements. If an element exists\n * in both lists, the first element from the first list will be used.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig ((a, a) -> Boolean) -> [*] -> [*] -> [*]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list1 The first list.\n * @param {Array} list2 The second list.\n * @return {Array} The first and second lists concatenated, with\n *         duplicates removed.\n * @see R.union\n * @example\n *\n *      const l1 = [{a: 1}, {a: 2}];\n *      const l2 = [{a: 1}, {a: 4}];\n *      R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]\n */\n\n\nvar unionWith =\n/*#__PURE__*/\n_curry3(function unionWith(pred, list1, list2) {\n  return uniqWith(pred, _concat(list1, list2));\n});\n\nmodule.exports = unionWith;","var identity =\n/*#__PURE__*/\nrequire(\"./identity.js\");\n\nvar uniqBy =\n/*#__PURE__*/\nrequire(\"./uniqBy.js\");\n/**\n * Returns a new list containing only one copy of each element in the original\n * list. [`R.equals`](#equals) is used to determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n *      R.uniq([1, '1']);     //=> [1, '1']\n *      R.uniq([[42], [42]]); //=> [[42]]\n */\n\n\nvar uniq =\n/*#__PURE__*/\nuniqBy(identity);\nmodule.exports = uniq;","var _Set =\n/*#__PURE__*/\nrequire(\"./internal/_Set.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _xuniqBy =\n/*#__PURE__*/\nrequire(\"./internal/_xuniqBy.js\");\n/**\n * Returns a new list containing only one copy of each element in the original\n * list, based upon the value returned by applying the supplied function to\n * each list element. Prefers the first item if the supplied function produces\n * the same value on two items. [`R.equals`](#equals) is used for comparison.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> b) -> [a] -> [a]\n * @param {Function} fn A function used to produce a value to use during comparisons.\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n */\n\n\nvar uniqBy =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xuniqBy, function (fn, list) {\n  var set = new _Set();\n  var result = [];\n  var idx = 0;\n  var appliedItem, item;\n\n  while (idx < list.length) {\n    item = list[idx];\n    appliedItem = fn(item);\n\n    if (set.add(appliedItem)) {\n      result.push(item);\n    }\n\n    idx += 1;\n  }\n\n  return result;\n}));\n\nmodule.exports = uniqBy;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _dispatchable =\n/*#__PURE__*/\nrequire(\"./internal/_dispatchable.js\");\n\nvar _includesWith =\n/*#__PURE__*/\nrequire(\"./internal/_includesWith.js\");\n\nvar _xuniqWith =\n/*#__PURE__*/\nrequire(\"./internal/_xuniqWith.js\");\n/**\n * Returns a new list containing only one copy of each element in the original\n * list, based upon the value returned by applying the supplied predicate to\n * two list elements. Prefers the first item if two items compare equal based\n * on the predicate.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category List\n * @sig ((a, a) -> Boolean) -> [a] -> [a]\n * @param {Function} pred A predicate used to test whether two items are equal.\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      const strEq = R.eqBy(String);\n *      R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]\n *      R.uniqWith(strEq)([{}, {}]);       //=> [{}]\n *      R.uniqWith(strEq)([1, '1', 1]);    //=> [1]\n *      R.uniqWith(strEq)(['1', 1, 1]);    //=> ['1']\n */\n\n\nvar uniqWith =\n/*#__PURE__*/\n_curry2(\n/*#__PURE__*/\n_dispatchable([], _xuniqWith, function (pred, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n  var item;\n\n  while (idx < len) {\n    item = list[idx];\n\n    if (!_includesWith(pred, item, result)) {\n      result[result.length] = item;\n    }\n\n    idx += 1;\n  }\n\n  return result;\n}));\n\nmodule.exports = uniqWith;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Tests the final argument by passing it to the given predicate function. If\n * the predicate is not satisfied, the function will return the result of\n * calling the `whenFalseFn` function with the same argument. If the predicate\n * is satisfied, the argument is returned as is.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> b) -> a -> a | b\n * @param {Function} pred        A predicate function\n * @param {Function} whenFalseFn A function to invoke when the `pred` evaluates\n *                               to a falsy value.\n * @param {*}        x           An object to test with the `pred` function and\n *                               pass to `whenFalseFn` if necessary.\n * @return {*} Either `x` or the result of applying `x` to `whenFalseFn`.\n * @see R.ifElse, R.when, R.cond\n * @example\n *\n *      let safeInc = R.unless(R.isNil, R.inc);\n *      safeInc(null); //=> null\n *      safeInc(1); //=> 2\n */\n\n\nvar unless =\n/*#__PURE__*/\n_curry3(function unless(pred, whenFalseFn, x) {\n  return pred(x) ? x : whenFalseFn(x);\n});\n\nmodule.exports = unless;","var _identity =\n/*#__PURE__*/\nrequire(\"./internal/_identity.js\");\n\nvar chain =\n/*#__PURE__*/\nrequire(\"./chain.js\");\n/**\n * Shorthand for `R.chain(R.identity)`, which removes one level of nesting from\n * any [Chain](https://github.com/fantasyland/fantasy-land#chain).\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig Chain c => c (c a) -> c a\n * @param {*} list\n * @return {*}\n * @see R.flatten, R.chain\n * @example\n *\n *      R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]\n *      R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]\n */\n\n\nvar unnest =\n/*#__PURE__*/\nchain(_identity);\nmodule.exports = unnest;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Takes a predicate, a transformation function, and an initial value,\n * and returns a value of the same type as the initial value.\n * It does so by applying the transformation until the predicate is satisfied,\n * at which point it returns the satisfactory value.\n *\n * @func\n * @memberOf R\n * @since v0.20.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred A predicate function\n * @param {Function} fn The iterator function\n * @param {*} init Initial value\n * @return {*} Final value that satisfies predicate\n * @example\n *\n *      R.until(R.gt(R.__, 100), R.multiply(2))(1) // => 128\n */\n\n\nvar until =\n/*#__PURE__*/\n_curry3(function until(pred, fn, init) {\n  var val = init;\n\n  while (!pred(val)) {\n    val = fn(val);\n  }\n\n  return val;\n});\n\nmodule.exports = until;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _isArray =\n/*#__PURE__*/\nrequire(\"./internal/_isArray.js\");\n\nvar _map =\n/*#__PURE__*/\nrequire(\"./internal/_map.js\");\n\nvar _assoc =\n/*#__PURE__*/\nrequire(\"./internal/_assoc.js\");\n/**\n *\n * Deconstructs an array field from the input documents to output a document for each element.\n * Each output document is the input document with the value of the array field replaced by the element.\n *\n * @func\n * @memberOf R\n * @since v0.28.0\n * @category Object\n * @sig String -> {k: [v]} -> [{k: v}]\n * @param {String} key The key to determine which property of the object should be unwind\n * @param {Object} object The object containing list under property named as key which is to unwind\n * @return {List} A new list of object containing the value of input key having list replaced by each element in the object.\n * @example\n *\n * R.unwind('hobbies', {\n *   name: 'alice',\n *   hobbies: ['Golf', 'Hacking'],\n *   colors: ['red', 'green'],\n * });\n * // [\n * //   { name: 'alice', hobbies: 'Golf', colors: ['red', 'green'] },\n * //   { name: 'alice', hobbies: 'Hacking', colors: ['red', 'green'] }\n * // ]\n */\n\n\nvar unwind =\n/*#__PURE__*/\n_curry2(function (key, object) {\n  // If key is not in object or key is not as a list in object\n  if (!(key in object && _isArray(object[key]))) {\n    return [object];\n  } // Map over object[key] which is a list and assoc each element with key\n\n\n  return _map(function (item) {\n    return _assoc(key, item, object);\n  }, object[key]);\n});\n\nmodule.exports = unwind;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n\nvar adjust =\n/*#__PURE__*/\nrequire(\"./adjust.js\");\n\nvar always =\n/*#__PURE__*/\nrequire(\"./always.js\");\n/**\n * Returns a new copy of the array with the element at the provided index\n * replaced with the given value.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig Number -> a -> [a] -> [a]\n * @param {Number} idx The index to update.\n * @param {*} x The value to exist at the given index of the returned array.\n * @param {Array|Arguments} list The source array-like object to be updated.\n * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.\n * @see R.adjust\n * @example\n *\n *      R.update(1, '_', ['a', 'b', 'c']);      //=> ['a', '_', 'c']\n *      R.update(-1, '_', ['a', 'b', 'c']);     //=> ['a', 'b', '_']\n * @symb R.update(-1, a, [b, c]) = [b, a]\n * @symb R.update(0, a, [b, c]) = [a, c]\n * @symb R.update(1, a, [b, c]) = [b, a]\n */\n\n\nvar update =\n/*#__PURE__*/\n_curry3(function update(idx, x, list) {\n  return adjust(idx, always(x), list);\n});\n\nmodule.exports = update;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar curryN =\n/*#__PURE__*/\nrequire(\"./curryN.js\");\n/**\n * Accepts a function `fn` and a list of transformer functions and returns a\n * new curried function. When the new function is invoked, it calls the\n * function `fn` with parameters consisting of the result of calling each\n * supplied handler on successive arguments to the new function.\n *\n * If more arguments are passed to the returned function than transformer\n * functions, those arguments are passed directly to `fn` as additional\n * parameters. If you expect additional arguments that don't need to be\n * transformed, although you can ignore them, it's best to pass an identity\n * function so that the new function reports the correct arity.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((x1, x2, ...) -> z) -> [(a -> x1), (b -> x2), ...] -> (a -> b -> ... -> z)\n * @param {Function} fn The function to wrap.\n * @param {Array} transformers A list of transformer functions\n * @return {Function} The wrapped function.\n * @see R.converge\n * @example\n *\n *      R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81\n *      R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81\n *      R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32\n *      R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32\n * @symb R.useWith(f, [g, h])(a, b) = f(g(a), h(b))\n */\n\n\nvar useWith =\n/*#__PURE__*/\n_curry2(function useWith(fn, transformers) {\n  return curryN(transformers.length, function () {\n    var args = [];\n    var idx = 0;\n\n    while (idx < transformers.length) {\n      args.push(transformers[idx].call(this, arguments[idx]));\n      idx += 1;\n    }\n\n    return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length)));\n  });\n});\n\nmodule.exports = useWith;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n\nvar keys =\n/*#__PURE__*/\nrequire(\"./keys.js\");\n/**\n * Returns a list of all the enumerable own properties of the supplied object.\n * Note that the order of the output array is not guaranteed across different\n * JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [v]\n * @param {Object} obj The object to extract values from\n * @return {Array} An array of the values of the object's own properties.\n * @see R.valuesIn, R.keys, R.toPairs\n * @example\n *\n *      R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]\n */\n\n\nvar values =\n/*#__PURE__*/\n_curry1(function values(obj) {\n  var props = keys(obj);\n  var len = props.length;\n  var vals = [];\n  var idx = 0;\n\n  while (idx < len) {\n    vals[idx] = obj[props[idx]];\n    idx += 1;\n  }\n\n  return vals;\n});\n\nmodule.exports = values;","var _curry1 =\n/*#__PURE__*/\nrequire(\"./internal/_curry1.js\");\n/**\n * Returns a list of all the properties, including prototype properties, of the\n * supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @sig {k: v} -> [v]\n * @param {Object} obj The object to extract values from\n * @return {Array} An array of the values of the object's own and prototype properties.\n * @see R.values, R.keysIn\n * @example\n *\n *      const F = function() { this.x = 'X'; };\n *      F.prototype.y = 'Y';\n *      const f = new F();\n *      R.valuesIn(f); //=> ['X', 'Y']\n */\n\n\nvar valuesIn =\n/*#__PURE__*/\n_curry1(function valuesIn(obj) {\n  var prop;\n  var vs = [];\n\n  for (prop in obj) {\n    vs[vs.length] = obj[prop];\n  }\n\n  return vs;\n});\n\nmodule.exports = valuesIn;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\"); // `Const` is a functor that effectively ignores the function given to `map`.\n\n\nvar Const = function (x) {\n  return {\n    value: x,\n    'fantasy-land/map': function () {\n      return this;\n    }\n  };\n};\n/**\n * Returns a \"view\" of the given data structure, determined by the given lens.\n * The lens's focus determines which portion of the data structure is visible.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category Object\n * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s\n * @sig Lens s a -> s -> a\n * @param {Lens} lens\n * @param {*} x\n * @return {*}\n * @see R.set, R.over, R.lens, R.lensIndex, R.lensProp, R.lensPath\n * @example\n *\n *      const xLens = R.lensProp('x');\n *\n *      R.view(xLens, {x: 1, y: 2});  //=> 1\n *      R.view(xLens, {x: 4, y: 2});  //=> 4\n */\n\n\nvar view =\n/*#__PURE__*/\n_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\nmodule.exports = view;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Tests the final argument by passing it to the given predicate function. If\n * the predicate is satisfied, the function will return the result of calling\n * the `whenTrueFn` function with the same argument. If the predicate is not\n * satisfied, the argument is returned as is.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> b) -> a -> a | b\n * @param {Function} pred       A predicate function\n * @param {Function} whenTrueFn A function to invoke when the `condition`\n *                              evaluates to a truthy value.\n * @param {*}        x          An object to test with the `pred` function and\n *                              pass to `whenTrueFn` if necessary.\n * @return {*} Either `x` or the result of applying `x` to `whenTrueFn`.\n * @see R.ifElse, R.unless, R.cond\n * @example\n *\n *      // truncate :: String -> String\n *      const truncate = R.when(\n *        R.propSatisfies(R.gt(R.__, 10), 'length'),\n *        R.pipe(R.take(10), R.append('…'), R.join(''))\n *      );\n *      truncate('12345');         //=> '12345'\n *      truncate('0123456789ABC'); //=> '0123456789…'\n */\n\n\nvar when =\n/*#__PURE__*/\n_curry3(function when(pred, whenTrueFn, x) {\n  return pred(x) ? whenTrueFn(x) : x;\n});\n\nmodule.exports = when;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n/**\n * Takes a spec object and a test object; returns true if the test satisfies\n * the spec. Each of the spec's own properties must be a predicate function.\n * Each predicate is applied to the value of the corresponding property of the\n * test object. `where` returns true if all the predicates return true, false\n * otherwise.\n *\n * `where` is well suited to declaratively expressing constraints for other\n * functions such as [`filter`](#filter) and [`find`](#find).\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category Object\n * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n * @param {Object} spec\n * @param {Object} testObj\n * @return {Boolean}\n * @see R.propSatisfies, R.whereEq\n * @example\n *\n *      // pred :: Object -> Boolean\n *      const pred = R.where({\n *        a: R.equals('foo'),\n *        b: R.complement(R.equals('bar')),\n *        x: R.gt(R.__, 10),\n *        y: R.lt(R.__, 20)\n *      });\n *\n *      pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true\n *      pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false\n *      pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false\n *      pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false\n *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false\n */\n\n\nvar where =\n/*#__PURE__*/\n_curry2(function where(spec, testObj) {\n  for (var prop in spec) {\n    if (_has(prop, spec) && !spec[prop](testObj[prop])) {\n      return false;\n    }\n  }\n\n  return true;\n});\n\nmodule.exports = where;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar _has =\n/*#__PURE__*/\nrequire(\"./internal/_has.js\");\n/**\n * Takes a spec object and a test object; 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. `whereAny` returns true if at least one of the predicates return true,\n * false otherwise.\n *\n * `whereAny` 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.28.0\n * @category Object\n * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean\n * @param {Object} spec\n * @param {Object} testObj\n * @return {Boolean}\n * @see R.propSatisfies, R.where\n * @example\n *\n *      // pred :: Object -> Boolean\n *      const pred = R.whereAny({\n *        a: R.equals('foo'),\n *        b: R.complement(R.equals('xxx')),\n *        x: R.gt(R.__, 10),\n *        y: R.lt(R.__, 20)\n *      });\n *\n *      pred({a: 'foo', b: 'xxx', x: 8, y: 34}); //=> true\n *      pred({a: 'xxx', b: 'xxx', x: 9, y: 21}); //=> false\n *      pred({a: 'bar', b: 'xxx', x: 10, y: 20}); //=> false\n *      pred({a: 'foo', b: 'bar', x: 10, y: 20}); //=> true\n *      pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> true\n */\n\n\nvar whereAny =\n/*#__PURE__*/\n_curry2(function whereAny(spec, testObj) {\n  for (var prop in spec) {\n    if (_has(prop, spec) && spec[prop](testObj[prop])) {\n      return true;\n    }\n  }\n\n  return false;\n});\n\nmodule.exports = whereAny;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar equals =\n/*#__PURE__*/\nrequire(\"./equals.js\");\n\nvar map =\n/*#__PURE__*/\nrequire(\"./map.js\");\n\nvar where =\n/*#__PURE__*/\nrequire(\"./where.js\");\n/**\n * Takes a spec object and a test object; returns true if the test satisfies\n * the spec, false otherwise. An object satisfies the spec if, for each of the\n * spec's own properties, accessing that property of the object gives the same\n * value (in [`R.equals`](#equals) terms) as accessing that property of the\n * spec.\n *\n * `whereEq` is a specialization of [`where`](#where).\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category Object\n * @sig {String: *} -> {String: *} -> Boolean\n * @param {Object} spec\n * @param {Object} testObj\n * @return {Boolean}\n * @see R.propEq, R.where\n * @example\n *\n *      // pred :: Object -> Boolean\n *      const pred = R.whereEq({a: 1, b: 2});\n *\n *      pred({a: 1});              //=> false\n *      pred({a: 1, b: 2});        //=> true\n *      pred({a: 1, b: 2, c: 3});  //=> true\n *      pred({a: 1, b: 1});        //=> false\n */\n\n\nvar whereEq =\n/*#__PURE__*/\n_curry2(function whereEq(spec, testObj) {\n  return where(map(equals, spec), testObj);\n});\n\nmodule.exports = whereEq;","var _includes =\n/*#__PURE__*/\nrequire(\"./internal/_includes.js\");\n\nvar _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n\nvar flip =\n/*#__PURE__*/\nrequire(\"./flip.js\");\n\nvar reject =\n/*#__PURE__*/\nrequire(\"./reject.js\");\n/**\n * Returns a new list without values in the first argument.\n * [`R.equals`](#equals) is used to determine equality.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.19.0\n * @category List\n * @sig [a] -> [a] -> [a]\n * @param {Array} list1 The values to be removed from `list2`.\n * @param {Array} list2 The array to remove values from.\n * @return {Array} The new array without values in `list1`.\n * @see R.transduce, R.difference, R.remove\n * @example\n *\n *      R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]\n */\n\n\nvar without =\n/*#__PURE__*/\n_curry2(function (xs, list) {\n  return reject(flip(_includes)(xs), list);\n});\n\nmodule.exports = without;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Exclusive disjunction logical operation.\n * Returns `true` if one of the arguments is truthy and the other is falsy.\n * Otherwise, it returns `false`.\n *\n * @func\n * @memberOf R\n * @since v0.27.1\n * @category Logic\n * @sig a -> b -> Boolean\n * @param {Any} a\n * @param {Any} b\n * @return {Boolean} true if one of the arguments is truthy and the other is falsy\n * @see R.or, R.and\n * @example\n *\n *      R.xor(true, true); //=> false\n *      R.xor(true, false); //=> true\n *      R.xor(false, true); //=> true\n *      R.xor(false, false); //=> false\n */\n\n\nvar xor =\n/*#__PURE__*/\n_curry2(function xor(a, b) {\n  return Boolean(!a ^ !b);\n});\n\nmodule.exports = xor;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Creates a new list out of the two supplied by creating each possible pair\n * from the lists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b] -> [[a,b]]\n * @param {Array} as The first list.\n * @param {Array} bs The second list.\n * @return {Array} The list made by combining each possible pair from\n *         `as` and `bs` into pairs (`[a, b]`).\n * @example\n *\n *      R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]\n * @symb R.xprod([a, b], [c, d]) = [[a, c], [a, d], [b, c], [b, d]]\n */\n\n\nvar xprod =\n/*#__PURE__*/\n_curry2(function xprod(a, b) {\n  // = xprodWith(prepend); (takes about 3 times as long...)\n  var idx = 0;\n  var ilen = a.length;\n  var j;\n  var jlen = b.length;\n  var result = [];\n\n  while (idx < ilen) {\n    j = 0;\n\n    while (j < jlen) {\n      result[result.length] = [a[idx], b[j]];\n      j += 1;\n    }\n\n    idx += 1;\n  }\n\n  return result;\n});\n\nmodule.exports = xprod;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Creates a new list out of the two supplied by pairing up equally-positioned\n * items from both lists. The returned list is truncated to the length of the\n * shorter of the two input lists.\n * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b] -> [[a,b]]\n * @param {Array} list1 The first array to consider.\n * @param {Array} list2 The second array to consider.\n * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.\n * @example\n *\n *      R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]\n * @symb R.zip([a, b, c], [d, e, f]) = [[a, d], [b, e], [c, f]]\n */\n\n\nvar zip =\n/*#__PURE__*/\n_curry2(function zip(a, b) {\n  var rv = [];\n  var idx = 0;\n  var len = Math.min(a.length, b.length);\n\n  while (idx < len) {\n    rv[idx] = [a[idx], b[idx]];\n    idx += 1;\n  }\n\n  return rv;\n});\n\nmodule.exports = zip;","var _curry2 =\n/*#__PURE__*/\nrequire(\"./internal/_curry2.js\");\n/**\n * Creates a new object out of a list of keys and a list of values.\n * Key/value pairing is truncated to the length of the shorter of the two lists.\n * Note: `zipObj` is equivalent to `pipe(zip, fromPairs)`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [String] -> [*] -> {String: *}\n * @param {Array} keys The array that will be properties on the output object.\n * @param {Array} values The list of values on the output object.\n * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.\n * @example\n *\n *      R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}\n */\n\n\nvar zipObj =\n/*#__PURE__*/\n_curry2(function zipObj(keys, values) {\n  var idx = 0;\n  var len = Math.min(keys.length, values.length);\n  var out = {};\n\n  while (idx < len) {\n    out[keys[idx]] = values[idx];\n    idx += 1;\n  }\n\n  return out;\n});\n\nmodule.exports = zipObj;","var _curry3 =\n/*#__PURE__*/\nrequire(\"./internal/_curry3.js\");\n/**\n * Creates a new list out of the two supplied by applying the function to each\n * equally-positioned pair in the lists. The returned list is truncated to the\n * length of the shorter of the two input lists.\n *\n * @function\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> c) -> [a] -> [b] -> [c]\n * @param {Function} fn The function used to combine the two elements into one value.\n * @param {Array} list1 The first array to consider.\n * @param {Array} list2 The second array to consider.\n * @return {Array} The list made by combining same-indexed elements of `list1` and `list2`\n *         using `fn`.\n * @example\n *\n *      const f = (x, y) => {\n *        // ...\n *      };\n *      R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);\n *      //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]\n * @symb R.zipWith(fn, [a, b, c], [d, e, f]) = [fn(a, d), fn(b, e), fn(c, f)]\n */\n\n\nvar zipWith =\n/*#__PURE__*/\n_curry3(function zipWith(fn, a, b) {\n  var rv = [];\n  var idx = 0;\n  var len = Math.min(a.length, b.length);\n\n  while (idx < len) {\n    rv[idx] = fn(a[idx], b[idx]);\n    idx += 1;\n  }\n\n  return rv;\n});\n\nmodule.exports = zipWith;","/**\n * default settings\n *\n * @author Zongmin Lei<leizongmin@gmail.com>\n */\n\nvar FilterCSS = require(\"cssfilter\").FilterCSS;\nvar getDefaultCSSWhiteList = require(\"cssfilter\").getDefaultWhiteList;\nvar _ = require(\"./util\");\n\nfunction getDefaultWhiteList() {\n  return {\n    a: [\"target\", \"href\", \"title\"],\n    abbr: [\"title\"],\n    address: [],\n    area: [\"shape\", \"coords\", \"href\", \"alt\"],\n    article: [],\n    aside: [],\n    audio: [\n      \"autoplay\",\n      \"controls\",\n      \"crossorigin\",\n      \"loop\",\n      \"muted\",\n      \"preload\",\n      \"src\",\n    ],\n    b: [],\n    bdi: [\"dir\"],\n    bdo: [\"dir\"],\n    big: [],\n    blockquote: [\"cite\"],\n    br: [],\n    caption: [],\n    center: [],\n    cite: [],\n    code: [],\n    col: [\"align\", \"valign\", \"span\", \"width\"],\n    colgroup: [\"align\", \"valign\", \"span\", \"width\"],\n    dd: [],\n    del: [\"datetime\"],\n    details: [\"open\"],\n    div: [],\n    dl: [],\n    dt: [],\n    em: [],\n    figcaption: [],\n    figure: [],\n    font: [\"color\", \"size\", \"face\"],\n    footer: [],\n    h1: [],\n    h2: [],\n    h3: [],\n    h4: [],\n    h5: [],\n    h6: [],\n    header: [],\n    hr: [],\n    i: [],\n    img: [\"src\", \"alt\", \"title\", \"width\", \"height\", \"loading\"],\n    ins: [\"datetime\"],\n    kbd: [],\n    li: [],\n    mark: [],\n    nav: [],\n    ol: [],\n    p: [],\n    pre: [],\n    s: [],\n    section: [],\n    small: [],\n    span: [],\n    sub: [],\n    summary: [],\n    sup: [],\n    strong: [],\n    strike: [],\n    table: [\"width\", \"border\", \"align\", \"valign\"],\n    tbody: [\"align\", \"valign\"],\n    td: [\"width\", \"rowspan\", \"colspan\", \"align\", \"valign\"],\n    tfoot: [\"align\", \"valign\"],\n    th: [\"width\", \"rowspan\", \"colspan\", \"align\", \"valign\"],\n    thead: [\"align\", \"valign\"],\n    tr: [\"rowspan\", \"align\", \"valign\"],\n    tt: [],\n    u: [],\n    ul: [],\n    video: [\n      \"autoplay\",\n      \"controls\",\n      \"crossorigin\",\n      \"loop\",\n      \"muted\",\n      \"playsinline\",\n      \"poster\",\n      \"preload\",\n      \"src\",\n      \"height\",\n      \"width\",\n    ],\n  };\n}\n\nvar defaultCSSFilter = new FilterCSS();\n\n/**\n * default onTag function\n *\n * @param {String} tag\n * @param {String} html\n * @param {Object} options\n * @return {String}\n */\nfunction onTag(tag, html, options) {\n  // do nothing\n}\n\n/**\n * default onIgnoreTag function\n *\n * @param {String} tag\n * @param {String} html\n * @param {Object} options\n * @return {String}\n */\nfunction onIgnoreTag(tag, html, options) {\n  // do nothing\n}\n\n/**\n * default onTagAttr function\n *\n * @param {String} tag\n * @param {String} name\n * @param {String} value\n * @return {String}\n */\nfunction onTagAttr(tag, name, value) {\n  // do nothing\n}\n\n/**\n * default onIgnoreTagAttr function\n *\n * @param {String} tag\n * @param {String} name\n * @param {String} value\n * @return {String}\n */\nfunction onIgnoreTagAttr(tag, name, value) {\n  // do nothing\n}\n\n/**\n * default escapeHtml function\n *\n * @param {String} html\n */\nfunction escapeHtml(html) {\n  return html.replace(REGEXP_LT, \"&lt;\").replace(REGEXP_GT, \"&gt;\");\n}\n\n/**\n * default safeAttrValue function\n *\n * @param {String} tag\n * @param {String} name\n * @param {String} value\n * @param {Object} cssFilter\n * @return {String}\n */\nfunction safeAttrValue(tag, name, value, cssFilter) {\n  // unescape attribute value firstly\n  value = friendlyAttrValue(value);\n\n  if (name === \"href\" || name === \"src\") {\n    // filter `href` and `src` attribute\n    // only allow the value that starts with `http://` | `https://` | `mailto:` | `/` | `#`\n    value = _.trim(value);\n    if (value === \"#\") return \"#\";\n    if (\n      !(\n        value.substr(0, 7) === \"http://\" ||\n        value.substr(0, 8) === \"https://\" ||\n        value.substr(0, 7) === \"mailto:\" ||\n        value.substr(0, 4) === \"tel:\" ||\n        value.substr(0, 11) === \"data:image/\" ||\n        value.substr(0, 6) === \"ftp://\" ||\n        value.substr(0, 2) === \"./\" ||\n        value.substr(0, 3) === \"../\" ||\n        value[0] === \"#\" ||\n        value[0] === \"/\"\n      )\n    ) {\n      return \"\";\n    }\n  } else if (name === \"background\") {\n    // filter `background` attribute (maybe no use)\n    // `javascript:`\n    REGEXP_DEFAULT_ON_TAG_ATTR_4.lastIndex = 0;\n    if (REGEXP_DEFAULT_ON_TAG_ATTR_4.test(value)) {\n      return \"\";\n    }\n  } else if (name === \"style\") {\n    // `expression()`\n    REGEXP_DEFAULT_ON_TAG_ATTR_7.lastIndex = 0;\n    if (REGEXP_DEFAULT_ON_TAG_ATTR_7.test(value)) {\n      return \"\";\n    }\n    // `url()`\n    REGEXP_DEFAULT_ON_TAG_ATTR_8.lastIndex = 0;\n    if (REGEXP_DEFAULT_ON_TAG_ATTR_8.test(value)) {\n      REGEXP_DEFAULT_ON_TAG_ATTR_4.lastIndex = 0;\n      if (REGEXP_DEFAULT_ON_TAG_ATTR_4.test(value)) {\n        return \"\";\n      }\n    }\n    if (cssFilter !== false) {\n      cssFilter = cssFilter || defaultCSSFilter;\n      value = cssFilter.process(value);\n    }\n  }\n\n  // escape `<>\"` before returns\n  value = escapeAttrValue(value);\n  return value;\n}\n\n// RegExp list\nvar REGEXP_LT = /</g;\nvar REGEXP_GT = />/g;\nvar REGEXP_QUOTE = /\"/g;\nvar REGEXP_QUOTE_2 = /&quot;/g;\nvar REGEXP_ATTR_VALUE_1 = /&#([a-zA-Z0-9]*);?/gim;\nvar REGEXP_ATTR_VALUE_COLON = /&colon;?/gim;\nvar REGEXP_ATTR_VALUE_NEWLINE = /&newline;?/gim;\n// var REGEXP_DEFAULT_ON_TAG_ATTR_3 = /\\/\\*|\\*\\//gm;\nvar REGEXP_DEFAULT_ON_TAG_ATTR_4 =\n  /((j\\s*a\\s*v\\s*a|v\\s*b|l\\s*i\\s*v\\s*e)\\s*s\\s*c\\s*r\\s*i\\s*p\\s*t\\s*|m\\s*o\\s*c\\s*h\\s*a):/gi;\n// var REGEXP_DEFAULT_ON_TAG_ATTR_5 = /^[\\s\"'`]*(d\\s*a\\s*t\\s*a\\s*)\\:/gi;\n// var REGEXP_DEFAULT_ON_TAG_ATTR_6 = /^[\\s\"'`]*(d\\s*a\\s*t\\s*a\\s*)\\:\\s*image\\//gi;\nvar REGEXP_DEFAULT_ON_TAG_ATTR_7 =\n  /e\\s*x\\s*p\\s*r\\s*e\\s*s\\s*s\\s*i\\s*o\\s*n\\s*\\(.*/gi;\nvar REGEXP_DEFAULT_ON_TAG_ATTR_8 = /u\\s*r\\s*l\\s*\\(.*/gi;\n\n/**\n * escape double quote\n *\n * @param {String} str\n * @return {String} str\n */\nfunction escapeQuote(str) {\n  return str.replace(REGEXP_QUOTE, \"&quot;\");\n}\n\n/**\n * unescape double quote\n *\n * @param {String} str\n * @return {String} str\n */\nfunction unescapeQuote(str) {\n  return str.replace(REGEXP_QUOTE_2, '\"');\n}\n\n/**\n * escape html entities\n *\n * @param {String} str\n * @return {String}\n */\nfunction escapeHtmlEntities(str) {\n  return str.replace(REGEXP_ATTR_VALUE_1, function replaceUnicode(str, code) {\n    return code[0] === \"x\" || code[0] === \"X\"\n      ? String.fromCharCode(parseInt(code.substr(1), 16))\n      : String.fromCharCode(parseInt(code, 10));\n  });\n}\n\n/**\n * escape html5 new danger entities\n *\n * @param {String} str\n * @return {String}\n */\nfunction escapeDangerHtml5Entities(str) {\n  return str\n    .replace(REGEXP_ATTR_VALUE_COLON, \":\")\n    .replace(REGEXP_ATTR_VALUE_NEWLINE, \" \");\n}\n\n/**\n * clear nonprintable characters\n *\n * @param {String} str\n * @return {String}\n */\nfunction clearNonPrintableCharacter(str) {\n  var str2 = \"\";\n  for (var i = 0, len = str.length; i < len; i++) {\n    str2 += str.charCodeAt(i) < 32 ? \" \" : str.charAt(i);\n  }\n  return _.trim(str2);\n}\n\n/**\n * get friendly attribute value\n *\n * @param {String} str\n * @return {String}\n */\nfunction friendlyAttrValue(str) {\n  str = unescapeQuote(str);\n  str = escapeHtmlEntities(str);\n  str = escapeDangerHtml5Entities(str);\n  str = clearNonPrintableCharacter(str);\n  return str;\n}\n\n/**\n * unescape attribute value\n *\n * @param {String} str\n * @return {String}\n */\nfunction escapeAttrValue(str) {\n  str = escapeQuote(str);\n  str = escapeHtml(str);\n  return str;\n}\n\n/**\n * `onIgnoreTag` function for removing all the tags that are not in whitelist\n */\nfunction onIgnoreTagStripAll() {\n  return \"\";\n}\n\n/**\n * remove tag body\n * specify a `tags` list, if the tag is not in the `tags` list then process by the specify function (optional)\n *\n * @param {array} tags\n * @param {function} next\n */\nfunction StripTagBody(tags, next) {\n  if (typeof next !== \"function\") {\n    next = function () {};\n  }\n\n  var isRemoveAllTag = !Array.isArray(tags);\n  function isRemoveTag(tag) {\n    if (isRemoveAllTag) return true;\n    return _.indexOf(tags, tag) !== -1;\n  }\n\n  var removeList = [];\n  var posStart = false;\n\n  return {\n    onIgnoreTag: function (tag, html, options) {\n      if (isRemoveTag(tag)) {\n        if (options.isClosing) {\n          var ret = \"[/removed]\";\n          var end = options.position + ret.length;\n          removeList.push([\n            posStart !== false ? posStart : options.position,\n            end,\n          ]);\n          posStart = false;\n          return ret;\n        } else {\n          if (!posStart) {\n            posStart = options.position;\n          }\n          return \"[removed]\";\n        }\n      } else {\n        return next(tag, html, options);\n      }\n    },\n    remove: function (html) {\n      var rethtml = \"\";\n      var lastPos = 0;\n      _.forEach(removeList, function (pos) {\n        rethtml += html.slice(lastPos, pos[0]);\n        lastPos = pos[1];\n      });\n      rethtml += html.slice(lastPos);\n      return rethtml;\n    },\n  };\n}\n\n/**\n * remove html comments\n *\n * @param {String} html\n * @return {String}\n */\nfunction stripCommentTag(html) {\n  var retHtml = \"\";\n  var lastPos = 0;\n  while (lastPos < html.length) {\n    var i = html.indexOf(\"<!--\", lastPos);\n    if (i === -1) {\n      retHtml += html.slice(lastPos);\n      break;\n    }\n    retHtml += html.slice(lastPos, i);\n    var j = html.indexOf(\"-->\", i);\n    if (j === -1) {\n      break;\n    }\n    lastPos = j + 3;\n  }\n  return retHtml;\n}\n\n/**\n * remove invisible characters\n *\n * @param {String} html\n * @return {String}\n */\nfunction stripBlankChar(html) {\n  var chars = html.split(\"\");\n  chars = chars.filter(function (char) {\n    var c = char.charCodeAt(0);\n    if (c === 127) return false;\n    if (c <= 31) {\n      if (c === 10 || c === 13) return true;\n      return false;\n    }\n    return true;\n  });\n  return chars.join(\"\");\n}\n\nexports.whiteList = getDefaultWhiteList();\nexports.getDefaultWhiteList = getDefaultWhiteList;\nexports.onTag = onTag;\nexports.onIgnoreTag = onIgnoreTag;\nexports.onTagAttr = onTagAttr;\nexports.onIgnoreTagAttr = onIgnoreTagAttr;\nexports.safeAttrValue = safeAttrValue;\nexports.escapeHtml = escapeHtml;\nexports.escapeQuote = escapeQuote;\nexports.unescapeQuote = unescapeQuote;\nexports.escapeHtmlEntities = escapeHtmlEntities;\nexports.escapeDangerHtml5Entities = escapeDangerHtml5Entities;\nexports.clearNonPrintableCharacter = clearNonPrintableCharacter;\nexports.friendlyAttrValue = friendlyAttrValue;\nexports.escapeAttrValue = escapeAttrValue;\nexports.onIgnoreTagStripAll = onIgnoreTagStripAll;\nexports.StripTagBody = StripTagBody;\nexports.stripCommentTag = stripCommentTag;\nexports.stripBlankChar = stripBlankChar;\nexports.attributeWrapSign = '\"';\nexports.cssFilter = defaultCSSFilter;\nexports.getDefaultCSSWhiteList = getDefaultCSSWhiteList;\n","/**\n * xss\n *\n * @author Zongmin Lei<leizongmin@gmail.com>\n */\n\nvar DEFAULT = require(\"./default\");\nvar parser = require(\"./parser\");\nvar FilterXSS = require(\"./xss\");\n\n/**\n * filter xss function\n *\n * @param {String} html\n * @param {Object} options { whiteList, onTag, onTagAttr, onIgnoreTag, onIgnoreTagAttr, safeAttrValue, escapeHtml }\n * @return {String}\n */\nfunction filterXSS(html, options) {\n  var xss = new FilterXSS(options);\n  return xss.process(html);\n}\n\nexports = module.exports = filterXSS;\nexports.filterXSS = filterXSS;\nexports.FilterXSS = FilterXSS;\n\n(function () {\n  for (var i in DEFAULT) {\n    exports[i] = DEFAULT[i];\n  }\n  for (var j in parser) {\n    exports[j] = parser[j];\n  }\n})();\n\n// using `xss` on the browser, output `filterXSS` to the globals\nif (typeof window !== \"undefined\") {\n  window.filterXSS = module.exports;\n}\n\n// using `xss` on the WebWorker, output `filterXSS` to the globals\nfunction isWorkerEnv() {\n  return (\n    typeof self !== \"undefined\" &&\n    typeof DedicatedWorkerGlobalScope !== \"undefined\" &&\n    self instanceof DedicatedWorkerGlobalScope\n  );\n}\nif (isWorkerEnv()) {\n  self.filterXSS = module.exports;\n}\n","/**\n * Simple HTML Parser\n *\n * @author Zongmin Lei<leizongmin@gmail.com>\n */\n\nvar _ = require(\"./util\");\n\n/**\n * get tag name\n *\n * @param {String} html e.g. '<a hef=\"#\">'\n * @return {String}\n */\nfunction getTagName(html) {\n  var i = _.spaceIndex(html);\n  var tagName;\n  if (i === -1) {\n    tagName = html.slice(1, -1);\n  } else {\n    tagName = html.slice(1, i + 1);\n  }\n  tagName = _.trim(tagName).toLowerCase();\n  if (tagName.slice(0, 1) === \"/\") tagName = tagName.slice(1);\n  if (tagName.slice(-1) === \"/\") tagName = tagName.slice(0, -1);\n  return tagName;\n}\n\n/**\n * is close tag?\n *\n * @param {String} html 如：'<a hef=\"#\">'\n * @return {Boolean}\n */\nfunction isClosing(html) {\n  return html.slice(0, 2) === \"</\";\n}\n\n/**\n * parse input html and returns processed html\n *\n * @param {String} html\n * @param {Function} onTag e.g. function (sourcePosition, position, tag, html, isClosing)\n * @param {Function} escapeHtml\n * @return {String}\n */\nfunction parseTag(html, onTag, escapeHtml) {\n  \"use strict\";\n\n  var rethtml = \"\";\n  var lastPos = 0;\n  var tagStart = false;\n  var quoteStart = false;\n  var currentPos = 0;\n  var len = html.length;\n  var currentTagName = \"\";\n  var currentHtml = \"\";\n\n  chariterator: for (currentPos = 0; currentPos < len; currentPos++) {\n    var c = html.charAt(currentPos);\n    if (tagStart === false) {\n      if (c === \"<\") {\n        tagStart = currentPos;\n        continue;\n      }\n    } else {\n      if (quoteStart === false) {\n        if (c === \"<\") {\n          rethtml += escapeHtml(html.slice(lastPos, currentPos));\n          tagStart = currentPos;\n          lastPos = currentPos;\n          continue;\n        }\n        if (c === \">\" || currentPos === len - 1) {\n          rethtml += escapeHtml(html.slice(lastPos, tagStart));\n          currentHtml = html.slice(tagStart, currentPos + 1);\n          currentTagName = getTagName(currentHtml);\n          rethtml += onTag(\n            tagStart,\n            rethtml.length,\n            currentTagName,\n            currentHtml,\n            isClosing(currentHtml)\n          );\n          lastPos = currentPos + 1;\n          tagStart = false;\n          continue;\n        }\n        if (c === '\"' || c === \"'\") {\n          var i = 1;\n          var ic = html.charAt(currentPos - i);\n\n          while (ic.trim() === \"\" || ic === \"=\") {\n            if (ic === \"=\") {\n              quoteStart = c;\n              continue chariterator;\n            }\n            ic = html.charAt(currentPos - ++i);\n          }\n        }\n      } else {\n        if (c === quoteStart) {\n          quoteStart = false;\n          continue;\n        }\n      }\n    }\n  }\n  if (lastPos < len) {\n    rethtml += escapeHtml(html.substr(lastPos));\n  }\n\n  return rethtml;\n}\n\nvar REGEXP_ILLEGAL_ATTR_NAME = /[^a-zA-Z0-9\\\\_:.-]/gim;\n\n/**\n * parse input attributes and returns processed attributes\n *\n * @param {String} html e.g. `href=\"#\" target=\"_blank\"`\n * @param {Function} onAttr e.g. `function (name, value)`\n * @return {String}\n */\nfunction parseAttr(html, onAttr) {\n  \"use strict\";\n\n  var lastPos = 0;\n  var lastMarkPos = 0;\n  var retAttrs = [];\n  var tmpName = false;\n  var len = html.length;\n\n  function addAttr(name, value) {\n    name = _.trim(name);\n    name = name.replace(REGEXP_ILLEGAL_ATTR_NAME, \"\").toLowerCase();\n    if (name.length < 1) return;\n    var ret = onAttr(name, value || \"\");\n    if (ret) retAttrs.push(ret);\n  }\n\n  // 逐个分析字符\n  for (var i = 0; i < len; i++) {\n    var c = html.charAt(i);\n    var v, j;\n    if (tmpName === false && c === \"=\") {\n      tmpName = html.slice(lastPos, i);\n      lastPos = i + 1;\n      lastMarkPos = html.charAt(lastPos) === '\"' || html.charAt(lastPos) === \"'\" ? lastPos : findNextQuotationMark(html, i + 1);\n      continue;\n    }\n    if (tmpName !== false) {\n      if (\n        i === lastMarkPos\n      ) {\n        j = html.indexOf(c, i + 1);\n        if (j === -1) {\n          break;\n        } else {\n          v = _.trim(html.slice(lastMarkPos + 1, j));\n          addAttr(tmpName, v);\n          tmpName = false;\n          i = j;\n          lastPos = i + 1;\n          continue;\n        }\n      }\n    }\n    if (/\\s|\\n|\\t/.test(c)) {\n      html = html.replace(/\\s|\\n|\\t/g, \" \");\n      if (tmpName === false) {\n        j = findNextEqual(html, i);\n        if (j === -1) {\n          v = _.trim(html.slice(lastPos, i));\n          addAttr(v);\n          tmpName = false;\n          lastPos = i + 1;\n          continue;\n        } else {\n          i = j - 1;\n          continue;\n        }\n      } else {\n        j = findBeforeEqual(html, i - 1);\n        if (j === -1) {\n          v = _.trim(html.slice(lastPos, i));\n          v = stripQuoteWrap(v);\n          addAttr(tmpName, v);\n          tmpName = false;\n          lastPos = i + 1;\n          continue;\n        } else {\n          continue;\n        }\n      }\n    }\n  }\n\n  if (lastPos < html.length) {\n    if (tmpName === false) {\n      addAttr(html.slice(lastPos));\n    } else {\n      addAttr(tmpName, stripQuoteWrap(_.trim(html.slice(lastPos))));\n    }\n  }\n\n  return _.trim(retAttrs.join(\" \"));\n}\n\nfunction findNextEqual(str, i) {\n  for (; i < str.length; i++) {\n    var c = str[i];\n    if (c === \" \") continue;\n    if (c === \"=\") return i;\n    return -1;\n  }\n}\n\nfunction findNextQuotationMark(str, i) {\n  for (; i < str.length; i++) {\n    var c = str[i];\n    if (c === \" \") continue;\n    if (c === \"'\" || c === '\"') return i;\n    return -1;\n  }\n}\n\nfunction findBeforeEqual(str, i) {\n  for (; i > 0; i--) {\n    var c = str[i];\n    if (c === \" \") continue;\n    if (c === \"=\") return i;\n    return -1;\n  }\n}\n\nfunction isQuoteWrapString(text) {\n  if (\n    (text[0] === '\"' && text[text.length - 1] === '\"') ||\n    (text[0] === \"'\" && text[text.length - 1] === \"'\")\n  ) {\n    return true;\n  } else {\n    return false;\n  }\n}\n\nfunction stripQuoteWrap(text) {\n  if (isQuoteWrapString(text)) {\n    return text.substr(1, text.length - 2);\n  } else {\n    return text;\n  }\n}\n\nexports.parseTag = parseTag;\nexports.parseAttr = parseAttr;\n","module.exports = {\n  indexOf: function (arr, item) {\n    var i, j;\n    if (Array.prototype.indexOf) {\n      return arr.indexOf(item);\n    }\n    for (i = 0, j = arr.length; i < j; i++) {\n      if (arr[i] === item) {\n        return i;\n      }\n    }\n    return -1;\n  },\n  forEach: function (arr, fn, scope) {\n    var i, j;\n    if (Array.prototype.forEach) {\n      return arr.forEach(fn, scope);\n    }\n    for (i = 0, j = arr.length; i < j; i++) {\n      fn.call(scope, arr[i], i, arr);\n    }\n  },\n  trim: function (str) {\n    if (String.prototype.trim) {\n      return str.trim();\n    }\n    return str.replace(/(^\\s*)|(\\s*$)/g, \"\");\n  },\n  spaceIndex: function (str) {\n    var reg = /\\s|\\n|\\t/;\n    var match = reg.exec(str);\n    return match ? match.index : -1;\n  },\n};\n","/**\n * filter xss\n *\n * @author Zongmin Lei<leizongmin@gmail.com>\n */\n\nvar FilterCSS = require(\"cssfilter\").FilterCSS;\nvar DEFAULT = require(\"./default\");\nvar parser = require(\"./parser\");\nvar parseTag = parser.parseTag;\nvar parseAttr = parser.parseAttr;\nvar _ = require(\"./util\");\n\n/**\n * returns `true` if the input value is `undefined` or `null`\n *\n * @param {Object} obj\n * @return {Boolean}\n */\nfunction isNull(obj) {\n  return obj === undefined || obj === null;\n}\n\n/**\n * get attributes for a tag\n *\n * @param {String} html\n * @return {Object}\n *   - {String} html\n *   - {Boolean} closing\n */\nfunction getAttrs(html) {\n  var i = _.spaceIndex(html);\n  if (i === -1) {\n    return {\n      html: \"\",\n      closing: html[html.length - 2] === \"/\",\n    };\n  }\n  html = _.trim(html.slice(i + 1, -1));\n  var isClosing = html[html.length - 1] === \"/\";\n  if (isClosing) html = _.trim(html.slice(0, -1));\n  return {\n    html: html,\n    closing: isClosing,\n  };\n}\n\n/**\n * shallow copy\n *\n * @param {Object} obj\n * @return {Object}\n */\nfunction shallowCopyObject(obj) {\n  var ret = {};\n  for (var i in obj) {\n    ret[i] = obj[i];\n  }\n  return ret;\n}\n\nfunction keysToLowerCase(obj) {\n  var ret = {};\n  for (var i in obj) {\n    if (Array.isArray(obj[i])) {\n      ret[i.toLowerCase()] = obj[i].map(function (item) {\n        return item.toLowerCase();\n      });\n    } else {\n      ret[i.toLowerCase()] = obj[i];\n    }\n  }\n  return ret;\n}\n\n/**\n * FilterXSS class\n *\n * @param {Object} options\n *        whiteList (or allowList), onTag, onTagAttr, onIgnoreTag,\n *        onIgnoreTagAttr, safeAttrValue, escapeHtml\n *        stripIgnoreTagBody, allowCommentTag, stripBlankChar\n *        css{whiteList, onAttr, onIgnoreAttr} `css=false` means don't use `cssfilter`\n */\nfunction FilterXSS(options) {\n  options = shallowCopyObject(options || {});\n\n  if (options.stripIgnoreTag) {\n    if (options.onIgnoreTag) {\n      console.error(\n        'Notes: cannot use these two options \"stripIgnoreTag\" and \"onIgnoreTag\" at the same time'\n      );\n    }\n    options.onIgnoreTag = DEFAULT.onIgnoreTagStripAll;\n  }\n  if (options.whiteList || options.allowList) {\n    options.whiteList = keysToLowerCase(options.whiteList || options.allowList);\n  } else {\n    options.whiteList = DEFAULT.whiteList;\n  }\n\n  this.attributeWrapSign = options.singleQuotedAttributeValue === true ? \"'\" : DEFAULT.attributeWrapSign;\n\n  options.onTag = options.onTag || DEFAULT.onTag;\n  options.onTagAttr = options.onTagAttr || DEFAULT.onTagAttr;\n  options.onIgnoreTag = options.onIgnoreTag || DEFAULT.onIgnoreTag;\n  options.onIgnoreTagAttr = options.onIgnoreTagAttr || DEFAULT.onIgnoreTagAttr;\n  options.safeAttrValue = options.safeAttrValue || DEFAULT.safeAttrValue;\n  options.escapeHtml = options.escapeHtml || DEFAULT.escapeHtml;\n  this.options = options;\n\n  if (options.css === false) {\n    this.cssFilter = false;\n  } else {\n    options.css = options.css || {};\n    this.cssFilter = new FilterCSS(options.css);\n  }\n}\n\n/**\n * start process and returns result\n *\n * @param {String} html\n * @return {String}\n */\nFilterXSS.prototype.process = function (html) {\n  // compatible with the input\n  html = html || \"\";\n  html = html.toString();\n  if (!html) return \"\";\n\n  var me = this;\n  var options = me.options;\n  var whiteList = options.whiteList;\n  var onTag = options.onTag;\n  var onIgnoreTag = options.onIgnoreTag;\n  var onTagAttr = options.onTagAttr;\n  var onIgnoreTagAttr = options.onIgnoreTagAttr;\n  var safeAttrValue = options.safeAttrValue;\n  var escapeHtml = options.escapeHtml;\n  var attributeWrapSign = me.attributeWrapSign;\n  var cssFilter = me.cssFilter;\n\n  // remove invisible characters\n  if (options.stripBlankChar) {\n    html = DEFAULT.stripBlankChar(html);\n  }\n\n  // remove html comments\n  if (!options.allowCommentTag) {\n    html = DEFAULT.stripCommentTag(html);\n  }\n\n  // if enable stripIgnoreTagBody\n  var stripIgnoreTagBody = false;\n  if (options.stripIgnoreTagBody) {\n    stripIgnoreTagBody = DEFAULT.StripTagBody(\n      options.stripIgnoreTagBody,\n      onIgnoreTag\n    );\n    onIgnoreTag = stripIgnoreTagBody.onIgnoreTag;\n  }\n\n  var retHtml = parseTag(\n    html,\n    function (sourcePosition, position, tag, html, isClosing) {\n      var info = {\n        sourcePosition: sourcePosition,\n        position: position,\n        isClosing: isClosing,\n        isWhite: Object.prototype.hasOwnProperty.call(whiteList, tag),\n      };\n\n      // call `onTag()`\n      var ret = onTag(tag, html, info);\n      if (!isNull(ret)) return ret;\n\n      if (info.isWhite) {\n        if (info.isClosing) {\n          return \"</\" + tag + \">\";\n        }\n\n        var attrs = getAttrs(html);\n        var whiteAttrList = whiteList[tag];\n        var attrsHtml = parseAttr(attrs.html, function (name, value) {\n          // call `onTagAttr()`\n          var isWhiteAttr = _.indexOf(whiteAttrList, name) !== -1;\n          var ret = onTagAttr(tag, name, value, isWhiteAttr);\n          if (!isNull(ret)) return ret;\n\n          if (isWhiteAttr) {\n            // call `safeAttrValue()`\n            value = safeAttrValue(tag, name, value, cssFilter);\n            if (value) {\n              return name + '=' + attributeWrapSign + value + attributeWrapSign;\n            } else {\n              return name;\n            }\n          } else {\n            // call `onIgnoreTagAttr()`\n            ret = onIgnoreTagAttr(tag, name, value, isWhiteAttr);\n            if (!isNull(ret)) return ret;\n            return;\n          }\n        });\n\n        // build new tag html\n        html = \"<\" + tag;\n        if (attrsHtml) html += \" \" + attrsHtml;\n        if (attrs.closing) html += \" /\";\n        html += \">\";\n        return html;\n      } else {\n        // call `onIgnoreTag()`\n        ret = onIgnoreTag(tag, html, info);\n        if (!isNull(ret)) return ret;\n        return escapeHtml(html);\n      }\n    },\n    escapeHtml\n  );\n\n  // if enable stripIgnoreTagBody\n  if (stripIgnoreTagBody) {\n    retHtml = stripIgnoreTagBody.remove(retHtml);\n  }\n\n  return retHtml;\n};\n\nmodule.exports = FilterXSS;\n","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = '';\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (arg) {\n\t\t\t\tclasses = appendClass(classes, parseValue(arg));\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction parseValue (arg) {\n\t\tif (typeof arg === 'string' || typeof arg === 'number') {\n\t\t\treturn arg;\n\t\t}\n\n\t\tif (typeof arg !== 'object') {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (Array.isArray(arg)) {\n\t\t\treturn classNames.apply(null, arg);\n\t\t}\n\n\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\treturn arg.toString();\n\t\t}\n\n\t\tvar classes = '';\n\n\t\tfor (var key in arg) {\n\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\tclasses = appendClass(classes, key);\n\t\t\t}\n\t\t}\n\n\t\treturn classes;\n\t}\n\n\tfunction appendClass (value, newClass) {\n\t\tif (!newClass) {\n\t\t\treturn value;\n\t\t}\n\t\n\t\tif (value) {\n\t\t\treturn value + ' ' + newClass;\n\t\t}\n\t\n\t\treturn value + newClass;\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n"],"names":["getNearestInt","num","Math","round","parseFloat","uuid","cryptoObj","window","crypto","msCrypto","random32ByteNumber","randomNumber","max32ByteNumber","rnds32","Uint32Array","getRandomValues","e","random","toString","storages","s","l","getStorage","store","visitorIdExpiry","fptiExpiry","fpti3pKey","appendDataToURL","url","data","key","appendQueryStringData","value","JSON","stringify","indexOf","charAt","length","encodeURIComponent","HOST_PP","VERSION","FPTI_BASE_URL","normalizeData","dataObject","generateBeaconUrl","options","fptiserverurl","parts","split","match","location","protocol","version","basePayLoad","t","Date","getTime","g","getTimezoneOffset","start","end","view","t11","undefined","createTrackingPayload","beaconURL","onBeaconCreate","_tenantName","fpti","tenant_name","hostname","fpti3pIds","fpti_3p","getItem","_getItem","vid","vid_exp","fpti_exp","now","parse","item","storage","setItem","_setItem","setLocalItem","get3pStorage","base","obj","shouldOverride","extend","src","Image","ua","navigator","userAgent","isIE","test","isIOSSafari","referrerPolicy","fireImagePixel","record","inputData","beaconUrl","exports","recordImpression","preRecordCallback","document","title","referrer","screen","colorDepth","screenDimensions","width","height","deviceDimensions","ratio","devicePixelRatio","w","h","abs","orientation","temp","getDeviceDimensions","elem","a","browserDimensions","documentElement","body","cookieEnabled","res","recordWithFetch","result","fetch","__esModule","MessagingLogger","beaver_logger_1","ramda_1","global_data_1","fpti_1","this","getPayloadString","payload","logger","Logger","prefix","flushInterval","logLevel","addMetaBuilder","current_page","href","prototype","logInfo","event","info","logError","error","errorPayload","logFPTIEvent","eventName","eventType","gData","globalData","fptiPayload","fptiValue","mergeDeepRight","event_name","product","platform","comp","experience","tenant","getCSRFToken","apiUtils_1","basePath","locale","doGet","concat","__createBinding","Object","create","o","m","k","k2","desc","getOwnPropertyDescriptor","writable","configurable","enumerable","get","defineProperty","__setModuleDefault","v","__importStar","mod","hasOwnProperty","call","__exportStar","p","__importDefault","Timer","getPageNamesForInstrumentation","doPost","createMasker","MessagingLogger_1","chatApi_1","createMasker_1","utils_1","TimerUtils_1","ConversationType","isRunning","startTime","endTime","startTimer","console","stopTimer","calculateDuration","getStartTime","getStopTime","getIsRunning","path","headers","Promise","resolve","reject","_a","messagingSessionToken","method","credentials","then","response","ok","contentType","includes","text","json","blob","err","code","status","message","statusText","csrfToken","requestHeader","isCreated","resp","xss_1","defaultExpresions","regex","tokenType","country","countryFilter","expression","toUpperCase","maskerConfiguration","tokenizer","stringMasker","filter","fullStringMasker","expresions","fullString","reduceWhile","maskedWord","masked","repeat","original","maskedMessage","trim","replace","map","reduce","increased","tokenMasker","sanitize","setAnalyticsData","init","setCurrentParticipant","getSessionToken","setSessionToken","setCsrfToken","isLoggedIn","enableMultiStream","analyticsData","sessionToken","participantId","currentParticipantId","getBasePath","page","pgrp","_templateObject","_templateObject2","_templateObject3","_templateObject4","_templateObject5","_templateObject6","_templateObject7","_templateObject8","_templateObject9","_templateObject10","_templateObject11","styles","tokens","keys","sysBorderRadiusLg","sysBorderThicknessNormal","sysColorBackgroundSurface","sysColorBackgroundSurfaceHover","sysSizeMediaSm","sysSizeMediaMd","sysSizeMediaLg","sysSpaceLg","sysSpaceMd","sysSpaceSm","sysSizeFieldLg","sysSpaceTiny","sysSpaceXs","elevationStyles","css","suggestionListContainer","elevatedSuggestionListContainer","level3","content","centeredContent","suggestionSublist","suggestionList","highlightedSuggesiton","suggestion","errorMessage","suggestionDecoration","_excluded","SuggestionList","_ref2","_ref2$suggestions","suggestions","renderSuggestion","onHighlight","onSelect","className","listItemClassName","query","_ref2$enableKeyboardI","enableKeyboardInteraction","hasSections","rest","u","_styles","useMemo","_useState","useState","_useState2","highlightedIndex","setHighlightedIndex","highlightedIndexRef","useRef","listRef","_suggestions","acc","section","sectionIndex","forEach","suggestionIndex","push","index","normalizeSuggestions","handleHighlight","evt","current","id","highlightedElm","scrollIntoView","behavior","block","handleSelect","handleKeyDown","currentHighlightedIndex","KeyCode","keyCode","IS_ARROW_UP","preventDefault","IS_ARROW_DOWN","IS_ENTER","useEffect","addEventListener","removeEventListener","currentNormalizedIndex","renderSuggestionList","items","normalizedIndex","arguments","cssVal","suggestionContent","_ref","primaryText","secondaryText","decoration","highlightedValue","secondaryElm","jsx","decorationElm","dangerouslySetInnerHTML","__html","defaultRenderSuggestion","role","ref","el","onMouseDown","onClick","listItems","_excluded$1","getNormalizedSuggestionLength","AutoSuggest","forwardRef","props","_props$id","_props$debounceTimeou","debounceTimeout","_props$fetchSuggestio","fetchSuggestions","_props$suggestionList","isSuggestionListInline","isLoadingSuggestions","onChange","onFocus","onKeyDown","onBlur","onClear","_props$triggerCompone","triggerComponent","_props$defaultSuggest","defaultSuggestionList","suggestionListFooter","suggestionListContainerClassName","suggestionListFooterClassName","suggestionListChangeMessage","_props$suggestionList2","suggestionListLoadingMessage","suggestionListErrorMessage","onSuggestionListClose","timerRef","internalRef","suggestionListContainerRef","areSuggestionsVisible","setSuggestionsVisible","_useState3","_useState4","highlightedSuggestionId","setHighlightedSuggestionId","_useState5","_useState6","isTriggerFocused","setTriggerFocus","inputRef","suggestionsLength","focusSuggestionLength","handleOutsideClick","inputElm","target","contains","clearTimeout","callSuggestionListClose","suggestionListId","footer","suggestionsElm","focusSuggestionElm","loadingElm","screenReaderText","size","errorElm","type","suggestionListContainerCssVal","suggestionContainerElm","_suggestListChangeMessage","otherProps","newValue","setTimeout","IS_ESC","IS_TAB","iconMap","success","warning","ContextualAlert","_ref$type","_ref$typeIconAriaLabe","typeIconAriaLabel","children","_ref$noPadding","noPadding","sysSizeIconXs","textCaption","caption","statusIcon","iconCssVal","StatusIcon","baseCSS","color","self","module","modules","installedModules","moduleId","i","c","d","name","getter","r","Symbol","toStringTag","mode","ns","bind","n","default","object","property","_extends","assign","source","apply","utils_isPromise","Window","constructor","_toString","LOG_LEVEL","constants_PROTOCOL","canUseSendBeacon","extendIfDefined","util_isAmplitude","sendBeacon","getHTTPTransport","flushPromise","dispatchedErrors","possiblyUnhandledPromiseHandlers","activeCount","flushActive","promise","startActive","endActive","promise_ZalgoPromise","ZalgoPromise","handler","_this","resolved","rejected","errorHandled","handlers","dispatching","stack","_result","_error","isAsync","_proto","Error","dispatch","_this2","_err","j","asyncReject","chain","firstPromise","secondPromise","_handlers$i","onSuccess","onError","_result2","promiseResult","catch","finally","onFinally","try","timeout","time","_this3","toPromise","TypeError","lazy","all","promises","count","results","slice","prom","hash","awaitPromises","_loop","onPossiblyUnhandledException","cancel","splice","context","args","delay","_delay","isPromise","flush","IE_WIN_ACCESS_ERROR","getActualProtocol","win","getProtocol","mockDomain","isAboutProtocol","canReadFromWindow","getActualDomain","parent","host","getDomain","domain","isSameDomain","iframeWindows","iframeFrames","isWindowClosed","allowMock","closed","mockclosed","top","iframeIndex","collection","frame","contentWindow","parentNode","doc","ownerDocument","isWindow","__cross_domain_utils_window_check__","util_safeIndexOf","objectIDs","weakmap_CrossDomainSafeWeakMap","CrossDomainSafeWeakMap","weakmap","values","WeakMap","freeze","testWeakMap","testKey","set","_cleanupClosedWindows","delete","isSafeToReadWrite","entry","has","getOrSet","getFunctionName","fn","__name__","displayName","setFunctionName","uniqueID","chars","floor","str","btoa","p1","String","fromCharCode","parseInt","Buffer","from","toISOString","toLowerCase","getEmptyObject","memoizeGlobalIndex","memoizeGlobalIndexValidFrom","memoize","simpleCache","thisCache","_options$thisNamespac","thisNamespace","cacheTime","memoizeIndex","memoizedFunction","_len","Array","_key","cache","cacheKey","subkey","val","uid","element","passed","Element","nodeType","style","_","serializeArgs","_unused","cacheResult","reset","src_util_noop","objFilter","Boolean","isDocumentReady","readyState","isDocumentInteractive","dom_isBrowser","clear","interval","setInterval","clearInterval","currentScript","getCurrentScript","stackDetails","exec","scriptLocation","_i22","_Array$prototype$slic2","getElementsByTagName","reverse","script","currentUID","getAttribute","hashedString","total","charCodeAt","dataset","setAttribute","http_headerBuilders","DEBUG","INFO","WARN","ERROR","FILE","AUTO_FLUSH_LEVEL","LOG_LEVEL_PRIORITY","DEFAULT_LOG_LEVEL","enableSendBeacon","hasHeaders","Blob","_ref2$win","_ref2$useBlob","useBlob","httpWin","_ref$enableSendBeacon","beaconResult","_ref$method","_ref$headers","_ref$win","_ref$timeout","normalizedHeaders","_i4","_Object$keys2","_key2","accept","_i6","builtHeaders","_i8","_Object$keys4","_key3","xhr","XMLHttpRequest","_key4","responseHeaders","rawHeaders","_i2","_rawHeaders$trim$spli2","_line$split","join","getAllResponseHeaders","isJSON","responseBody","responseText","open","setRequestHeader","ontimeout","send","_ref$logLevel","_ref$transport","transport","amplitudeApiKey","_ref$flushInterval","events","tracking","payloadBuilders","metaBuilders","trackingBuilders","headerBuilders","print","level","log","immediateFlush","meta","api_key","event_type","transition_name","event_properties","localPromise","logPayload","timestamp","addBuilder","builders","builder","loop","debug","warn","track","trackingPayload","addPayloadBuilder","addTrackingBuilder","addHeaderBuilder","setTransport","newTransport","configure","opts","DEFAULT","parseStyle","isNull","FilterCSS","ret","shallowCopyObject","whiteList","onAttr","onIgnoreAttr","safeAttrValue","process","sourcePosition","position","check","isWhite","RegExp","getDefaultWhiteList","REGEXP_URL_JAVASCRIPT","html","filterCSS","trimRight","cssLength","isParenthesisOpen","lastPos","retCSS","addNewAttr","arr","scope","add","_curry2","b","Number","_concat","_curry1","curryN","addIndex","idx","origFn","list","adjust","_curry3","len","_idx","_list","_dispatchable","max","pluck","allPass","preds","always","and","_assertPromise","andThen","f","any","anyPass","_reduce","ap","applyF","applyX","x","_aperture","aperture","append","_isArray","mapValues","applySpec","spec","applyTo","ascend","aa","bb","assocPath","assoc","prop","_has","_isInteger","_assoc","isNil","nextObj","nAry","binary","_arity","thisObj","_isFunction","lift","both","_makeFlat","_xchain","monad","clamp","min","_clone","clone","collectBy","group","tag","newList","comparator","pred","complement","pipe","pipeWith","composeWith","xf","_isString","cond","pairs","arity","pair","constructN","construct","Fn","curry","$0","$1","$2","$3","$4","$5","$6","$7","$8","$9","_map","converge","after","fns","countBy","reduceBy","_curryN","dec","defaultTo","descend","_Set","difference","first","second","out","firstLen","secondLen","toFilterOut","_includesWith","differenceWith","dissocPath","dissoc","_dissoc","head","tail","_shallowCloneObject","divide","_xdrop","drop","xs","Infinity","_dropLast","dropLast","_dropLastWhile","dropLastWhile","_xdropRepeatsWith","dropRepeatsWith","equals","dropRepeats","last","_xdropWhile","dropWhile","or","either","_isArguments","_isObject","_isTypedArray","empty","takeLast","endsWith","suffix","eqBy","y","eqProps","obj1","obj2","_equals","evolve","transformations","transformation","_filter","_xfilter","filterable","find","findIndex","findLast","findLastIndex","flatten","flip","_checkForMethod","forEachObjIndexed","keyList","fromPairs","groupBy","groupWith","nextidx","gt","gte","hasPath","hasIn","_path","nth","_objectIs","identical","identity","ifElse","condition","onTrue","onFalse","inc","_includes","F","T","__","compose","indexBy","innerJoin","insert","insertAll","intersection","intersperse","into","invert","invertObj","invoker","is","isEmpty","juxt","keysIn","lastIndexOf","lens","lensIndex","lensPath","lensProp","liftN","lt","lte","mapAccum","mapAccumRight","mapObjIndexed","mathMod","maxBy","mean","median","memoizeWith","mergeAll","mergeDeepLeft","mergeDeepWith","mergeDeepWithKey","mergeLeft","mergeRight","mergeWith","mergeWithKey","minBy","modify","modifyPath","modulo","move","multiply","partialObject","negate","none","not","nthArg","objOf","of","omit","on","once","otherwise","over","partial","partialRight","partition","paths","pathEq","pathOr","pathSatisfies","pick","pickAll","pickBy","prepend","project","promap","propEq","propIs","propOr","propSatisfies","range","reduceRight","reduced","remove","scan","sequence","sort","sortBy","sortWith","splitAt","splitEvery","splitWhen","splitWhenever","startsWith","subtract","sum","symmetricDifference","symmetricDifferenceWith","take","takeLastWhile","takeWhile","tap","times","toLower","toPairs","toPairsIn","toUpper","transduce","transpose","traverse","tryCatch","unapply","unary","uncurryN","unfold","union","unionWith","uniq","uniqBy","uniqWith","unless","unnest","until","unwind","update","useWith","valuesIn","when","where","whereAny","whereEq","without","xor","xprod","zip","zipObj","zipWith","thunkify","_indexOf","ys","elt","elts","_nativeSet","Set","_items","hasOrAdd","shouldAdd","prevSize","bIdx","limit","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","iter","next","done","methodname","_cloneRegExp","refFrom","refTo","deep","copy","copiedValue","getPrototypeOf","valueOf","pattern","global","ignoreCase","multiline","sticky","unicode","set1","set2","len1","len2","_isPlaceholder","f1","f2","_b","f3","_c","received","combined","argsIdx","left","combinedIdx","_isTransformer","methodNames","transducerCreator","transducer","_arrayFromIterator","_functionName","_uniqContentEquals","aIterator","bIterator","stackA","stackB","eq","aItem","typeA","entries","keysA","extendedStackA","extendedStackB","_forceReduced","_isArrayLike","_xfBase","rxf","input","preservingReduced","inf","isArray","isInteger","recursive","flatt","jlen","ilen","functor","output","nextKey","profunctor","_xwrap","_iterableReduce","step","_methodReduce","methodName","symIterator","iterator","_arrayReduce","_objectAssign","_identity","_stepCatArray","_stepCatString","_stepCatObject","pad","_toISOString","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","toFixed","_quote","seen","recur","mapPairs","isNaN","NaN","repr","_reduced","XAll","_xall","XAny","_xany","XAperture","pos","full","getCopy","_xaperture","_flatCat","XDrop","XDropLast","_xdropLast","XDropLastWhile","retained","retain","_xdropLastWhile","XDropRepeatsWith","lastValue","seenFirstValue","sameAsLast","XDropWhile","XFilter","XFind","found","_xfind","XFindIndex","_xfindIndex","XFindLast","_xfindLast","XFindLastIndex","lastIdx","_xfindLastIndex","XMap","_xmap","_promap","XPromap","_xpromap","XReduceBy","valueFn","valueAcc","keyFn","inputs","_xreduceBy","XTake","_xtake","XTakeWhile","_xtakeWhile","XTap","_xtap","XUniqBy","_xuniqBy","XUniqWith","_xuniqWith","XWrap","list1","list2","lookupList","filteredList","separator","_stepCat","Ctor","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","hasArgsEnumBug","nIdx","ks","checkArgsLength","_isNumber","setter","toFunctorFn","focus","lifted","tuple","rx","mFn","lObj","rObj","lVal","rVal","_l","_r","_modify","to","positiveFrom","positiveTo","_complement","offset","names","called","Identity","fst","snd","_createPartialApplicator","pathAr","propPath","pathsArray","_pipe","headList","tailList","ps","replacement","traversable","fromIndex","toIndex","array","curr","_isRegExp","fnArgs","RangeError","outerlist","innerlist","ws","beginRx","endRx","tryer","catcher","depth","endIdx","currentDepth","seed","appliedItem","whenFalseFn","transformers","vals","vs","Const","whenTrueFn","testObj","rv","getDefaultCSSWhiteList","defaultCSSFilter","escapeHtml","REGEXP_LT","REGEXP_GT","REGEXP_QUOTE","REGEXP_QUOTE_2","REGEXP_ATTR_VALUE_1","REGEXP_ATTR_VALUE_COLON","REGEXP_ATTR_VALUE_NEWLINE","REGEXP_DEFAULT_ON_TAG_ATTR_4","REGEXP_DEFAULT_ON_TAG_ATTR_7","REGEXP_DEFAULT_ON_TAG_ATTR_8","escapeQuote","unescapeQuote","escapeHtmlEntities","substr","escapeDangerHtml5Entities","clearNonPrintableCharacter","str2","friendlyAttrValue","escapeAttrValue","abbr","address","area","article","aside","audio","bdi","bdo","big","blockquote","br","center","cite","col","colgroup","dd","del","details","div","dl","dt","em","figcaption","figure","font","h1","h2","h3","h4","h5","h6","header","hr","img","ins","kbd","li","mark","nav","ol","pre","small","span","sub","summary","sup","strong","strike","table","tbody","td","tfoot","th","thead","tr","tt","ul","video","onTag","onIgnoreTag","onTagAttr","onIgnoreTagAttr","cssFilter","lastIndex","onIgnoreTagStripAll","StripTagBody","tags","isRemoveAllTag","removeList","posStart","isRemoveTag","isClosing","rethtml","stripCommentTag","retHtml","stripBlankChar","char","attributeWrapSign","parser","FilterXSS","filterXSS","DedicatedWorkerGlobalScope","getTagName","tagName","spaceIndex","REGEXP_ILLEGAL_ATTR_NAME","findNextEqual","findNextQuotationMark","findBeforeEqual","stripQuoteWrap","isQuoteWrapString","parseTag","tagStart","quoteStart","currentPos","currentTagName","currentHtml","chariterator","ic","parseAttr","lastMarkPos","retAttrs","tmpName","addAttr","stripIgnoreTag","allowList","keysToLowerCase","singleQuotedAttributeValue","me","allowCommentTag","stripIgnoreTagBody","attrs","closing","getAttrs","whiteAttrList","attrsHtml","isWhiteAttr","hasOwn","classNames","classes","arg","appendClass","parseValue","newClass"],"sourceRoot":""}