{"version":3,"file":"js/55444-40663ef1e279d97aaeb3.js","mappings":"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","sources":["webpack://StravaModern/./node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack://StravaModern/./node_modules/@strava/react-hooks/src/use-safe-state/useSafeState.hook.ts","webpack://StravaModern/./node_modules/@strava/ui/node_modules/@strava/icons/dist/NavigationProfileHighlightedMedium.js","webpack://StravaModern/./node_modules/@strava/ui/node_modules/@strava/icons/dist/BadgesMulticolorSuperuserSmall.js","webpack://StravaModern/./node_modules/@strava/ui/node_modules/@strava/icons/dist/BadgesMulticolorSummitSmall.js","webpack://StravaModern/./node_modules/@strava/ui/node_modules/@strava/icons/dist/BadgesMulticolorProSmall.js","webpack://StravaModern/./node_modules/@strava/ui/node_modules/@strava/icons/dist/BadgesMulticolorVerifiedSmall.js","webpack://StravaModern/./node_modules/@strava/ui/Avatar/Avatar.module.scss?3ebc","webpack://StravaModern/./node_modules/@strava/ui/Avatar/Avatar.tsx","webpack://StravaModern/./node_modules/@strava/ui/Stat/Stat.module.scss?3051","webpack://StravaModern/./node_modules/@strava/ui/Stat/Stat.tsx","webpack://StravaModern/./node_modules/@strava/ui/Stats/styles.module.scss?4754","webpack://StravaModern/./node_modules/@strava/ui/Stats/index.js","webpack://StravaModern/./node_modules/classnames/index.js","webpack://StravaModern/./node_modules/decimal.js-light/decimal.js","webpack://StravaModern/./node_modules/dom-helpers/class/addClass.js","webpack://StravaModern/./node_modules/dom-helpers/class/hasClass.js","webpack://StravaModern/./node_modules/dom-helpers/class/removeClass.js","webpack://StravaModern/./node_modules/lodash/_Symbol.js","webpack://StravaModern/./node_modules/lodash/_baseGetTag.js","webpack://StravaModern/./node_modules/lodash/_freeGlobal.js","webpack://StravaModern/./node_modules/lodash/_getRawTag.js","webpack://StravaModern/./node_modules/lodash/_objectToString.js","webpack://StravaModern/./node_modules/lodash/_root.js","webpack://StravaModern/./node_modules/lodash/isObject.js","webpack://StravaModern/./node_modules/lodash/isObjectLike.js","webpack://StravaModern/./node_modules/lodash/isSymbol.js","webpack://StravaModern/./node_modules/react-lifecycles-compat/react-lifecycles-compat.es.js","webpack://StravaModern/./node_modules/recharts-scale/es6/util/utils.js","webpack://StravaModern/./node_modules/recharts-scale/es6/util/arithmetic.js","webpack://StravaModern/./node_modules/recharts-scale/es6/getNiceTickValues.js"],"sourcesContent":["function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\n\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","import {\n  Dispatch,\n  SetStateAction,\n  useRef,\n  useCallback,\n  useEffect,\n  useState\n} from 'react';\n\n/**\n * The `useSafeState` hook acts the same as React's `useState`,\n * where we can set the initial state, and it returns (1) the current state,\n * and (2) the state setter.\n *\n * But with `useSafeState`, it will only set the state when the component is mounted\n * in order to prevent memory leaks and avoid this warning:\n * \"Warning: Can’t perform a React state update on an unmounted component.\"\n * When a component is unmounted, we don't want to set the state.\n *\n * This helps when we have async behavior where we call an async API call,\n * then based on the async response, we set the state. But if the component\n * unmounts before the API call resolves, we don't want to set the state.\n * */\n// eslint-disable-next-line import/prefer-default-export\nexport const useSafeState = <S>(\n  initialState: S | (() => S)\n): [S, Dispatch<SetStateAction<S>>] => {\n  const mountedRef = useRef(false);\n  const [state, setState] = useState(initialState);\n\n  useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  const setSafeState = useCallback(\n    (args: SetStateAction<S>) =>\n      mountedRef.current ? setState(args) : () => {},\n    []\n  );\n\n  return [state, setSafeState];\n};\n","import * as React from \"react\";\nimport PropTypes from \"prop-types\";\nconst SvgNavigationProfileHighlightedMedium = React.forwardRef(\n  ({ color, size, title, titleId, ...props }, ref) => (\n    <svg\n      fill={color}\n      xmlns=\"http://www.w3.org/2000/svg\"\n      viewBox=\"0 0 32 32\"\n      ref={ref}\n      width={size}\n      height={size}\n      aria-labelledby={titleId}\n      {...props}\n    >\n      {title ? <title id={titleId}>{title}</title> : null}\n      <path\n        d=\"M16 17.825a6.825 6.825 0 100-13.65 6.825 6.825 0 000 13.65zm13.383 8.422l-1.234-2.32a8.852 8.852 0 00-7.833-4.7h-8.632a8.852 8.852 0 00-7.833 4.7l-1.234 2.32A3.826 3.826 0 006 31.871h20.01a3.826 3.826 0 003.378-5.624z\"\n        fill=\"\"\n      />\n    </svg>\n  )\n);\nSvgNavigationProfileHighlightedMedium.defaultProps = {\n  color: \"currentColor\",\n  size: 32,\n  title: undefined,\n  titleId: undefined,\n};\nSvgNavigationProfileHighlightedMedium.propTypes = {\n  color: PropTypes.string,\n  size: PropTypes.number,\n  title: PropTypes.string,\n  titleId: PropTypes.string,\n};\nexport default SvgNavigationProfileHighlightedMedium;\n","import * as React from \"react\";\nimport PropTypes from \"prop-types\";\nconst SvgBadgesMulticolorSuperuserSmall = React.forwardRef(\n  ({ color, size, title, titleId, ...props }, ref) => (\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      viewBox=\"0 0 24 24\"\n      ref={ref}\n      fill={color}\n      width={size}\n      height={size}\n      aria-labelledby={titleId}\n      {...props}\n    >\n      {title ? <title id={titleId}>{title}</title> : null}\n      <g fill=\"none\" fillRule=\"evenodd\">\n        <path\n          fill=\"#FEFEFE\"\n          d=\"M.844.999C.584.561.894 0 1.394 0h14.721a.32.32 0 01.275.159l7.021 11.842-7.021 11.842a.324.324 0 01-.275.159H1.395c-.502 0-.81-.561-.551-1L7.365 12 .844.999z\"\n        />\n        <path\n          fill=\"#FC4C02\"\n          d=\"M16.562 12h-2.229L8.979 3H5.826l5.465 9H9.044L2.987 2.006a.333.333 0 01.285-.506h11.76c.234 0 .45.122.57.321l6.17 10.18h-2.17L14.25 2.974h-3.153L16.562 12z\"\n        />\n        <path\n          fill=\"#CF4017\"\n          d=\"M19.602 12h2.17l-6.17 10.18a.666.666 0 01-.57.32H3.272a.333.333 0 01-.285-.506L9.044 12h2.247l-5.439 9H9l5.333-9h2.229l-5.44 9h3.15l5.33-9z\"\n        />\n      </g>\n    </svg>\n  )\n);\nSvgBadgesMulticolorSuperuserSmall.defaultProps = {\n  color: \"currentColor\",\n  size: 24,\n  title: undefined,\n  titleId: undefined,\n};\nSvgBadgesMulticolorSuperuserSmall.propTypes = {\n  color: PropTypes.string,\n  size: PropTypes.number,\n  title: PropTypes.string,\n  titleId: PropTypes.string,\n};\nexport default SvgBadgesMulticolorSuperuserSmall;\n","import * as React from \"react\";\nimport PropTypes from \"prop-types\";\nconst SvgBadgesMulticolorSummitSmall = React.forwardRef(\n  ({ color, size, title, titleId, ...props }, ref) => (\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      viewBox=\"0 0 24 24\"\n      ref={ref}\n      fill={color}\n      width={size}\n      height={size}\n      aria-labelledby={titleId}\n      {...props}\n    >\n      {title ? <title id={titleId}>{title}</title> : null}\n      <g fill=\"none\" fillRule=\"evenodd\">\n        <path\n          fill=\"#FEFEFE\"\n          d=\"M.844.999C.584.561.894 0 1.394 0h14.721a.32.32 0 01.275.159l7.021 11.842-7.021 11.842a.324.324 0 01-.275.159H1.395c-.502 0-.81-.561-.551-1L7.365 12 .844.999z\"\n        />\n        <path\n          fill=\"#FC4C02\"\n          d=\"M21.772 12l-6.17-10.179a.67.67 0 00-.57-.321H3.272c-.26 0-.42.284-.285.507L9.044 12h12.728z\"\n        />\n        <path\n          fill=\"#CF4017\"\n          d=\"M2.987 21.994L9.044 12h12.728l-6.17 10.179a.67.67 0 01-.57.32H3.272a.334.334 0 01-.285-.506\"\n        />\n      </g>\n    </svg>\n  )\n);\nSvgBadgesMulticolorSummitSmall.defaultProps = {\n  color: \"currentColor\",\n  size: 24,\n  title: undefined,\n  titleId: undefined,\n};\nSvgBadgesMulticolorSummitSmall.propTypes = {\n  color: PropTypes.string,\n  size: PropTypes.number,\n  title: PropTypes.string,\n  titleId: PropTypes.string,\n};\nexport default SvgBadgesMulticolorSummitSmall;\n","import * as React from \"react\";\nimport PropTypes from \"prop-types\";\nconst SvgBadgesMulticolorProSmall = React.forwardRef(\n  ({ color, size, title, titleId, ...props }, ref) => (\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      viewBox=\"0 0 24 24\"\n      ref={ref}\n      fill={color}\n      width={size}\n      height={size}\n      aria-labelledby={titleId}\n      {...props}\n    >\n      {title ? <title id={titleId}>{title}</title> : null}\n      <g fill=\"none\" fillRule=\"evenodd\">\n        <path\n          fill=\"#FEFEFE\"\n          d=\"M.844.999C.584.561.894 0 1.394 0h14.721a.32.32 0 01.275.159l7.021 11.842-7.021 11.842a.324.324 0 01-.275.159H1.395c-.502 0-.81-.561-.551-1L7.365 12 .844.999z\"\n        />\n        <path\n          fill=\"#FC4C02\"\n          d=\"M16.408 12L9.982 1.5h5.05c.234 0 .45.121.571.321L21.771 12h-5.363zm-1.5 0H9.044L2.988 2.005a.332.332 0 01.284-.505h5.19L14.908 12z\"\n        />\n        <path\n          fill=\"#CF4017\"\n          d=\"M14.908 12l-6.44 10.5H3.272a.333.333 0 01-.285-.506l6.057-9.995h5.863V12zm1.5 0h5.362l-6.168 10.178a.666.666 0 01-.57.321H9.99L16.408 12z\"\n        />\n      </g>\n    </svg>\n  )\n);\nSvgBadgesMulticolorProSmall.defaultProps = {\n  color: \"currentColor\",\n  size: 24,\n  title: undefined,\n  titleId: undefined,\n};\nSvgBadgesMulticolorProSmall.propTypes = {\n  color: PropTypes.string,\n  size: PropTypes.number,\n  title: PropTypes.string,\n  titleId: PropTypes.string,\n};\nexport default SvgBadgesMulticolorProSmall;\n","import * as React from \"react\";\nimport PropTypes from \"prop-types\";\nconst SvgBadgesMulticolorVerifiedSmall = React.forwardRef(\n  ({ color, size, title, titleId, ...props }, ref) => (\n    <svg\n      xmlns=\"http://www.w3.org/2000/svg\"\n      viewBox=\"0 0 24 24\"\n      ref={ref}\n      fill={color}\n      width={size}\n      height={size}\n      aria-labelledby={titleId}\n      {...props}\n    >\n      {title ? <title id={titleId}>{title}</title> : null}\n      <g fill=\"none\" fillRule=\"evenodd\">\n        <path\n          fill=\"#FEFEFE\"\n          d=\"M23.79 9.713L20.724 7.14l-.696-3.94a.592.592 0 00-.582-.49h-4L12.38.14A.596.596 0 0012 0a.597.597 0 00-.38.14L8.555 2.71H4.553a.592.592 0 00-.582.49l-.694 3.94L.21 9.713a.593.593 0 00-.132.748l2 3.465-.694 3.94a.593.593 0 00.38.659l3.76 1.368 2.001 3.466a.59.59 0 00.714.26l3.76-1.37 3.76 1.37a.595.595 0 00.715-.26l2-3.466 3.76-1.368a.591.591 0 00.38-.659l-.695-3.94 2.001-3.465a.591.591 0 00-.132-.748\"\n        />\n        <path\n          fill=\"#FC4C02\"\n          d=\"M22.154 10.011a.51.51 0 01.113.644l-1.718 2.974.597 3.384a.508.508 0 01-.327.566l-3.228 1.174-1.719 2.976a.505.505 0 01-.613.224l-3.23-1.175-3.228 1.175a.505.505 0 01-.614-.224L6.47 18.753 3.24 17.58a.508.508 0 01-.327-.566l.597-3.384-1.72-2.974a.508.508 0 01.115-.644l2.632-2.21.597-3.383a.507.507 0 01.5-.42H9.07l2.633-2.208a.505.505 0 01.652 0l2.633 2.208h3.436c.246 0 .456.177.5.42l.597 3.384 2.632 2.21zM16.07 8.705l-5.52 5.52-2.456-2.458a.856.856 0 00-1.211 1.211l3.062 3.063a.856.856 0 001.211 0l6.125-6.125a.856.856 0 00-1.21-1.211z\"\n        />\n      </g>\n    </svg>\n  )\n);\nSvgBadgesMulticolorVerifiedSmall.defaultProps = {\n  color: \"currentColor\",\n  size: 24,\n  title: undefined,\n  titleId: undefined,\n};\nSvgBadgesMulticolorVerifiedSmall.propTypes = {\n  color: PropTypes.string,\n  size: PropTypes.number,\n  title: PropTypes.string,\n  titleId: PropTypes.string,\n};\nexport default SvgBadgesMulticolorVerifiedSmall;\n","// extracted by mini-css-extract-plugin\nexport default {\"avatar\":\"Avatar--avatar--EjA+i\",\"imgWrapper\":\"Avatar--imgWrapper--no4rK\",\"badge\":\"Avatar--badge--AGhgx\",\"athlete\":\"Avatar--athlete--swByo\",\"xsmall\":\"Avatar--xsmall--ooxrp\",\"small\":\"Avatar--small--d-InS\",\"large\":\"Avatar--large--yUfy1\",\"xlarge\":\"Avatar--xlarge--Yt5UL\",\"club\":\"Avatar--club--HMeLa\",\"default\":\"Avatar--default--cRgUh\"};","import React, { useEffect } from 'react';\nimport { useSafeState } from '@strava/react-hooks/src/use-safe-state';\nimport AvatarFallback from '@strava/icons/NavigationProfileHighlightedMedium';\nimport EmployeeBadge from '@strava/icons/BadgesMulticolorSuperuserSmall';\nimport SubscriberBadge from '@strava/icons/BadgesMulticolorSummitSmall';\nimport ProBadge from '@strava/icons/BadgesMulticolorProSmall';\nimport VerifiedBadge from '@strava/icons/BadgesMulticolorVerifiedSmall';\nimport clsx from '../clsx';\n\nimport styles from './Avatar.module.scss';\n\ninterface ImgProps {\n  src: string;\n  alt: string;\n  title: string;\n  fallback?: React.ReactNode;\n}\n\nconst Img = ({ src, alt, title, fallback = null }: ImgProps) => {\n  const [children, setChildren] = useSafeState<React.ReactNode | null>(\n    <img src={src} alt={alt} title={title} />\n  );\n\n  useEffect(() => {\n    let image: HTMLImageElement | null = new Image();\n    image.onload = () => {\n      setChildren(<img src={src} alt={alt} title={title} />);\n    };\n    image.onerror = () => {\n      setChildren(fallback);\n    };\n    image.src = src;\n    return () => {\n      image = null;\n    };\n  }, [src, alt, title, fallback]);\n\n  return <>{children}</>;\n};\n\nfunction getBadge(badge: string) {\n  switch (badge) {\n    case 'ambassador':\n      return <ProBadge />;\n    case 'employee':\n      return <EmployeeBadge />;\n    case 'subscriber':\n    case 'premium':\n      return <SubscriberBadge />;\n    case 'pro':\n      return <ProBadge />;\n    case 'verified':\n      return <VerifiedBadge />;\n    default:\n      return null;\n  }\n}\n\nexport type AvatarType = 'athlete' | 'club';\nexport type AvatarSize = 'xsmall' | 'small' | 'default' | 'large' | 'xlarge';\nexport type AvatarBadge =\n  | '' // in some cases active has member_type as empty string for default users\n  | 'ambassador'\n  | 'employee'\n  | 'subscriber'\n  | 'premium' // legacy name referring to 'subscriber', used in active\n  | 'pro'\n  | 'verified';\n\ninterface BaseAvatarProps {\n  src: string;\n  type: AvatarType;\n  name?: string;\n  alt?: string;\n  title?: string;\n  size?: AvatarSize;\n  badge?: AvatarBadge;\n  className?: string;\n}\n\ntype AnchorProps = React.ComponentPropsWithoutRef<'a'> & {\n  href?: string;\n};\ntype DivProps = React.ComponentPropsWithoutRef<'div'> & {\n  href?: never;\n};\n\n// Guard to check if href exists in props\nconst hasHref = (props: AnchorProps | DivProps): props is AnchorProps =>\n  'href' in props;\n\ntype AvatarProps = BaseAvatarProps & (AnchorProps | DivProps);\n\n/**\n * Prop Deprecation Warning: We are slowly deprecating the `name` prop in favor of the `title` prop\n * so that the React props match up to the element's attribute.\n * */\nconst Avatar = ({\n  name = '',\n  alt = '',\n  title,\n  type,\n  src,\n  size,\n  badge,\n  className,\n  ...otherProps\n}: AvatarProps) => {\n  const classNames = clsx([\n    styles.avatar,\n    styles[type],\n    className,\n    size && styles[size]\n  ]);\n\n  // TODO: uncomment when existing Avatar usage is refactored. Otherwise, there will be a lot of warning in the console.\n  // if (name || process.env.NODE_ENV !== 'production') {\n  //   console.warn(\n  //     '[Prop Deprecation Warning] Deprecating the `name` prop in favor of the `title`.'\n  //   );\n  // }\n\n  const children = (\n    <>\n      {badge && <div className={styles.badge}>{getBadge(badge)}</div>}\n      <div className={styles.imgWrapper}>\n        <Img\n          src={src}\n          alt={alt}\n          title={title || name}\n          fallback={type === 'athlete' ? <AvatarFallback /> : null}\n        />\n      </div>\n    </>\n  );\n\n  if (hasHref(otherProps)) {\n    return (\n      <a className={classNames} data-testid=\"avatar-wrapper\" {...otherProps}>\n        {children}\n      </a>\n    );\n  }\n\n  return (\n    <div\n      className={classNames}\n      data-testid=\"avatar-wrapper\"\n      {...(otherProps as DivProps)}\n    >\n      {children}\n    </div>\n  );\n};\n\nexport default Avatar;\n","// extracted by mini-css-extract-plugin\nexport default {\"stat\":\"Stat--stat--7Qurd\",\"statLabel\":\"Stat--statLabel--qWLL-\",\"statValue\":\"Stat--statValue--7eWuL\",\"stat-xs\":\"Stat--stat-xs--svVNE\",\"statXs\":\"Stat--stat-xs--svVNE\",\"stat-sm\":\"Stat--stat-sm--7BLLi\",\"statSm\":\"Stat--stat-sm--7BLLi\",\"stat-lg\":\"Stat--stat-lg--bYBGt\",\"statLg\":\"Stat--stat-lg--bYBGt\",\"stat-xl\":\"Stat--stat-xl--GtHFn\",\"statXl\":\"Stat--stat-xl--GtHFn\"};","import React, { ReactNode } from 'react';\n\nimport styles from './Stat.module.scss';\n\nimport clsx from '../clsx';\n\nexport const StatTypes = ['stat-xs', 'stat-sm', 'stat-lg', 'stat-xl'] as const;\ntype StatTypesType = (typeof StatTypes)[number];\n\ninterface StatProps {\n  value: string | number | ReactNode;\n  label?: string;\n  type?: StatTypesType;\n  wrapperClassName?: string;\n  labelClassName?: string;\n  valueClassName?: string;\n  labelAfterValue?: boolean;\n}\n\nconst Stat = ({\n  value,\n  label,\n  type,\n  wrapperClassName,\n  labelClassName,\n  valueClassName,\n  labelAfterValue = false\n}: StatProps) => {\n  const labelElement = (\n    <span className={clsx(styles.statLabel, labelClassName)}>{label}</span>\n  );\n\n  return (\n    <div className={clsx(styles.stat, type && styles[type], wrapperClassName)}>\n      {!labelAfterValue && labelElement}\n      <div className={clsx(styles.statValue, valueClassName)}>{value}</div>\n      {labelAfterValue && labelElement}\n    </div>\n  );\n};\n\nexport default Stat;\n","// extracted by mini-css-extract-plugin\nexport default {\"listStats\":\"Stats--listStats--hRQeq\"};","import React from 'react';\nimport PropTypes from 'prop-types';\n\nimport styles from './styles.module.scss';\n\nconst Stats = (props) => {\n  const { children, listClassName } = props;\n\n  return (\n    <ul className={`${styles.listStats} ${listClassName || ''}`}>\n      {React.Children.map(\n        children,\n        (child) => (child && <li key={child.label}>{child}</li>) || ''\n      )}\n    </ul>\n  );\n};\n\nStats.propTypes = {\n  children: PropTypes.node.isRequired,\n  listClassName: PropTypes.string\n};\n\nStats.defaultProps = {\n  listClassName: null\n};\n\nexport default Stats;\n","/*!\n  Copyright (c) 2018 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://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) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tif (arg.length) {\n\t\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\t\tif (inner) {\n\t\t\t\t\t\tclasses.push(inner);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tif (arg.toString === Object.prototype.toString) {\n\t\t\t\t\tfor (var key in arg) {\n\t\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tclasses.push(arg.toString());\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\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","/*! decimal.js-light v2.5.1 https://github.com/MikeMcl/decimal.js-light/LICENCE */\r\n;(function (globalScope) {\r\n  'use strict';\r\n\r\n\r\n  /*\r\n   *  decimal.js-light v2.5.1\r\n   *  An arbitrary-precision Decimal type for JavaScript.\r\n   *  https://github.com/MikeMcl/decimal.js-light\r\n   *  Copyright (c) 2020 Michael Mclaughlin <M8ch88l@gmail.com>\r\n   *  MIT Expat Licence\r\n   */\r\n\r\n\r\n  // -----------------------------------  EDITABLE DEFAULTS  ------------------------------------ //\r\n\r\n\r\n    // The limit on the value of `precision`, and on the value of the first argument to\r\n    // `toDecimalPlaces`, `toExponential`, `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n  var MAX_DIGITS = 1e9,                        // 0 to 1e9\r\n\r\n\r\n    // The initial configuration properties of the Decimal constructor.\r\n    Decimal = {\r\n\r\n      // These values must be integers within the stated ranges (inclusive).\r\n      // Most of these values can be changed during run-time using `Decimal.config`.\r\n\r\n      // The maximum number of significant digits of the result of a calculation or base conversion.\r\n      // E.g. `Decimal.config({ precision: 20 });`\r\n      precision: 20,                         // 1 to MAX_DIGITS\r\n\r\n      // The rounding mode used by default by `toInteger`, `toDecimalPlaces`, `toExponential`,\r\n      // `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n      //\r\n      // ROUND_UP         0 Away from zero.\r\n      // ROUND_DOWN       1 Towards zero.\r\n      // ROUND_CEIL       2 Towards +Infinity.\r\n      // ROUND_FLOOR      3 Towards -Infinity.\r\n      // ROUND_HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n      // ROUND_HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n      // ROUND_HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n      // ROUND_HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n      // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n      //\r\n      // E.g.\r\n      // `Decimal.rounding = 4;`\r\n      // `Decimal.rounding = Decimal.ROUND_HALF_UP;`\r\n      rounding: 4,                           // 0 to 8\r\n\r\n      // The exponent value at and beneath which `toString` returns exponential notation.\r\n      // JavaScript numbers: -7\r\n      toExpNeg: -7,                          // 0 to -MAX_E\r\n\r\n      // The exponent value at and above which `toString` returns exponential notation.\r\n      // JavaScript numbers: 21\r\n      toExpPos:  21,                         // 0 to MAX_E\r\n\r\n      // The natural logarithm of 10.\r\n      // 115 digits\r\n      LN10: '2.302585092994045684017991454684364207601101488628772976033327900967572609677352480235997205089598298341967784042286'\r\n    },\r\n\r\n\r\n  // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //\r\n\r\n\r\n    external = true,\r\n\r\n    decimalError = '[DecimalError] ',\r\n    invalidArgument = decimalError + 'Invalid argument: ',\r\n    exponentOutOfRange = decimalError + 'Exponent out of range: ',\r\n\r\n    mathfloor = Math.floor,\r\n    mathpow = Math.pow,\r\n\r\n    isDecimal = /^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n\r\n    ONE,\r\n    BASE = 1e7,\r\n    LOG_BASE = 7,\r\n    MAX_SAFE_INTEGER = 9007199254740991,\r\n    MAX_E = mathfloor(MAX_SAFE_INTEGER / LOG_BASE),    // 1286742750677284\r\n\r\n    // Decimal.prototype object\r\n    P = {};\r\n\r\n\r\n  // Decimal prototype methods\r\n\r\n\r\n  /*\r\n   *  absoluteValue                       abs\r\n   *  comparedTo                          cmp\r\n   *  decimalPlaces                       dp\r\n   *  dividedBy                           div\r\n   *  dividedToIntegerBy                  idiv\r\n   *  equals                              eq\r\n   *  exponent\r\n   *  greaterThan                         gt\r\n   *  greaterThanOrEqualTo                gte\r\n   *  isInteger                           isint\r\n   *  isNegative                          isneg\r\n   *  isPositive                          ispos\r\n   *  isZero\r\n   *  lessThan                            lt\r\n   *  lessThanOrEqualTo                   lte\r\n   *  logarithm                           log\r\n   *  minus                               sub\r\n   *  modulo                              mod\r\n   *  naturalExponential                  exp\r\n   *  naturalLogarithm                    ln\r\n   *  negated                             neg\r\n   *  plus                                add\r\n   *  precision                           sd\r\n   *  squareRoot                          sqrt\r\n   *  times                               mul\r\n   *  toDecimalPlaces                     todp\r\n   *  toExponential\r\n   *  toFixed\r\n   *  toInteger                           toint\r\n   *  toNumber\r\n   *  toPower                             pow\r\n   *  toPrecision\r\n   *  toSignificantDigits                 tosd\r\n   *  toString\r\n   *  valueOf                             val\r\n   */\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the absolute value of this Decimal.\r\n   *\r\n   */\r\n  P.absoluteValue = P.abs = function () {\r\n    var x = new this.constructor(this);\r\n    if (x.s) x.s = 1;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1    if the value of this Decimal is greater than the value of `y`,\r\n   *  -1    if the value of this Decimal is less than the value of `y`,\r\n   *   0    if they have the same value\r\n   *\r\n   */\r\n  P.comparedTo = P.cmp = function (y) {\r\n    var i, j, xdL, ydL,\r\n      x = this;\r\n\r\n    y = new x.constructor(y);\r\n\r\n    // Signs differ?\r\n    if (x.s !== y.s) return x.s || -y.s;\r\n\r\n    // Compare exponents.\r\n    if (x.e !== y.e) return x.e > y.e ^ x.s < 0 ? 1 : -1;\r\n\r\n    xdL = x.d.length;\r\n    ydL = y.d.length;\r\n\r\n    // Compare digit by digit.\r\n    for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {\r\n      if (x.d[i] !== y.d[i]) return x.d[i] > y.d[i] ^ x.s < 0 ? 1 : -1;\r\n    }\r\n\r\n    // Compare lengths.\r\n    return xdL === ydL ? 0 : xdL > ydL ^ x.s < 0 ? 1 : -1;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the number of decimal places of the value of this Decimal.\r\n   *\r\n   */\r\n  P.decimalPlaces = P.dp = function () {\r\n    var x = this,\r\n      w = x.d.length - 1,\r\n      dp = (w - x.e) * LOG_BASE;\r\n\r\n    // Subtract the number of trailing zeros of the last word.\r\n    w = x.d[w];\r\n    if (w) for (; w % 10 == 0; w /= 10) dp--;\r\n\r\n    return dp < 0 ? 0 : dp;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal divided by `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.dividedBy = P.div = function (y) {\r\n    return divide(this, new this.constructor(y));\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the integer part of dividing the value of this Decimal\r\n   * by the value of `y`, truncated to `precision` significant digits.\r\n   *\r\n   */\r\n  P.dividedToIntegerBy = P.idiv = function (y) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n    return round(divide(x, new Ctor(y), 0, 1), Ctor.precision);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.equals = P.eq = function (y) {\r\n    return !this.cmp(y);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the (base 10) exponent value of this Decimal (this.e is the base 10000000 exponent).\r\n   *\r\n   */\r\n  P.exponent = function () {\r\n    return getBase10Exponent(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is greater than the value of `y`, otherwise return\r\n   * false.\r\n   *\r\n   */\r\n  P.greaterThan = P.gt = function (y) {\r\n    return this.cmp(y) > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is greater than or equal to the value of `y`,\r\n   * otherwise return false.\r\n   *\r\n   */\r\n  P.greaterThanOrEqualTo = P.gte = function (y) {\r\n    return this.cmp(y) >= 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is an integer, otherwise return false.\r\n   *\r\n   */\r\n  P.isInteger = P.isint = function () {\r\n    return this.e > this.d.length - 2;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is negative, otherwise return false.\r\n   *\r\n   */\r\n  P.isNegative = P.isneg = function () {\r\n    return this.s < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is positive, otherwise return false.\r\n   *\r\n   */\r\n  P.isPositive = P.ispos = function () {\r\n    return this.s > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is 0, otherwise return false.\r\n   *\r\n   */\r\n  P.isZero = function () {\r\n    return this.s === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is less than `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.lessThan = P.lt = function (y) {\r\n    return this.cmp(y) < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.\r\n   *\r\n   */\r\n  P.lessThanOrEqualTo = P.lte = function (y) {\r\n    return this.cmp(y) < 1;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the logarithm of the value of this Decimal to the specified base, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   * If no base is specified, return log[10](x).\r\n   *\r\n   * log[base](x) = ln(x) / ln(base)\r\n   *\r\n   * The maximum error of the result is 1 ulp (unit in the last place).\r\n   *\r\n   * [base] {number|string|Decimal} The base of the logarithm.\r\n   *\r\n   */\r\n  P.logarithm = P.log = function (base) {\r\n    var r,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision,\r\n      wpr = pr + 5;\r\n\r\n    // Default base is 10.\r\n    if (base === void 0) {\r\n      base = new Ctor(10);\r\n    } else {\r\n      base = new Ctor(base);\r\n\r\n      // log[-b](x) = NaN\r\n      // log[0](x)  = NaN\r\n      // log[1](x)  = NaN\r\n      if (base.s < 1 || base.eq(ONE)) throw Error(decimalError + 'NaN');\r\n    }\r\n\r\n    // log[b](-x) = NaN\r\n    // log[b](0) = -Infinity\r\n    if (x.s < 1) throw Error(decimalError + (x.s ? 'NaN' : '-Infinity'));\r\n\r\n    // log[b](1) = 0\r\n    if (x.eq(ONE)) return new Ctor(0);\r\n\r\n    external = false;\r\n    r = divide(ln(x, wpr), ln(base, wpr), wpr);\r\n    external = true;\r\n\r\n    return round(r, pr);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal minus `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.minus = P.sub = function (y) {\r\n    var x = this;\r\n    y = new x.constructor(y);\r\n    return x.s == y.s ? subtract(x, y) : add(x, (y.s = -y.s, y));\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal modulo `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.modulo = P.mod = function (y) {\r\n    var q,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    y = new Ctor(y);\r\n\r\n    // x % 0 = NaN\r\n    if (!y.s) throw Error(decimalError + 'NaN');\r\n\r\n    // Return x if x is 0.\r\n    if (!x.s) return round(new Ctor(x), pr);\r\n\r\n    // Prevent rounding of intermediate calculations.\r\n    external = false;\r\n    q = divide(x, y, 0, 1).times(y);\r\n    external = true;\r\n\r\n    return x.minus(q);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of the value of this Decimal,\r\n   * i.e. the base e raised to the power the value of this Decimal, truncated to `precision`\r\n   * significant digits.\r\n   *\r\n   */\r\n  P.naturalExponential = P.exp = function () {\r\n    return exp(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,\r\n   * truncated to `precision` significant digits.\r\n   *\r\n   */\r\n  P.naturalLogarithm = P.ln = function () {\r\n    return ln(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by\r\n   * -1.\r\n   *\r\n   */\r\n  P.negated = P.neg = function () {\r\n    var x = new this.constructor(this);\r\n    x.s = -x.s || 0;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal plus `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.plus = P.add = function (y) {\r\n    var x = this;\r\n    y = new x.constructor(y);\r\n    return x.s == y.s ? add(x, y) : subtract(x, (y.s = -y.s, y));\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the number of significant digits of the value of this Decimal.\r\n   *\r\n   * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.\r\n   *\r\n   */\r\n  P.precision = P.sd = function (z) {\r\n    var e, sd, w,\r\n      x = this;\r\n\r\n    if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);\r\n\r\n    e = getBase10Exponent(x) + 1;\r\n    w = x.d.length - 1;\r\n    sd = w * LOG_BASE + 1;\r\n    w = x.d[w];\r\n\r\n    // If non-zero...\r\n    if (w) {\r\n\r\n      // Subtract the number of trailing zeros of the last word.\r\n      for (; w % 10 == 0; w /= 10) sd--;\r\n\r\n      // Add the number of digits of the first word.\r\n      for (w = x.d[0]; w >= 10; w /= 10) sd++;\r\n    }\r\n\r\n    return z && e > sd ? e : sd;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of this Decimal, truncated to `precision`\r\n   * significant digits.\r\n   *\r\n   */\r\n  P.squareRoot = P.sqrt = function () {\r\n    var e, n, pr, r, s, t, wpr,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    // Negative or zero?\r\n    if (x.s < 1) {\r\n      if (!x.s) return new Ctor(0);\r\n\r\n      // sqrt(-x) = NaN\r\n      throw Error(decimalError + 'NaN');\r\n    }\r\n\r\n    e = getBase10Exponent(x);\r\n    external = false;\r\n\r\n    // Initial estimate.\r\n    s = Math.sqrt(+x);\r\n\r\n    // Math.sqrt underflow/overflow?\r\n    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n    if (s == 0 || s == 1 / 0) {\r\n      n = digitsToString(x.d);\r\n      if ((n.length + e) % 2 == 0) n += '0';\r\n      s = Math.sqrt(n);\r\n      e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n      if (s == 1 / 0) {\r\n        n = '5e' + e;\r\n      } else {\r\n        n = s.toExponential();\r\n        n = n.slice(0, n.indexOf('e') + 1) + e;\r\n      }\r\n\r\n      r = new Ctor(n);\r\n    } else {\r\n      r = new Ctor(s.toString());\r\n    }\r\n\r\n    pr = Ctor.precision;\r\n    s = wpr = pr + 3;\r\n\r\n    // Newton-Raphson iteration.\r\n    for (;;) {\r\n      t = r;\r\n      r = t.plus(divide(x, t, wpr + 2)).times(0.5);\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === (n = digitsToString(r.d)).slice(0, wpr)) {\r\n        n = n.slice(wpr - 3, wpr + 1);\r\n\r\n        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or\r\n        // 4999, i.e. approaching a rounding boundary, continue the iteration.\r\n        if (s == wpr && n == '4999') {\r\n\r\n          // On the first iteration only, check to see if rounding up gives the exact result as the\r\n          // nines may infinitely repeat.\r\n          round(t, pr + 1, 0);\r\n\r\n          if (t.times(t).eq(x)) {\r\n            r = t;\r\n            break;\r\n          }\r\n        } else if (n != '9999') {\r\n          break;\r\n        }\r\n\r\n        wpr += 4;\r\n      }\r\n    }\r\n\r\n    external = true;\r\n\r\n    return round(r, pr);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal times `y`, truncated to\r\n   * `precision` significant digits.\r\n   *\r\n   */\r\n  P.times = P.mul = function (y) {\r\n    var carry, e, i, k, r, rL, t, xdL, ydL,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      xd = x.d,\r\n      yd = (y = new Ctor(y)).d;\r\n\r\n    // Return 0 if either is 0.\r\n    if (!x.s || !y.s) return new Ctor(0);\r\n\r\n    y.s *= x.s;\r\n    e = x.e + y.e;\r\n    xdL = xd.length;\r\n    ydL = yd.length;\r\n\r\n    // Ensure xd points to the longer array.\r\n    if (xdL < ydL) {\r\n      r = xd;\r\n      xd = yd;\r\n      yd = r;\r\n      rL = xdL;\r\n      xdL = ydL;\r\n      ydL = rL;\r\n    }\r\n\r\n    // Initialise the result array with zeros.\r\n    r = [];\r\n    rL = xdL + ydL;\r\n    for (i = rL; i--;) r.push(0);\r\n\r\n    // Multiply!\r\n    for (i = ydL; --i >= 0;) {\r\n      carry = 0;\r\n      for (k = xdL + i; k > i;) {\r\n        t = r[k] + yd[i] * xd[k - i - 1] + carry;\r\n        r[k--] = t % BASE | 0;\r\n        carry = t / BASE | 0;\r\n      }\r\n\r\n      r[k] = (r[k] + carry) % BASE | 0;\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (; !r[--rL];) r.pop();\r\n\r\n    if (carry) ++e;\r\n    else r.shift();\r\n\r\n    y.d = r;\r\n    y.e = e;\r\n\r\n    return external ? round(y, Ctor.precision) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`\r\n   * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.\r\n   *\r\n   * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toDecimalPlaces = P.todp = function (dp, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    x = new Ctor(x);\r\n    if (dp === void 0) return x;\r\n\r\n    checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    return round(x, dp + getBase10Exponent(x) + 1, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in exponential notation rounded to\r\n   * `dp` fixed decimal places using rounding mode `rounding`.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toExponential = function (dp, rm) {\r\n    var str,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (dp === void 0) {\r\n      str = toString(x, true);\r\n    } else {\r\n      checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n\r\n      x = round(new Ctor(x), dp + 1, rm);\r\n      str = toString(x, true, dp + 1);\r\n    }\r\n\r\n    return str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in normal (fixed-point) notation to\r\n   * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is\r\n   * omitted.\r\n   *\r\n   * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\r\n   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\r\n   * (-0).toFixed(3) is '0.000'.\r\n   * (-0.5).toFixed(0) is '-0'.\r\n   *\r\n   */\r\n  P.toFixed = function (dp, rm) {\r\n    var str, y,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (dp === void 0) return toString(x);\r\n\r\n    checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n    if (rm === void 0) rm = Ctor.rounding;\r\n    else checkInt32(rm, 0, 8);\r\n\r\n    y = round(new Ctor(x), dp + getBase10Exponent(x) + 1, rm);\r\n    str = toString(y.abs(), false, dp + getBase10Exponent(y) + 1);\r\n\r\n    // To determine whether to add the minus sign look at the value before it was rounded,\r\n    // i.e. look at `x` rather than `y`.\r\n    return x.isneg() && !x.isZero() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using\r\n   * rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.toInteger = P.toint = function () {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n    return round(new Ctor(x), getBase10Exponent(x) + 1, Ctor.rounding);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the value of this Decimal converted to a number primitive.\r\n   *\r\n   */\r\n  P.toNumber = function () {\r\n    return +this;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal raised to the power `y`,\r\n   * truncated to `precision` significant digits.\r\n   *\r\n   * For non-integer or very large exponents pow(x, y) is calculated using\r\n   *\r\n   *   x^y = exp(y*ln(x))\r\n   *\r\n   * The maximum error is 1 ulp (unit in last place).\r\n   *\r\n   * y {number|string|Decimal} The power to which to raise this Decimal.\r\n   *\r\n   */\r\n  P.toPower = P.pow = function (y) {\r\n    var e, k, pr, r, sign, yIsInt,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      guard = 12,\r\n      yn = +(y = new Ctor(y));\r\n\r\n    // pow(x, 0) = 1\r\n    if (!y.s) return new Ctor(ONE);\r\n\r\n    x = new Ctor(x);\r\n\r\n    // pow(0, y > 0) = 0\r\n    // pow(0, y < 0) = Infinity\r\n    if (!x.s) {\r\n      if (y.s < 1) throw Error(decimalError + 'Infinity');\r\n      return x;\r\n    }\r\n\r\n    // pow(1, y) = 1\r\n    if (x.eq(ONE)) return x;\r\n\r\n    pr = Ctor.precision;\r\n\r\n    // pow(x, 1) = x\r\n    if (y.eq(ONE)) return round(x, pr);\r\n\r\n    e = y.e;\r\n    k = y.d.length - 1;\r\n    yIsInt = e >= k;\r\n    sign = x.s;\r\n\r\n    if (!yIsInt) {\r\n\r\n      // pow(x < 0, y non-integer) = NaN\r\n      if (sign < 0) throw Error(decimalError + 'NaN');\r\n\r\n    // If y is a small integer use the 'exponentiation by squaring' algorithm.\r\n    } else if ((k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {\r\n      r = new Ctor(ONE);\r\n\r\n      // Max k of 9007199254740991 takes 53 loop iterations.\r\n      // Maximum digits array length; leaves [28, 34] guard digits.\r\n      e = Math.ceil(pr / LOG_BASE + 4);\r\n\r\n      external = false;\r\n\r\n      for (;;) {\r\n        if (k % 2) {\r\n          r = r.times(x);\r\n          truncate(r.d, e);\r\n        }\r\n\r\n        k = mathfloor(k / 2);\r\n        if (k === 0) break;\r\n\r\n        x = x.times(x);\r\n        truncate(x.d, e);\r\n      }\r\n\r\n      external = true;\r\n\r\n      return y.s < 0 ? new Ctor(ONE).div(r) : round(r, pr);\r\n    }\r\n\r\n    // Result is negative if x is negative and the last digit of integer y is odd.\r\n    sign = sign < 0 && y.d[Math.max(e, k)] & 1 ? -1 : 1;\r\n\r\n    x.s = 1;\r\n    external = false;\r\n    r = y.times(ln(x, pr + guard));\r\n    external = true;\r\n    r = exp(r);\r\n    r.s = sign;\r\n\r\n    return r;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal rounded to `sd` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * Return exponential notation if `sd` is less than the number of digits necessary to represent\r\n   * the integer part of the value in normal notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toPrecision = function (sd, rm) {\r\n    var e, str,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (sd === void 0) {\r\n      e = getBase10Exponent(x);\r\n      str = toString(x, e <= Ctor.toExpNeg || e >= Ctor.toExpPos);\r\n    } else {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n\r\n      x = round(new Ctor(x), sd, rm);\r\n      e = getBase10Exponent(x);\r\n      str = toString(x, sd <= e || e <= Ctor.toExpNeg, sd);\r\n    }\r\n\r\n    return str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`\r\n   * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if\r\n   * omitted.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   */\r\n  P.toSignificantDigits = P.tosd = function (sd, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (sd === void 0) {\r\n      sd = Ctor.precision;\r\n      rm = Ctor.rounding;\r\n    } else {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n    }\r\n\r\n    return round(new Ctor(x), sd, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal.\r\n   *\r\n   * Return exponential notation if this Decimal has a positive exponent equal to or greater than\r\n   * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.\r\n   *\r\n   */\r\n  P.toString = P.valueOf = P.val = P.toJSON = function () {\r\n    var x = this,\r\n      e = getBase10Exponent(x),\r\n      Ctor = x.constructor;\r\n\r\n    return toString(x, e <= Ctor.toExpNeg || e >= Ctor.toExpPos);\r\n  };\r\n\r\n\r\n  // Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.\r\n\r\n\r\n  /*\r\n   *  add                 P.minus, P.plus\r\n   *  checkInt32          P.todp, P.toExponential, P.toFixed, P.toPrecision, P.tosd\r\n   *  digitsToString      P.log, P.sqrt, P.pow, toString, exp, ln\r\n   *  divide              P.div, P.idiv, P.log, P.mod, P.sqrt, exp, ln\r\n   *  exp                 P.exp, P.pow\r\n   *  getBase10Exponent   P.exponent, P.sd, P.toint, P.sqrt, P.todp, P.toFixed, P.toPrecision,\r\n   *                      P.toString, divide, round, toString, exp, ln\r\n   *  getLn10             P.log, ln\r\n   *  getZeroString       digitsToString, toString\r\n   *  ln                  P.log, P.ln, P.pow, exp\r\n   *  parseDecimal        Decimal\r\n   *  round               P.abs, P.idiv, P.log, P.minus, P.mod, P.neg, P.plus, P.toint, P.sqrt,\r\n   *                      P.times, P.todp, P.toExponential, P.toFixed, P.pow, P.toPrecision, P.tosd,\r\n   *                      divide, getLn10, exp, ln\r\n   *  subtract            P.minus, P.plus\r\n   *  toString            P.toExponential, P.toFixed, P.toPrecision, P.toString, P.valueOf\r\n   *  truncate            P.pow\r\n   *\r\n   *  Throws:             P.log, P.mod, P.sd, P.sqrt, P.pow,  checkInt32, divide, round,\r\n   *                      getLn10, exp, ln, parseDecimal, Decimal, config\r\n   */\r\n\r\n\r\n  function add(x, y) {\r\n    var carry, d, e, i, k, len, xd, yd,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    // If either is zero...\r\n    if (!x.s || !y.s) {\r\n\r\n      // Return x if y is zero.\r\n      // Return y if y is non-zero.\r\n      if (!y.s) y = new Ctor(x);\r\n      return external ? round(y, pr) : y;\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n\r\n    // x and y are finite, non-zero numbers with the same sign.\r\n\r\n    k = x.e;\r\n    e = y.e;\r\n    xd = xd.slice();\r\n    i = k - e;\r\n\r\n    // If base 1e7 exponents differ...\r\n    if (i) {\r\n      if (i < 0) {\r\n        d = xd;\r\n        i = -i;\r\n        len = yd.length;\r\n      } else {\r\n        d = yd;\r\n        e = k;\r\n        len = xd.length;\r\n      }\r\n\r\n      // Limit number of zeros prepended to max(ceil(pr / LOG_BASE), len) + 1.\r\n      k = Math.ceil(pr / LOG_BASE);\r\n      len = k > len ? k + 1 : len + 1;\r\n\r\n      if (i > len) {\r\n        i = len;\r\n        d.length = 1;\r\n      }\r\n\r\n      // Prepend zeros to equalise exponents. Note: Faster to use reverse then do unshifts.\r\n      d.reverse();\r\n      for (; i--;) d.push(0);\r\n      d.reverse();\r\n    }\r\n\r\n    len = xd.length;\r\n    i = yd.length;\r\n\r\n    // If yd is longer than xd, swap xd and yd so xd points to the longer array.\r\n    if (len - i < 0) {\r\n      i = len;\r\n      d = yd;\r\n      yd = xd;\r\n      xd = d;\r\n    }\r\n\r\n    // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.\r\n    for (carry = 0; i;) {\r\n      carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;\r\n      xd[i] %= BASE;\r\n    }\r\n\r\n    if (carry) {\r\n      xd.unshift(carry);\r\n      ++e;\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n    for (len = xd.length; xd[--len] == 0;) xd.pop();\r\n\r\n    y.d = xd;\r\n    y.e = e;\r\n\r\n    return external ? round(y, pr) : y;\r\n  }\r\n\r\n\r\n  function checkInt32(i, min, max) {\r\n    if (i !== ~~i || i < min || i > max) {\r\n      throw Error(invalidArgument + i);\r\n    }\r\n  }\r\n\r\n\r\n  function digitsToString(d) {\r\n    var i, k, ws,\r\n      indexOfLastWord = d.length - 1,\r\n      str = '',\r\n      w = d[0];\r\n\r\n    if (indexOfLastWord > 0) {\r\n      str += w;\r\n      for (i = 1; i < indexOfLastWord; i++) {\r\n        ws = d[i] + '';\r\n        k = LOG_BASE - ws.length;\r\n        if (k) str += getZeroString(k);\r\n        str += ws;\r\n      }\r\n\r\n      w = d[i];\r\n      ws = w + '';\r\n      k = LOG_BASE - ws.length;\r\n      if (k) str += getZeroString(k);\r\n    } else if (w === 0) {\r\n      return '0';\r\n    }\r\n\r\n    // Remove trailing zeros of last w.\r\n    for (; w % 10 === 0;) w /= 10;\r\n\r\n    return str + w;\r\n  }\r\n\r\n\r\n  var divide = (function () {\r\n\r\n    // Assumes non-zero x and k, and hence non-zero result.\r\n    function multiplyInteger(x, k) {\r\n      var temp,\r\n        carry = 0,\r\n        i = x.length;\r\n\r\n      for (x = x.slice(); i--;) {\r\n        temp = x[i] * k + carry;\r\n        x[i] = temp % BASE | 0;\r\n        carry = temp / BASE | 0;\r\n      }\r\n\r\n      if (carry) x.unshift(carry);\r\n\r\n      return x;\r\n    }\r\n\r\n    function compare(a, b, aL, bL) {\r\n      var i, r;\r\n\r\n      if (aL != bL) {\r\n        r = aL > bL ? 1 : -1;\r\n      } else {\r\n        for (i = r = 0; i < aL; i++) {\r\n          if (a[i] != b[i]) {\r\n            r = a[i] > b[i] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      return r;\r\n    }\r\n\r\n    function subtract(a, b, aL) {\r\n      var i = 0;\r\n\r\n      // Subtract b from a.\r\n      for (; aL--;) {\r\n        a[aL] -= i;\r\n        i = a[aL] < b[aL] ? 1 : 0;\r\n        a[aL] = i * BASE + a[aL] - b[aL];\r\n      }\r\n\r\n      // Remove leading zeros.\r\n      for (; !a[0] && a.length > 1;) a.shift();\r\n    }\r\n\r\n    return function (x, y, pr, dp) {\r\n      var cmp, e, i, k, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0, yL, yz,\r\n        Ctor = x.constructor,\r\n        sign = x.s == y.s ? 1 : -1,\r\n        xd = x.d,\r\n        yd = y.d;\r\n\r\n      // Either 0?\r\n      if (!x.s) return new Ctor(x);\r\n      if (!y.s) throw Error(decimalError + 'Division by zero');\r\n\r\n      e = x.e - y.e;\r\n      yL = yd.length;\r\n      xL = xd.length;\r\n      q = new Ctor(sign);\r\n      qd = q.d = [];\r\n\r\n      // Result exponent may be one less than e.\r\n      for (i = 0; yd[i] == (xd[i] || 0); ) ++i;\r\n      if (yd[i] > (xd[i] || 0)) --e;\r\n\r\n      if (pr == null) {\r\n        sd = pr = Ctor.precision;\r\n      } else if (dp) {\r\n        sd = pr + (getBase10Exponent(x) - getBase10Exponent(y)) + 1;\r\n      } else {\r\n        sd = pr;\r\n      }\r\n\r\n      if (sd < 0) return new Ctor(0);\r\n\r\n      // Convert precision in number of base 10 digits to base 1e7 digits.\r\n      sd = sd / LOG_BASE + 2 | 0;\r\n      i = 0;\r\n\r\n      // divisor < 1e7\r\n      if (yL == 1) {\r\n        k = 0;\r\n        yd = yd[0];\r\n        sd++;\r\n\r\n        // k is the carry.\r\n        for (; (i < xL || k) && sd--; i++) {\r\n          t = k * BASE + (xd[i] || 0);\r\n          qd[i] = t / yd | 0;\r\n          k = t % yd | 0;\r\n        }\r\n\r\n      // divisor >= 1e7\r\n      } else {\r\n\r\n        // Normalise xd and yd so highest order digit of yd is >= BASE/2\r\n        k = BASE / (yd[0] + 1) | 0;\r\n\r\n        if (k > 1) {\r\n          yd = multiplyInteger(yd, k);\r\n          xd = multiplyInteger(xd, k);\r\n          yL = yd.length;\r\n          xL = xd.length;\r\n        }\r\n\r\n        xi = yL;\r\n        rem = xd.slice(0, yL);\r\n        remL = rem.length;\r\n\r\n        // Add zeros to make remainder as long as divisor.\r\n        for (; remL < yL;) rem[remL++] = 0;\r\n\r\n        yz = yd.slice();\r\n        yz.unshift(0);\r\n        yd0 = yd[0];\r\n\r\n        if (yd[1] >= BASE / 2) ++yd0;\r\n\r\n        do {\r\n          k = 0;\r\n\r\n          // Compare divisor and remainder.\r\n          cmp = compare(yd, rem, yL, remL);\r\n\r\n          // If divisor < remainder.\r\n          if (cmp < 0) {\r\n\r\n            // Calculate trial digit, k.\r\n            rem0 = rem[0];\r\n            if (yL != remL) rem0 = rem0 * BASE + (rem[1] || 0);\r\n\r\n            // k will be how many times the divisor goes into the current remainder.\r\n            k = rem0 / yd0 | 0;\r\n\r\n            //  Algorithm:\r\n            //  1. product = divisor * trial digit (k)\r\n            //  2. if product > remainder: product -= divisor, k--\r\n            //  3. remainder -= product\r\n            //  4. if product was < remainder at 2:\r\n            //    5. compare new remainder and divisor\r\n            //    6. If remainder > divisor: remainder -= divisor, k++\r\n\r\n            if (k > 1) {\r\n              if (k >= BASE) k = BASE - 1;\r\n\r\n              // product = divisor * trial digit.\r\n              prod = multiplyInteger(yd, k);\r\n              prodL = prod.length;\r\n              remL = rem.length;\r\n\r\n              // Compare product and remainder.\r\n              cmp = compare(prod, rem, prodL, remL);\r\n\r\n              // product > remainder.\r\n              if (cmp == 1) {\r\n                k--;\r\n\r\n                // Subtract divisor from product.\r\n                subtract(prod, yL < prodL ? yz : yd, prodL);\r\n              }\r\n            } else {\r\n\r\n              // cmp is -1.\r\n              // If k is 0, there is no need to compare yd and rem again below, so change cmp to 1\r\n              // to avoid it. If k is 1 there is a need to compare yd and rem again below.\r\n              if (k == 0) cmp = k = 1;\r\n              prod = yd.slice();\r\n            }\r\n\r\n            prodL = prod.length;\r\n            if (prodL < remL) prod.unshift(0);\r\n\r\n            // Subtract product from remainder.\r\n            subtract(rem, prod, remL);\r\n\r\n            // If product was < previous remainder.\r\n            if (cmp == -1) {\r\n              remL = rem.length;\r\n\r\n              // Compare divisor and new remainder.\r\n              cmp = compare(yd, rem, yL, remL);\r\n\r\n              // If divisor < new remainder, subtract divisor from remainder.\r\n              if (cmp < 1) {\r\n                k++;\r\n\r\n                // Subtract divisor from remainder.\r\n                subtract(rem, yL < remL ? yz : yd, remL);\r\n              }\r\n            }\r\n\r\n            remL = rem.length;\r\n          } else if (cmp === 0) {\r\n            k++;\r\n            rem = [0];\r\n          }    // if cmp === 1, k will be 0\r\n\r\n          // Add the next digit, k, to the result array.\r\n          qd[i++] = k;\r\n\r\n          // Update the remainder.\r\n          if (cmp && rem[0]) {\r\n            rem[remL++] = xd[xi] || 0;\r\n          } else {\r\n            rem = [xd[xi]];\r\n            remL = 1;\r\n          }\r\n\r\n        } while ((xi++ < xL || rem[0] !== void 0) && sd--);\r\n      }\r\n\r\n      // Leading zero?\r\n      if (!qd[0]) qd.shift();\r\n\r\n      q.e = e;\r\n\r\n      return round(q, dp ? pr + getBase10Exponent(q) + 1 : pr);\r\n    };\r\n  })();\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of `x` truncated to `sd`\r\n   * significant digits.\r\n   *\r\n   * Taylor/Maclaurin series.\r\n   *\r\n   * exp(x) = x^0/0! + x^1/1! + x^2/2! + x^3/3! + ...\r\n   *\r\n   * Argument reduction:\r\n   *   Repeat x = x / 32, k += 5, until |x| < 0.1\r\n   *   exp(x) = exp(x / 2^k)^(2^k)\r\n   *\r\n   * Previously, the argument was initially reduced by\r\n   * exp(x) = exp(r) * 10^k  where r = x - k * ln10, k = floor(x / ln10)\r\n   * to first put r in the range [0, ln10], before dividing by 32 until |x| < 0.1, but this was\r\n   * found to be slower than just dividing repeatedly by 32 as above.\r\n   *\r\n   * (Math object integer min/max: Math.exp(709) = 8.2e+307, Math.exp(-745) = 5e-324)\r\n   *\r\n   *  exp(x) is non-terminating for any finite, non-zero x.\r\n   *\r\n   */\r\n  function exp(x, sd) {\r\n    var denominator, guard, pow, sum, t, wpr,\r\n      i = 0,\r\n      k = 0,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    if (getBase10Exponent(x) > 16) throw Error(exponentOutOfRange + getBase10Exponent(x));\r\n\r\n    // exp(0) = 1\r\n    if (!x.s) return new Ctor(ONE);\r\n\r\n    if (sd == null) {\r\n      external = false;\r\n      wpr = pr;\r\n    } else {\r\n      wpr = sd;\r\n    }\r\n\r\n    t = new Ctor(0.03125);\r\n\r\n    while (x.abs().gte(0.1)) {\r\n      x = x.times(t);    // x = x / 2^5\r\n      k += 5;\r\n    }\r\n\r\n    // Estimate the precision increase necessary to ensure the first 4 rounding digits are correct.\r\n    guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;\r\n    wpr += guard;\r\n    denominator = pow = sum = new Ctor(ONE);\r\n    Ctor.precision = wpr;\r\n\r\n    for (;;) {\r\n      pow = round(pow.times(x), wpr);\r\n      denominator = denominator.times(++i);\r\n      t = sum.plus(divide(pow, denominator, wpr));\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n        while (k--) sum = round(sum.times(sum), wpr);\r\n        Ctor.precision = pr;\r\n        return sd == null ? (external = true, round(sum, pr)) : sum;\r\n      }\r\n\r\n      sum = t;\r\n    }\r\n  }\r\n\r\n\r\n  // Calculate the base 10 exponent from the base 1e7 exponent.\r\n  function getBase10Exponent(x) {\r\n    var e = x.e * LOG_BASE,\r\n      w = x.d[0];\r\n\r\n    // Add the number of digits of the first word of the digits array.\r\n    for (; w >= 10; w /= 10) e++;\r\n    return e;\r\n  }\r\n\r\n\r\n  function getLn10(Ctor, sd, pr) {\r\n\r\n    if (sd > Ctor.LN10.sd()) {\r\n\r\n\r\n      // Reset global state in case the exception is caught.\r\n      external = true;\r\n      if (pr) Ctor.precision = pr;\r\n      throw Error(decimalError + 'LN10 precision limit exceeded');\r\n    }\r\n\r\n    return round(new Ctor(Ctor.LN10), sd);\r\n  }\r\n\r\n\r\n  function getZeroString(k) {\r\n    var zs = '';\r\n    for (; k--;) zs += '0';\r\n    return zs;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of `x` truncated to `sd` significant\r\n   * digits.\r\n   *\r\n   *  ln(n) is non-terminating (n != 1)\r\n   *\r\n   */\r\n  function ln(y, sd) {\r\n    var c, c0, denominator, e, numerator, sum, t, wpr, x2,\r\n      n = 1,\r\n      guard = 10,\r\n      x = y,\r\n      xd = x.d,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    // ln(-x) = NaN\r\n    // ln(0) = -Infinity\r\n    if (x.s < 1) throw Error(decimalError + (x.s ? 'NaN' : '-Infinity'));\r\n\r\n    // ln(1) = 0\r\n    if (x.eq(ONE)) return new Ctor(0);\r\n\r\n    if (sd == null) {\r\n      external = false;\r\n      wpr = pr;\r\n    } else {\r\n      wpr = sd;\r\n    }\r\n\r\n    if (x.eq(10)) {\r\n      if (sd == null) external = true;\r\n      return getLn10(Ctor, wpr);\r\n    }\r\n\r\n    wpr += guard;\r\n    Ctor.precision = wpr;\r\n    c = digitsToString(xd);\r\n    c0 = c.charAt(0);\r\n    e = getBase10Exponent(x);\r\n\r\n    if (Math.abs(e) < 1.5e15) {\r\n\r\n      // Argument reduction.\r\n      // The series converges faster the closer the argument is to 1, so using\r\n      // ln(a^b) = b * ln(a),   ln(a) = ln(a^b) / b\r\n      // multiply the argument by itself until the leading digits of the significand are 7, 8, 9,\r\n      // 10, 11, 12 or 13, recording the number of multiplications so the sum of the series can\r\n      // later be divided by this number, then separate out the power of 10 using\r\n      // ln(a*10^b) = ln(a) + b*ln(10).\r\n\r\n      // max n is 21 (gives 0.9, 1.0 or 1.1) (9e15 / 21 = 4.2e14).\r\n      //while (c0 < 9 && c0 != 1 || c0 == 1 && c.charAt(1) > 1) {\r\n      // max n is 6 (gives 0.7 - 1.3)\r\n      while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {\r\n        x = x.times(y);\r\n        c = digitsToString(x.d);\r\n        c0 = c.charAt(0);\r\n        n++;\r\n      }\r\n\r\n      e = getBase10Exponent(x);\r\n\r\n      if (c0 > 1) {\r\n        x = new Ctor('0.' + c);\r\n        e++;\r\n      } else {\r\n        x = new Ctor(c0 + '.' + c.slice(1));\r\n      }\r\n    } else {\r\n\r\n      // The argument reduction method above may result in overflow if the argument y is a massive\r\n      // number with exponent >= 1500000000000000 (9e15 / 6 = 1.5e15), so instead recall this\r\n      // function using ln(x*10^e) = ln(x) + e*ln(10).\r\n      t = getLn10(Ctor, wpr + 2, pr).times(e + '');\r\n      x = ln(new Ctor(c0 + '.' + c.slice(1)), wpr - guard).plus(t);\r\n\r\n      Ctor.precision = pr;\r\n      return sd == null ? (external = true, round(x, pr)) : x;\r\n    }\r\n\r\n    // x is reduced to a value near 1.\r\n\r\n    // Taylor series.\r\n    // ln(y) = ln((1 + x)/(1 - x)) = 2(x + x^3/3 + x^5/5 + x^7/7 + ...)\r\n    // where x = (y - 1)/(y + 1)    (|x| < 1)\r\n    sum = numerator = x = divide(x.minus(ONE), x.plus(ONE), wpr);\r\n    x2 = round(x.times(x), wpr);\r\n    denominator = 3;\r\n\r\n    for (;;) {\r\n      numerator = round(numerator.times(x2), wpr);\r\n      t = sum.plus(divide(numerator, new Ctor(denominator), wpr));\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n        sum = sum.times(2);\r\n\r\n        // Reverse the argument reduction.\r\n        if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ''));\r\n        sum = divide(sum, new Ctor(n), wpr);\r\n\r\n        Ctor.precision = pr;\r\n        return sd == null ? (external = true, round(sum, pr)) : sum;\r\n      }\r\n\r\n      sum = t;\r\n      denominator += 2;\r\n    }\r\n  }\r\n\r\n\r\n  /*\r\n   * Parse the value of a new Decimal `x` from string `str`.\r\n   */\r\n  function parseDecimal(x, str) {\r\n    var e, i, len;\r\n\r\n    // Decimal point?\r\n    if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n    // Exponential form?\r\n    if ((i = str.search(/e/i)) > 0) {\r\n\r\n      // Determine exponent.\r\n      if (e < 0) e = i;\r\n      e += +str.slice(i + 1);\r\n      str = str.substring(0, i);\r\n    } else if (e < 0) {\r\n\r\n      // Integer.\r\n      e = str.length;\r\n    }\r\n\r\n    // Determine leading zeros.\r\n    for (i = 0; str.charCodeAt(i) === 48;) ++i;\r\n\r\n    // Determine trailing zeros.\r\n    for (len = str.length; str.charCodeAt(len - 1) === 48;) --len;\r\n    str = str.slice(i, len);\r\n\r\n    if (str) {\r\n      len -= i;\r\n      e = e - i - 1;\r\n      x.e = mathfloor(e / LOG_BASE);\r\n      x.d = [];\r\n\r\n      // Transform base\r\n\r\n      // e is the base 10 exponent.\r\n      // i is where to slice str to get the first word of the digits array.\r\n      i = (e + 1) % LOG_BASE;\r\n      if (e < 0) i += LOG_BASE;\r\n\r\n      if (i < len) {\r\n        if (i) x.d.push(+str.slice(0, i));\r\n        for (len -= LOG_BASE; i < len;) x.d.push(+str.slice(i, i += LOG_BASE));\r\n        str = str.slice(i);\r\n        i = LOG_BASE - str.length;\r\n      } else {\r\n        i -= len;\r\n      }\r\n\r\n      for (; i--;) str += '0';\r\n      x.d.push(+str);\r\n\r\n      if (external && (x.e > MAX_E || x.e < -MAX_E)) throw Error(exponentOutOfRange + e);\r\n    } else {\r\n\r\n      // Zero.\r\n      x.s = 0;\r\n      x.e = 0;\r\n      x.d = [0];\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Round `x` to `sd` significant digits, using rounding mode `rm` if present (truncate otherwise).\r\n   */\r\n   function round(x, sd, rm) {\r\n    var i, j, k, n, rd, doRound, w, xdi,\r\n      xd = x.d;\r\n\r\n    // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n    // w: the word of xd which contains the rounding digit, a base 1e7 number.\r\n    // xdi: the index of w within xd.\r\n    // n: the number of digits of w.\r\n    // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if\r\n    // they had leading zeros)\r\n    // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).\r\n\r\n    // Get the length of the first word of the digits array xd.\r\n    for (n = 1, k = xd[0]; k >= 10; k /= 10) n++;\r\n    i = sd - n;\r\n\r\n    // Is the rounding digit in the first word of xd?\r\n    if (i < 0) {\r\n      i += LOG_BASE;\r\n      j = sd;\r\n      w = xd[xdi = 0];\r\n    } else {\r\n      xdi = Math.ceil((i + 1) / LOG_BASE);\r\n      k = xd.length;\r\n      if (xdi >= k) return x;\r\n      w = k = xd[xdi];\r\n\r\n      // Get the number of digits of w.\r\n      for (n = 1; k >= 10; k /= 10) n++;\r\n\r\n      // Get the index of rd within w.\r\n      i %= LOG_BASE;\r\n\r\n      // Get the index of rd within w, adjusted for leading zeros.\r\n      // The number of leading zeros of w is given by LOG_BASE - n.\r\n      j = i - LOG_BASE + n;\r\n    }\r\n\r\n    if (rm !== void 0) {\r\n      k = mathpow(10, n - j - 1);\r\n\r\n      // Get the rounding digit at index j of w.\r\n      rd = w / k % 10 | 0;\r\n\r\n      // Are there any non-zero digits after the rounding digit?\r\n      doRound = sd < 0 || xd[xdi + 1] !== void 0 || w % k;\r\n\r\n      // The expression `w % mathpow(10, n - j - 1)` returns all the digits of w to the right of the\r\n      // digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression will give\r\n      // 714.\r\n\r\n      doRound = rm < 4\r\n        ? (rd || doRound) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n        : rd > 5 || rd == 5 && (rm == 4 || doRound || rm == 6 &&\r\n\r\n          // Check whether the digit to the left of the rounding digit is odd.\r\n          ((i > 0 ? j > 0 ? w / mathpow(10, n - j) : 0 : xd[xdi - 1]) % 10) & 1 ||\r\n            rm == (x.s < 0 ? 8 : 7));\r\n    }\r\n\r\n    if (sd < 1 || !xd[0]) {\r\n      if (doRound) {\r\n        k = getBase10Exponent(x);\r\n        xd.length = 1;\r\n\r\n        // Convert sd to decimal places.\r\n        sd = sd - k - 1;\r\n\r\n        // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n        xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);\r\n        x.e = mathfloor(-sd / LOG_BASE) || 0;\r\n      } else {\r\n        xd.length = 1;\r\n\r\n        // Zero.\r\n        xd[0] = x.e = x.s = 0;\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n    // Remove excess digits.\r\n    if (i == 0) {\r\n      xd.length = xdi;\r\n      k = 1;\r\n      xdi--;\r\n    } else {\r\n      xd.length = xdi + 1;\r\n      k = mathpow(10, LOG_BASE - i);\r\n\r\n      // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n      // j > 0 means i > number of leading zeros of w.\r\n      xd[xdi] = j > 0 ? (w / mathpow(10, n - j) % mathpow(10, j) | 0) * k : 0;\r\n    }\r\n\r\n    if (doRound) {\r\n      for (;;) {\r\n\r\n        // Is the digit to be rounded up in the first word of xd?\r\n        if (xdi == 0) {\r\n          if ((xd[0] += k) == BASE) {\r\n            xd[0] = 1;\r\n            ++x.e;\r\n          }\r\n\r\n          break;\r\n        } else {\r\n          xd[xdi] += k;\r\n          if (xd[xdi] != BASE) break;\r\n          xd[xdi--] = 0;\r\n          k = 1;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (i = xd.length; xd[--i] === 0;) xd.pop();\r\n\r\n    if (external && (x.e > MAX_E || x.e < -MAX_E)) {\r\n      throw Error(exponentOutOfRange + getBase10Exponent(x));\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  function subtract(x, y) {\r\n    var d, e, i, j, k, len, xd, xe, xLTy, yd,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision;\r\n\r\n    // Return y negated if x is zero.\r\n    // Return x if y is zero and x is non-zero.\r\n    if (!x.s || !y.s) {\r\n      if (y.s) y.s = -y.s;\r\n      else y = new Ctor(x);\r\n      return external ? round(y, pr) : y;\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n\r\n    // x and y are non-zero numbers with the same sign.\r\n\r\n    e = y.e;\r\n    xe = x.e;\r\n    xd = xd.slice();\r\n    k = xe - e;\r\n\r\n    // If exponents differ...\r\n    if (k) {\r\n      xLTy = k < 0;\r\n\r\n      if (xLTy) {\r\n        d = xd;\r\n        k = -k;\r\n        len = yd.length;\r\n      } else {\r\n        d = yd;\r\n        e = xe;\r\n        len = xd.length;\r\n      }\r\n\r\n      // Numbers with massively different exponents would result in a very high number of zeros\r\n      // needing to be prepended, but this can be avoided while still ensuring correct rounding by\r\n      // limiting the number of zeros to `Math.ceil(pr / LOG_BASE) + 2`.\r\n      i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;\r\n\r\n      if (k > i) {\r\n        k = i;\r\n        d.length = 1;\r\n      }\r\n\r\n      // Prepend zeros to equalise exponents.\r\n      d.reverse();\r\n      for (i = k; i--;) d.push(0);\r\n      d.reverse();\r\n\r\n    // Base 1e7 exponents equal.\r\n    } else {\r\n\r\n      // Check digits to determine which is the bigger number.\r\n\r\n      i = xd.length;\r\n      len = yd.length;\r\n      xLTy = i < len;\r\n      if (xLTy) len = i;\r\n\r\n      for (i = 0; i < len; i++) {\r\n        if (xd[i] != yd[i]) {\r\n          xLTy = xd[i] < yd[i];\r\n          break;\r\n        }\r\n      }\r\n\r\n      k = 0;\r\n    }\r\n\r\n    if (xLTy) {\r\n      d = xd;\r\n      xd = yd;\r\n      yd = d;\r\n      y.s = -y.s;\r\n    }\r\n\r\n    len = xd.length;\r\n\r\n    // Append zeros to xd if shorter.\r\n    // Don't add zeros to yd if shorter as subtraction only needs to start at yd length.\r\n    for (i = yd.length - len; i > 0; --i) xd[len++] = 0;\r\n\r\n    // Subtract yd from xd.\r\n    for (i = yd.length; i > k;) {\r\n      if (xd[--i] < yd[i]) {\r\n        for (j = i; j && xd[--j] === 0;) xd[j] = BASE - 1;\r\n        --xd[j];\r\n        xd[i] += BASE;\r\n      }\r\n\r\n      xd[i] -= yd[i];\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (; xd[--len] === 0;) xd.pop();\r\n\r\n    // Remove leading zeros and adjust exponent accordingly.\r\n    for (; xd[0] === 0; xd.shift()) --e;\r\n\r\n    // Zero?\r\n    if (!xd[0]) return new Ctor(0);\r\n\r\n    y.d = xd;\r\n    y.e = e;\r\n\r\n    //return external && xd.length >= pr / LOG_BASE ? round(y, pr) : y;\r\n    return external ? round(y, pr) : y;\r\n  }\r\n\r\n\r\n  function toString(x, isExp, sd) {\r\n    var k,\r\n      e = getBase10Exponent(x),\r\n      str = digitsToString(x.d),\r\n      len = str.length;\r\n\r\n    if (isExp) {\r\n      if (sd && (k = sd - len) > 0) {\r\n        str = str.charAt(0) + '.' + str.slice(1) + getZeroString(k);\r\n      } else if (len > 1) {\r\n        str = str.charAt(0) + '.' + str.slice(1);\r\n      }\r\n\r\n      str = str + (e < 0 ? 'e' : 'e+') + e;\r\n    } else if (e < 0) {\r\n      str = '0.' + getZeroString(-e - 1) + str;\r\n      if (sd && (k = sd - len) > 0) str += getZeroString(k);\r\n    } else if (e >= len) {\r\n      str += getZeroString(e + 1 - len);\r\n      if (sd && (k = sd - e - 1) > 0) str = str + '.' + getZeroString(k);\r\n    } else {\r\n      if ((k = e + 1) < len) str = str.slice(0, k) + '.' + str.slice(k);\r\n      if (sd && (k = sd - len) > 0) {\r\n        if (e + 1 === len) str += '.';\r\n        str += getZeroString(k);\r\n      }\r\n    }\r\n\r\n    return x.s < 0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // Does not strip trailing zeros.\r\n  function truncate(arr, len) {\r\n    if (arr.length > len) {\r\n      arr.length = len;\r\n      return true;\r\n    }\r\n  }\r\n\r\n\r\n  // Decimal methods\r\n\r\n\r\n  /*\r\n   *  clone\r\n   *  config/set\r\n   */\r\n\r\n\r\n  /*\r\n   * Create and return a Decimal constructor with the same configuration properties as this Decimal\r\n   * constructor.\r\n   *\r\n   */\r\n  function clone(obj) {\r\n    var i, p, ps;\r\n\r\n    /*\r\n     * The Decimal constructor and exported function.\r\n     * Return a new Decimal instance.\r\n     *\r\n     * value {number|string|Decimal} A numeric value.\r\n     *\r\n     */\r\n    function Decimal(value) {\r\n      var x = this;\r\n\r\n      // Decimal called without new.\r\n      if (!(x instanceof Decimal)) return new Decimal(value);\r\n\r\n      // Retain a reference to this Decimal constructor, and shadow Decimal.prototype.constructor\r\n      // which points to Object.\r\n      x.constructor = Decimal;\r\n\r\n      // Duplicate.\r\n      if (value instanceof Decimal) {\r\n        x.s = value.s;\r\n        x.e = value.e;\r\n        x.d = (value = value.d) ? value.slice() : value;\r\n        return;\r\n      }\r\n\r\n      if (typeof value === 'number') {\r\n\r\n        // Reject Infinity/NaN.\r\n        if (value * 0 !== 0) {\r\n          throw Error(invalidArgument + value);\r\n        }\r\n\r\n        if (value > 0) {\r\n          x.s = 1;\r\n        } else if (value < 0) {\r\n          value = -value;\r\n          x.s = -1;\r\n        } else {\r\n          x.s = 0;\r\n          x.e = 0;\r\n          x.d = [0];\r\n          return;\r\n        }\r\n\r\n        // Fast path for small integers.\r\n        if (value === ~~value && value < 1e7) {\r\n          x.e = 0;\r\n          x.d = [value];\r\n          return;\r\n        }\r\n\r\n        return parseDecimal(x, value.toString());\r\n      } else if (typeof value !== 'string') {\r\n        throw Error(invalidArgument + value);\r\n      }\r\n\r\n      // Minus sign?\r\n      if (value.charCodeAt(0) === 45) {\r\n        value = value.slice(1);\r\n        x.s = -1;\r\n      } else {\r\n        x.s = 1;\r\n      }\r\n\r\n      if (isDecimal.test(value)) parseDecimal(x, value);\r\n      else throw Error(invalidArgument + value);\r\n    }\r\n\r\n    Decimal.prototype = P;\r\n\r\n    Decimal.ROUND_UP = 0;\r\n    Decimal.ROUND_DOWN = 1;\r\n    Decimal.ROUND_CEIL = 2;\r\n    Decimal.ROUND_FLOOR = 3;\r\n    Decimal.ROUND_HALF_UP = 4;\r\n    Decimal.ROUND_HALF_DOWN = 5;\r\n    Decimal.ROUND_HALF_EVEN = 6;\r\n    Decimal.ROUND_HALF_CEIL = 7;\r\n    Decimal.ROUND_HALF_FLOOR = 8;\r\n\r\n    Decimal.clone = clone;\r\n    Decimal.config = Decimal.set = config;\r\n\r\n    if (obj === void 0) obj = {};\r\n    if (obj) {\r\n      ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'LN10'];\r\n      for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];\r\n    }\r\n\r\n    Decimal.config(obj);\r\n\r\n    return Decimal;\r\n  }\r\n\r\n\r\n  /*\r\n   * Configure global settings for a Decimal constructor.\r\n   *\r\n   * `obj` is an object with one or more of the following properties,\r\n   *\r\n   *   precision  {number}\r\n   *   rounding   {number}\r\n   *   toExpNeg   {number}\r\n   *   toExpPos   {number}\r\n   *\r\n   * E.g. Decimal.config({ precision: 20, rounding: 4 })\r\n   *\r\n   */\r\n  function config(obj) {\r\n    if (!obj || typeof obj !== 'object') {\r\n      throw Error(decimalError + 'Object expected');\r\n    }\r\n    var i, p, v,\r\n      ps = [\r\n        'precision', 1, MAX_DIGITS,\r\n        'rounding', 0, 8,\r\n        'toExpNeg', -1 / 0, 0,\r\n        'toExpPos', 0, 1 / 0\r\n      ];\r\n\r\n    for (i = 0; i < ps.length; i += 3) {\r\n      if ((v = obj[p = ps[i]]) !== void 0) {\r\n        if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;\r\n        else throw Error(invalidArgument + p + ': ' + v);\r\n      }\r\n    }\r\n\r\n    if ((v = obj[p = 'LN10']) !== void 0) {\r\n        if (v == Math.LN10) this[p] = new this(v);\r\n        else throw Error(invalidArgument + p + ': ' + v);\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n\r\n  // Create and configure initial Decimal constructor.\r\n  Decimal = clone(Decimal);\r\n\r\n  Decimal['default'] = Decimal.Decimal = Decimal;\r\n\r\n  // Internal constant.\r\n  ONE = new Decimal(1);\r\n\r\n\r\n  // Export.\r\n\r\n\r\n  // AMD.\r\n  if (typeof define == 'function' && define.amd) {\r\n    define(function () {\r\n      return Decimal;\r\n    });\r\n\r\n  // Node and other environments that support module.exports.\r\n  } else if (typeof module != 'undefined' && module.exports) {\r\n    module.exports = Decimal;\r\n\r\n    // Browser.\r\n  } else {\r\n    if (!globalScope) {\r\n      globalScope = typeof self != 'undefined' && self && self.self == self\r\n        ? self : Function('return this')();\r\n    }\r\n\r\n    globalScope.Decimal = Decimal;\r\n  }\r\n})(this);\r\n","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.default = addClass;\n\nvar _hasClass = _interopRequireDefault(require(\"./hasClass\"));\n\nfunction addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!(0, _hasClass.default)(element, className)) if (typeof element.className === 'string') element.className = element.className + ' ' + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + ' ' + className);\n}\n\nmodule.exports = exports[\"default\"];","\"use strict\";\n\nexports.__esModule = true;\nexports.default = hasClass;\n\nfunction hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);else return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}\n\nmodule.exports = exports[\"default\"];","'use strict';\n\nfunction replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp('(^|\\\\s)' + classToRemove + '(?:\\\\s|$)', 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n\nmodule.exports = function removeClass(element, className) {\n  if (element.classList) element.classList.remove(className);else if (typeof element.className === 'string') element.className = replaceClassName(element.className, className);else element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n};","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nfunction componentWillMount() {\n  // Call this.constructor.gDSFP to support sub-classes.\n  var state = this.constructor.getDerivedStateFromProps(this.props, this.state);\n  if (state !== null && state !== undefined) {\n    this.setState(state);\n  }\n}\n\nfunction componentWillReceiveProps(nextProps) {\n  // Call this.constructor.gDSFP to support sub-classes.\n  // Use the setState() updater to ensure state isn't stale in certain edge cases.\n  function updater(prevState) {\n    var state = this.constructor.getDerivedStateFromProps(nextProps, prevState);\n    return state !== null && state !== undefined ? state : null;\n  }\n  // Binding \"this\" is important for shallow renderer support.\n  this.setState(updater.bind(this));\n}\n\nfunction componentWillUpdate(nextProps, nextState) {\n  try {\n    var prevProps = this.props;\n    var prevState = this.state;\n    this.props = nextProps;\n    this.state = nextState;\n    this.__reactInternalSnapshotFlag = true;\n    this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate(\n      prevProps,\n      prevState\n    );\n  } finally {\n    this.props = prevProps;\n    this.state = prevState;\n  }\n}\n\n// React may warn about cWM/cWRP/cWU methods being deprecated.\n// Add a flag to suppress these warnings for this special case.\ncomponentWillMount.__suppressDeprecationWarning = true;\ncomponentWillReceiveProps.__suppressDeprecationWarning = true;\ncomponentWillUpdate.__suppressDeprecationWarning = true;\n\nfunction polyfill(Component) {\n  var prototype = Component.prototype;\n\n  if (!prototype || !prototype.isReactComponent) {\n    throw new Error('Can only polyfill class components');\n  }\n\n  if (\n    typeof Component.getDerivedStateFromProps !== 'function' &&\n    typeof prototype.getSnapshotBeforeUpdate !== 'function'\n  ) {\n    return Component;\n  }\n\n  // If new component APIs are defined, \"unsafe\" lifecycles won't be called.\n  // Error if any of these lifecycles are present,\n  // Because they would work differently between older and newer (16.3+) versions of React.\n  var foundWillMountName = null;\n  var foundWillReceivePropsName = null;\n  var foundWillUpdateName = null;\n  if (typeof prototype.componentWillMount === 'function') {\n    foundWillMountName = 'componentWillMount';\n  } else if (typeof prototype.UNSAFE_componentWillMount === 'function') {\n    foundWillMountName = 'UNSAFE_componentWillMount';\n  }\n  if (typeof prototype.componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'componentWillReceiveProps';\n  } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') {\n    foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';\n  }\n  if (typeof prototype.componentWillUpdate === 'function') {\n    foundWillUpdateName = 'componentWillUpdate';\n  } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') {\n    foundWillUpdateName = 'UNSAFE_componentWillUpdate';\n  }\n  if (\n    foundWillMountName !== null ||\n    foundWillReceivePropsName !== null ||\n    foundWillUpdateName !== null\n  ) {\n    var componentName = Component.displayName || Component.name;\n    var newApiName =\n      typeof Component.getDerivedStateFromProps === 'function'\n        ? 'getDerivedStateFromProps()'\n        : 'getSnapshotBeforeUpdate()';\n\n    throw Error(\n      'Unsafe legacy lifecycles will not be called for components using new component APIs.\\n\\n' +\n        componentName +\n        ' uses ' +\n        newApiName +\n        ' but also contains the following legacy lifecycles:' +\n        (foundWillMountName !== null ? '\\n  ' + foundWillMountName : '') +\n        (foundWillReceivePropsName !== null\n          ? '\\n  ' + foundWillReceivePropsName\n          : '') +\n        (foundWillUpdateName !== null ? '\\n  ' + foundWillUpdateName : '') +\n        '\\n\\nThe above lifecycles should be removed. Learn more about this warning here:\\n' +\n        'https://fb.me/react-async-component-lifecycle-hooks'\n    );\n  }\n\n  // React <= 16.2 does not support static getDerivedStateFromProps.\n  // As a workaround, use cWM and cWRP to invoke the new static lifecycle.\n  // Newer versions of React will ignore these lifecycles if gDSFP exists.\n  if (typeof Component.getDerivedStateFromProps === 'function') {\n    prototype.componentWillMount = componentWillMount;\n    prototype.componentWillReceiveProps = componentWillReceiveProps;\n  }\n\n  // React <= 16.2 does not support getSnapshotBeforeUpdate.\n  // As a workaround, use cWU to invoke the new lifecycle.\n  // Newer versions of React will ignore that lifecycle if gSBU exists.\n  if (typeof prototype.getSnapshotBeforeUpdate === 'function') {\n    if (typeof prototype.componentDidUpdate !== 'function') {\n      throw new Error(\n        'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype'\n      );\n    }\n\n    prototype.componentWillUpdate = componentWillUpdate;\n\n    var componentDidUpdate = prototype.componentDidUpdate;\n\n    prototype.componentDidUpdate = function componentDidUpdatePolyfill(\n      prevProps,\n      prevState,\n      maybeSnapshot\n    ) {\n      // 16.3+ will not execute our will-update method;\n      // It will pass a snapshot value to did-update though.\n      // Older versions will require our polyfilled will-update value.\n      // We need to handle both cases, but can't just check for the presence of \"maybeSnapshot\",\n      // Because for <= 15.x versions this might be a \"prevContext\" object.\n      // We also can't just check \"__reactInternalSnapshot\",\n      // Because get-snapshot might return a falsy value.\n      // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior.\n      var snapshot = this.__reactInternalSnapshotFlag\n        ? this.__reactInternalSnapshot\n        : maybeSnapshot;\n\n      componentDidUpdate.call(this, prevProps, prevState, snapshot);\n    };\n  }\n\n  return Component;\n}\n\nexport { polyfill };\n","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nvar identity = function identity(i) {\n  return i;\n};\n\nexport var PLACE_HOLDER = {\n  '@@functional/placeholder': true\n};\n\nvar isPlaceHolder = function isPlaceHolder(val) {\n  return val === PLACE_HOLDER;\n};\n\nvar curry0 = function curry0(fn) {\n  return function _curried() {\n    if (arguments.length === 0 || arguments.length === 1 && isPlaceHolder(arguments.length <= 0 ? undefined : arguments[0])) {\n      return _curried;\n    }\n\n    return fn.apply(void 0, arguments);\n  };\n};\n\nvar curryN = function curryN(n, fn) {\n  if (n === 1) {\n    return fn;\n  }\n\n  return curry0(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    var argsLength = args.filter(function (arg) {\n      return arg !== PLACE_HOLDER;\n    }).length;\n\n    if (argsLength >= n) {\n      return fn.apply(void 0, args);\n    }\n\n    return curryN(n - argsLength, curry0(function () {\n      for (var _len2 = arguments.length, restArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        restArgs[_key2] = arguments[_key2];\n      }\n\n      var newArgs = args.map(function (arg) {\n        return isPlaceHolder(arg) ? restArgs.shift() : arg;\n      });\n      return fn.apply(void 0, _toConsumableArray(newArgs).concat(restArgs));\n    }));\n  });\n};\n\nexport var curry = function curry(fn) {\n  return curryN(fn.length, fn);\n};\nexport var range = function range(begin, end) {\n  var arr = [];\n\n  for (var i = begin; i < end; ++i) {\n    arr[i - begin] = i;\n  }\n\n  return arr;\n};\nexport var map = curry(function (fn, arr) {\n  if (Array.isArray(arr)) {\n    return arr.map(fn);\n  }\n\n  return Object.keys(arr).map(function (key) {\n    return arr[key];\n  }).map(fn);\n});\nexport var compose = function compose() {\n  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n    args[_key3] = arguments[_key3];\n  }\n\n  if (!args.length) {\n    return identity;\n  }\n\n  var fns = args.reverse(); // first function can receive multiply arguments\n\n  var firstFn = fns[0];\n  var tailsFn = fns.slice(1);\n  return function () {\n    return tailsFn.reduce(function (res, fn) {\n      return fn(res);\n    }, firstFn.apply(void 0, arguments));\n  };\n};\nexport var reverse = function reverse(arr) {\n  if (Array.isArray(arr)) {\n    return arr.reverse();\n  } // can be string\n\n\n  return arr.split('').reverse.join('');\n};\nexport var memoize = function memoize(fn) {\n  var lastArgs = null;\n  var lastResult = null;\n  return function () {\n    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n      args[_key4] = arguments[_key4];\n    }\n\n    if (lastArgs && args.every(function (val, i) {\n      return val === lastArgs[i];\n    })) {\n      return lastResult;\n    }\n\n    lastArgs = args;\n    lastResult = fn.apply(void 0, args);\n    return lastResult;\n  };\n};","/**\n * @fileOverview 一些公用的运算方法\n * @author xile611\n * @date 2015-09-17\n */\nimport Decimal from 'decimal.js-light';\nimport { curry } from './utils';\n/**\n * 获取数值的位数\n * 其中绝对值属于区间[0.1, 1)， 得到的值为0\n * 绝对值属于区间[0.01, 0.1)，得到的位数为 -1\n * 绝对值属于区间[0.001, 0.01)，得到的位数为 -2\n *\n * @param  {Number} value 数值\n * @return {Integer} 位数\n */\n\nfunction getDigitCount(value) {\n  var result;\n\n  if (value === 0) {\n    result = 1;\n  } else {\n    result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;\n  }\n\n  return result;\n}\n/**\n * 按照固定的步长获取[start, end)这个区间的数据\n * 并且需要处理js计算精度的问题\n *\n * @param  {Decimal} start 起点\n * @param  {Decimal} end   终点，不包含该值\n * @param  {Decimal} step  步长\n * @return {Array}         若干数值\n */\n\n\nfunction rangeStep(start, end, step) {\n  var num = new Decimal(start);\n  var i = 0;\n  var result = []; // magic number to prevent infinite loop\n\n  while (num.lt(end) && i < 100000) {\n    result.push(num.toNumber());\n    num = num.add(step);\n    i++;\n  }\n\n  return result;\n}\n/**\n * 对数值进行线性插值\n *\n * @param  {Number} a  定义域的极点\n * @param  {Number} b  定义域的极点\n * @param  {Number} t  [0, 1]内的某个值\n * @return {Number}    定义域内的某个值\n */\n\n\nvar interpolateNumber = curry(function (a, b, t) {\n  var newA = +a;\n  var newB = +b;\n  return newA + t * (newB - newA);\n});\n/**\n * 线性插值的逆运算\n *\n * @param  {Number} a 定义域的极点\n * @param  {Number} b 定义域的极点\n * @param  {Number} x 可以认为是插值后的一个输出值\n * @return {Number}   当x在 a ~ b这个范围内时，返回值属于[0, 1]\n */\n\nvar uninterpolateNumber = curry(function (a, b, x) {\n  var diff = b - +a;\n  diff = diff || Infinity;\n  return (x - a) / diff;\n});\n/**\n * 线性插值的逆运算，并且有截断的操作\n *\n * @param  {Number} a 定义域的极点\n * @param  {Number} b 定义域的极点\n * @param  {Number} x 可以认为是插值后的一个输出值\n * @return {Number}   当x在 a ~ b这个区间内时，返回值属于[0, 1]，\n * 当x不在 a ~ b这个区间时，会截断到 a ~ b 这个区间\n */\n\nvar uninterpolateTruncation = curry(function (a, b, x) {\n  var diff = b - +a;\n  diff = diff || Infinity;\n  return Math.max(0, Math.min(1, (x - a) / diff));\n});\nexport default {\n  rangeStep: rangeStep,\n  getDigitCount: getDigitCount,\n  interpolateNumber: interpolateNumber,\n  uninterpolateNumber: uninterpolateNumber,\n  uninterpolateTruncation: uninterpolateTruncation\n};","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n/**\n * @fileOverview calculate tick values of scale\n * @author xile611, arcthur\n * @date 2015-09-17\n */\nimport Decimal from 'decimal.js-light';\nimport { compose, range, memoize, map, reverse } from './util/utils';\nimport Arithmetic from './util/arithmetic';\n/**\n * Calculate a interval of a minimum value and a maximum value\n *\n * @param  {Number} min       The minimum value\n * @param  {Number} max       The maximum value\n * @return {Array} An interval\n */\n\nfunction getValidInterval(_ref) {\n  var _ref2 = _slicedToArray(_ref, 2),\n      min = _ref2[0],\n      max = _ref2[1];\n\n  var validMin = min,\n      validMax = max; // exchange\n\n  if (min > max) {\n    validMin = max;\n    validMax = min;\n  }\n\n  return [validMin, validMax];\n}\n/**\n * Calculate the step which is easy to understand between ticks, like 10, 20, 25\n *\n * @param  {Decimal} roughStep        The rough step calculated by deviding the\n * difference by the tickCount\n * @param  {Boolean} allowDecimals    Allow the ticks to be decimals or not\n * @param  {Integer} correctionFactor A correction factor\n * @return {Decimal} The step which is easy to understand between two ticks\n */\n\n\nfunction getFormatStep(roughStep, allowDecimals, correctionFactor) {\n  if (roughStep.lte(0)) {\n    return new Decimal(0);\n  }\n\n  var digitCount = Arithmetic.getDigitCount(roughStep.toNumber()); // The ratio between the rough step and the smallest number which has a bigger\n  // order of magnitudes than the rough step\n\n  var digitCountValue = new Decimal(10).pow(digitCount);\n  var stepRatio = roughStep.div(digitCountValue); // When an integer and a float multiplied, the accuracy of result may be wrong\n\n  var stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;\n  var amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber())).add(correctionFactor).mul(stepRatioScale);\n  var formatStep = amendStepRatio.mul(digitCountValue);\n  return allowDecimals ? formatStep : new Decimal(Math.ceil(formatStep));\n}\n/**\n * calculate the ticks when the minimum value equals to the maximum value\n *\n * @param  {Number}  value         The minimum valuue which is also the maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}                 ticks\n */\n\n\nfunction getTickOfSingleValue(value, tickCount, allowDecimals) {\n  var step = 1; // calculate the middle value of ticks\n\n  var middle = new Decimal(value);\n\n  if (!middle.isint() && allowDecimals) {\n    var absVal = Math.abs(value);\n\n    if (absVal < 1) {\n      // The step should be a float number when the difference is smaller than 1\n      step = new Decimal(10).pow(Arithmetic.getDigitCount(value) - 1);\n      middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step);\n    } else if (absVal > 1) {\n      // Return the maximum integer which is smaller than 'value' when 'value' is greater than 1\n      middle = new Decimal(Math.floor(value));\n    }\n  } else if (value === 0) {\n    middle = new Decimal(Math.floor((tickCount - 1) / 2));\n  } else if (!allowDecimals) {\n    middle = new Decimal(Math.floor(value));\n  }\n\n  var middleIndex = Math.floor((tickCount - 1) / 2);\n  var fn = compose(map(function (n) {\n    return middle.add(new Decimal(n - middleIndex).mul(step)).toNumber();\n  }), range);\n  return fn(0, tickCount);\n}\n/**\n * Calculate the step\n *\n * @param  {Number}  min              The minimum value of an interval\n * @param  {Number}  max              The maximum value of an interval\n * @param  {Integer} tickCount        The count of ticks\n * @param  {Boolean} allowDecimals    Allow the ticks to be decimals or not\n * @param  {Number}  correctionFactor A correction factor\n * @return {Object}  The step, minimum value of ticks, maximum value of ticks\n */\n\n\nfunction calculateStep(min, max, tickCount, allowDecimals) {\n  var correctionFactor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;\n\n  // dirty hack (for recharts' test)\n  if (!Number.isFinite((max - min) / (tickCount - 1))) {\n    return {\n      step: new Decimal(0),\n      tickMin: new Decimal(0),\n      tickMax: new Decimal(0)\n    };\n  } // The step which is easy to understand between two ticks\n\n\n  var step = getFormatStep(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor); // A medial value of ticks\n\n  var middle; // When 0 is inside the interval, 0 should be a tick\n\n  if (min <= 0 && max >= 0) {\n    middle = new Decimal(0);\n  } else {\n    // calculate the middle value\n    middle = new Decimal(min).add(max).div(2); // minus modulo value\n\n    middle = middle.sub(new Decimal(middle).mod(step));\n  }\n\n  var belowCount = Math.ceil(middle.sub(min).div(step).toNumber());\n  var upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());\n  var scaleCount = belowCount + upCount + 1;\n\n  if (scaleCount > tickCount) {\n    // When more ticks need to cover the interval, step should be bigger.\n    return calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1);\n  }\n\n  if (scaleCount < tickCount) {\n    // When less ticks can cover the interval, we should add some additional ticks\n    upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount;\n    belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount);\n  }\n\n  return {\n    step: step,\n    tickMin: middle.sub(new Decimal(belowCount).mul(step)),\n    tickMax: middle.add(new Decimal(upCount).mul(step))\n  };\n}\n/**\n * Calculate the ticks of an interval, the count of ticks will be guraranteed\n *\n * @param  {Number}  min, max      min: The minimum value, max: The maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}   ticks\n */\n\n\nfunction getNiceTickValuesFn(_ref3) {\n  var _ref4 = _slicedToArray(_ref3, 2),\n      min = _ref4[0],\n      max = _ref4[1];\n\n  var tickCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;\n  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  // More than two ticks should be return\n  var count = Math.max(tickCount, 2);\n\n  var _getValidInterval = getValidInterval([min, max]),\n      _getValidInterval2 = _slicedToArray(_getValidInterval, 2),\n      cormin = _getValidInterval2[0],\n      cormax = _getValidInterval2[1];\n\n  if (cormin === -Infinity || cormax === Infinity) {\n    var _values = cormax === Infinity ? [cormin].concat(_toConsumableArray(range(0, tickCount - 1).map(function () {\n      return Infinity;\n    }))) : [].concat(_toConsumableArray(range(0, tickCount - 1).map(function () {\n      return -Infinity;\n    })), [cormax]);\n\n    return min > max ? reverse(_values) : _values;\n  }\n\n  if (cormin === cormax) {\n    return getTickOfSingleValue(cormin, tickCount, allowDecimals);\n  } // Get the step between two ticks\n\n\n  var _calculateStep = calculateStep(cormin, cormax, count, allowDecimals),\n      step = _calculateStep.step,\n      tickMin = _calculateStep.tickMin,\n      tickMax = _calculateStep.tickMax;\n\n  var values = Arithmetic.rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);\n  return min > max ? reverse(values) : values;\n}\n/**\n * Calculate the ticks of an interval, the count of ticks won't be guraranteed\n *\n * @param  {Number}  min, max      min: The minimum value, max: The maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}   ticks\n */\n\n\nfunction getTickValuesFn(_ref5) {\n  var _ref6 = _slicedToArray(_ref5, 2),\n      min = _ref6[0],\n      max = _ref6[1];\n\n  var tickCount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 6;\n  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n  // More than two ticks should be return\n  var count = Math.max(tickCount, 2);\n\n  var _getValidInterval3 = getValidInterval([min, max]),\n      _getValidInterval4 = _slicedToArray(_getValidInterval3, 2),\n      cormin = _getValidInterval4[0],\n      cormax = _getValidInterval4[1];\n\n  if (cormin === -Infinity || cormax === Infinity) {\n    return [min, max];\n  }\n\n  if (cormin === cormax) {\n    return getTickOfSingleValue(cormin, tickCount, allowDecimals);\n  }\n\n  var step = getFormatStep(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);\n  var fn = compose(map(function (n) {\n    return new Decimal(cormin).add(new Decimal(n).mul(step)).toNumber();\n  }), range);\n  var values = fn(0, count).filter(function (entry) {\n    return entry >= cormin && entry <= cormax;\n  });\n  return min > max ? reverse(values) : values;\n}\n/**\n * Calculate the ticks of an interval, the count of ticks won't be guraranteed,\n * but the domain will be guaranteed\n *\n * @param  {Number}  min, max      min: The minimum value, max: The maximum value\n * @param  {Integer} tickCount     The count of ticks\n * @param  {Boolean} allowDecimals Allow the ticks to be decimals or not\n * @return {Array}   ticks\n */\n\n\nfunction getTickValuesFixedDomainFn(_ref7, tickCount) {\n  var _ref8 = _slicedToArray(_ref7, 2),\n      min = _ref8[0],\n      max = _ref8[1];\n\n  var allowDecimals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n\n  // More than two ticks should be return\n  var _getValidInterval5 = getValidInterval([min, max]),\n      _getValidInterval6 = _slicedToArray(_getValidInterval5, 2),\n      cormin = _getValidInterval6[0],\n      cormax = _getValidInterval6[1];\n\n  if (cormin === -Infinity || cormax === Infinity) {\n    return [min, max];\n  }\n\n  if (cormin === cormax) {\n    return [cormin];\n  }\n\n  var count = Math.max(tickCount, 2);\n  var step = getFormatStep(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);\n  var values = [].concat(_toConsumableArray(Arithmetic.rangeStep(new Decimal(cormin), new Decimal(cormax).sub(new Decimal(0.99).mul(step)), step)), [cormax]);\n  return min > max ? reverse(values) : values;\n}\n\nexport var getNiceTickValues = memoize(getNiceTickValuesFn);\nexport var getTickValues = memoize(getTickValuesFn);\nexport var getTickValuesFixedDomain = memoize(getTickValuesFixedDomainFn);"],"names":["module","exports","obj","__esModule","useSafeState","initialState","mountedRef","useRef","state","setState","useState","useEffect","current","useCallback","args","SvgNavigationProfileHighlightedMedium","React","ref","color","size","title","titleId","props","_ref","fill","xmlns","viewBox","width","height","id","d","defaultProps","undefined","propTypes","PropTypes","SvgBadgesMulticolorSuperuserSmall","fillRule","SvgBadgesMulticolorSummitSmall","SvgBadgesMulticolorProSmall","SvgBadgesMulticolorVerifiedSmall","Img","src","alt","fallback","children","setChildren","image","Image","onload","onerror","_ref2","name","type","badge","className","otherProps","classNames","clsx","styles","avatar","ProBadge","EmployeeBadge","SubscriberBadge","VerifiedBadge","getBadge","imgWrapper","AvatarFallback","value","label","wrapperClassName","labelClassName","valueClassName","labelAfterValue","labelElement","statLabel","stat","statValue","Stats","listClassName","map","child","key","isRequired","hasOwn","hasOwnProperty","classes","i","arguments","length","arg","argType","push","Array","isArray","inner","apply","toString","Object","prototype","call","join","default","globalScope","ONE","MAX_DIGITS","Decimal","precision","rounding","toExpNeg","toExpPos","LN10","external","decimalError","invalidArgument","exponentOutOfRange","mathfloor","Math","floor","mathpow","pow","isDecimal","BASE","MAX_SAFE_INTEGER","MAX_E","P","add","x","y","carry","e","k","len","xd","yd","Ctor","constructor","pr","s","round","slice","ceil","reverse","unshift","pop","checkInt32","min","max","Error","digitsToString","ws","indexOfLastWord","str","w","getZeroString","absoluteValue","abs","this","comparedTo","cmp","j","xdL","ydL","decimalPlaces","dp","dividedBy","div","divide","dividedToIntegerBy","idiv","equals","eq","exponent","getBase10Exponent","greaterThan","gt","greaterThanOrEqualTo","gte","isInteger","isint","isNegative","isneg","isPositive","ispos","isZero","lessThan","lt","lessThanOrEqualTo","lte","logarithm","log","base","r","wpr","ln","minus","sub","subtract","modulo","mod","q","times","naturalExponential","exp","naturalLogarithm","negated","neg","plus","sd","z","squareRoot","sqrt","n","t","toExponential","indexOf","mul","rL","shift","toDecimalPlaces","todp","rm","toFixed","toInteger","toint","toNumber","toPower","sign","yIsInt","yn","truncate","toPrecision","toSignificantDigits","tosd","valueOf","val","toJSON","multiplyInteger","temp","compare","a","b","aL","bL","prod","prodL","qd","rem","remL","rem0","xi","xL","yd0","yL","yz","denominator","sum","getLn10","zs","c","c0","numerator","x2","charAt","parseDecimal","replace","search","substring","charCodeAt","rd","doRound","xdi","xe","xLTy","isExp","arr","config","p","v","ps","clone","test","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","set","_interopRequireDefault","element","classList","_hasClass","setAttribute","baseVal","contains","replaceClassName","origClass","classToRemove","RegExp","remove","Symbol","getRawTag","objectToString","symToStringTag","toStringTag","freeGlobal","g","objectProto","nativeObjectToString","isOwn","tag","unmasked","result","freeSelf","self","root","Function","baseGetTag","isObjectLike","componentWillMount","getDerivedStateFromProps","componentWillReceiveProps","nextProps","prevState","bind","componentWillUpdate","nextState","prevProps","__reactInternalSnapshotFlag","__reactInternalSnapshot","getSnapshotBeforeUpdate","polyfill","Component","isReactComponent","foundWillMountName","foundWillReceivePropsName","foundWillUpdateName","UNSAFE_componentWillMount","UNSAFE_componentWillReceiveProps","UNSAFE_componentWillUpdate","componentName","displayName","newApiName","componentDidUpdate","maybeSnapshot","snapshot","__suppressDeprecationWarning","_toConsumableArray","_arrayLikeToArray","_arrayWithoutHoles","iter","iterator","from","_iterableToArray","o","minLen","_unsupportedIterableToArray","TypeError","_nonIterableSpread","arr2","identity","PLACE_HOLDER","isPlaceHolder","curry0","fn","_curried","curryN","_len","_key","argsLength","filter","_len2","restArgs","_key2","newArgs","concat","curry","range","begin","end","keys","compose","_len3","_key3","fns","firstFn","tailsFn","reduce","res","split","memoize","lastArgs","lastResult","_len4","_key4","every","rangeStep","start","step","num","getDigitCount","interpolateNumber","newA","uninterpolateNumber","diff","Infinity","uninterpolateTruncation","_slicedToArray","_arrayWithHoles","_arr","_n","_d","_e","_s","_i","next","done","err","_iterableToArrayLimit","_nonIterableRest","getValidInterval","validMin","validMax","getFormatStep","roughStep","allowDecimals","correctionFactor","digitCount","digitCountValue","stepRatio","stepRatioScale","formatStep","getTickOfSingleValue","tickCount","middle","absVal","middleIndex","calculateStep","Number","isFinite","tickMin","tickMax","belowCount","upCount","scaleCount","getNiceTickValues","_ref3","_ref4","count","_getValidInterval","_getValidInterval2","cormin","cormax","_values","_calculateStep","values","getTickValuesFixedDomain","_ref5","_ref6","_getValidInterval3","_getValidInterval4","entry","_ref7","_ref8","_getValidInterval5","_getValidInterval6"],"sourceRoot":""}