@reltio/remotes 1.4.1387 → 1.4.1389

package/3723.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"3723.js","mappings":"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","sources":["webpack://@reltio/remotes/../../node_modules/@date-io/moment/build/index.esm.js","webpack://@reltio/remotes/../../node_modules/@material-ui/core/esm/Drawer/Drawer.js","webpack://@reltio/remotes/../../node_modules/@material-ui/core/esm/Slide/Slide.js","webpack://@reltio/remotes/../../node_modules/@material-ui/icons/Tune.js","webpack://@reltio/remotes/../../node_modules/@material-ui/icons/esm/ArrowDropDown.js","webpack://@reltio/remotes/../../node_modules/@material-ui/icons/esm/utils/createSvgIcon.js","webpack://@reltio/remotes/../../node_modules/decimal.js/decimal.js","webpack://@reltio/remotes/../../node_modules/decode-uri-component/index.js","webpack://@reltio/remotes/../../node_modules/object-assign/index.js","webpack://@reltio/remotes/../../node_modules/query-string/index.js","webpack://@reltio/remotes/../../node_modules/redux-devtools-extension/developmentOnly.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-middlewares/lib/index.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/Managers/MiddlewareManager.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/Managers/ModuleManager.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/Managers/ReducerManager.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/Managers/RefCountedManager.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/ModuleStore.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/Utils/ComparableMap.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/Utils/Flatten.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/Utils/RefCounter.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-core/lib/index.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-react/lib/DynamicModuleLoader.js","webpack://@reltio/remotes/../../node_modules/redux-dynamic-modules-react/lib/index.js","webpack://@reltio/remotes/../../node_modules/strict-uri-encode/index.js"],"sourcesContent":["import defaultMoment from 'moment';\n\nvar MomentUtils = /** @class */ (function () {\n    function MomentUtils(_a) {\n        var _b = _a === void 0 ? {} : _a, locale = _b.locale, instance = _b.instance, moment = _b.moment;\n        this.yearFormat = \"YYYY\";\n        this.yearMonthFormat = \"MMMM YYYY\";\n        this.dateTime12hFormat = \"MMMM Do hh:mm a\";\n        this.dateTime24hFormat = \"MMMM Do HH:mm\";\n        this.time12hFormat = \"hh:mm A\";\n        this.time24hFormat = \"HH:mm\";\n        this.dateFormat = \"MMMM Do\";\n        this.moment = instance || moment || defaultMoment;\n        this.locale = locale;\n    }\n    MomentUtils.prototype.parse = function (value, format) {\n        if (value === \"\") {\n            return null;\n        }\n        return this.moment(value, format, true);\n    };\n    MomentUtils.prototype.date = function (value) {\n        if (value === null) {\n            return null;\n        }\n        var moment = this.moment(value);\n        moment.locale(this.locale);\n        return moment;\n    };\n    MomentUtils.prototype.isValid = function (value) {\n        return this.moment(value).isValid();\n    };\n    MomentUtils.prototype.isNull = function (date) {\n        return date === null;\n    };\n    MomentUtils.prototype.getDiff = function (date, comparing) {\n        return date.diff(comparing);\n    };\n    MomentUtils.prototype.isAfter = function (date, value) {\n        return date.isAfter(value);\n    };\n    MomentUtils.prototype.isBefore = function (date, value) {\n        return date.isBefore(value);\n    };\n    MomentUtils.prototype.isAfterDay = function (date, value) {\n        return date.isAfter(value, \"day\");\n    };\n    MomentUtils.prototype.isBeforeDay = function (date, value) {\n        return date.isBefore(value, \"day\");\n    };\n    MomentUtils.prototype.isBeforeYear = function (date, value) {\n        return date.isBefore(value, \"year\");\n    };\n    MomentUtils.prototype.isAfterYear = function (date, value) {\n        return date.isAfter(value, \"year\");\n    };\n    MomentUtils.prototype.startOfDay = function (date) {\n        return date.clone().startOf(\"day\");\n    };\n    MomentUtils.prototype.endOfDay = function (date) {\n        return date.clone().endOf(\"day\");\n    };\n    MomentUtils.prototype.format = function (date, formatString) {\n        date.locale(this.locale);\n        return date.format(formatString);\n    };\n    MomentUtils.prototype.formatNumber = function (numberToFormat) {\n        return numberToFormat;\n    };\n    MomentUtils.prototype.getHours = function (date) {\n        return date.get(\"hours\");\n    };\n    MomentUtils.prototype.addDays = function (date, count) {\n        return count < 0\n            ? date.clone().subtract(Math.abs(count), \"days\")\n            : date.clone().add(count, \"days\");\n    };\n    MomentUtils.prototype.setHours = function (date, count) {\n        return date.clone().hours(count);\n    };\n    MomentUtils.prototype.getMinutes = function (date) {\n        return date.get(\"minutes\");\n    };\n    MomentUtils.prototype.setMinutes = function (date, count) {\n        return date.clone().minutes(count);\n    };\n    MomentUtils.prototype.getSeconds = function (date) {\n        return date.get(\"seconds\");\n    };\n    MomentUtils.prototype.setSeconds = function (date, count) {\n        return date.clone().seconds(count);\n    };\n    MomentUtils.prototype.getMonth = function (date) {\n        return date.get(\"month\");\n    };\n    MomentUtils.prototype.isSameDay = function (date, comparing) {\n        return date.isSame(comparing, \"day\");\n    };\n    MomentUtils.prototype.isSameMonth = function (date, comparing) {\n        return date.isSame(comparing, \"month\");\n    };\n    MomentUtils.prototype.isSameYear = function (date, comparing) {\n        return date.isSame(comparing, \"year\");\n    };\n    MomentUtils.prototype.isSameHour = function (date, comparing) {\n        return date.isSame(comparing, \"hour\");\n    };\n    MomentUtils.prototype.setMonth = function (date, count) {\n        return date.clone().month(count);\n    };\n    MomentUtils.prototype.getMeridiemText = function (ampm) {\n        return ampm === \"am\" ? \"AM\" : \"PM\";\n    };\n    MomentUtils.prototype.startOfMonth = function (date) {\n        return date.clone().startOf(\"month\");\n    };\n    MomentUtils.prototype.endOfMonth = function (date) {\n        return date.clone().endOf(\"month\");\n    };\n    MomentUtils.prototype.getNextMonth = function (date) {\n        return date.clone().add(1, \"month\");\n    };\n    MomentUtils.prototype.getPreviousMonth = function (date) {\n        return date.clone().subtract(1, \"month\");\n    };\n    MomentUtils.prototype.getMonthArray = function (date) {\n        var firstMonth = date.clone().startOf(\"year\");\n        var monthArray = [firstMonth];\n        while (monthArray.length < 12) {\n            var prevMonth = monthArray[monthArray.length - 1];\n            monthArray.push(this.getNextMonth(prevMonth));\n        }\n        return monthArray;\n    };\n    MomentUtils.prototype.getYear = function (date) {\n        return date.get(\"year\");\n    };\n    MomentUtils.prototype.setYear = function (date, year) {\n        return date.clone().set(\"year\", year);\n    };\n    MomentUtils.prototype.mergeDateAndTime = function (date, time) {\n        return this.setMinutes(this.setHours(date, this.getHours(time)), this.getMinutes(time));\n    };\n    MomentUtils.prototype.getWeekdays = function () {\n        return this.moment.weekdaysShort(true);\n    };\n    MomentUtils.prototype.isEqual = function (value, comparing) {\n        if (value === null && comparing === null) {\n            return true;\n        }\n        return this.moment(value).isSame(comparing);\n    };\n    MomentUtils.prototype.getWeekArray = function (date) {\n        var start = date\n            .clone()\n            .startOf(\"month\")\n            .startOf(\"week\");\n        var end = date\n            .clone()\n            .endOf(\"month\")\n            .endOf(\"week\");\n        var count = 0;\n        var current = start;\n        var nestedWeeks = [];\n        while (current.isBefore(end)) {\n            var weekNumber = Math.floor(count / 7);\n            nestedWeeks[weekNumber] = nestedWeeks[weekNumber] || [];\n            nestedWeeks[weekNumber].push(current);\n            current = current.clone().add(1, \"day\");\n            count += 1;\n        }\n        return nestedWeeks;\n    };\n    MomentUtils.prototype.getYearRange = function (start, end) {\n        var startDate = this.moment(start).startOf(\"year\");\n        var endDate = this.moment(end).endOf(\"year\");\n        var years = [];\n        var current = startDate;\n        while (current.isBefore(endDate)) {\n            years.push(current);\n            current = current.clone().add(1, \"year\");\n        }\n        return years;\n    };\n    // displaying methods\n    MomentUtils.prototype.getCalendarHeaderText = function (date) {\n        return this.format(date, this.yearMonthFormat);\n    };\n    MomentUtils.prototype.getYearText = function (date) {\n        return this.format(date, \"YYYY\");\n    };\n    MomentUtils.prototype.getDatePickerHeaderText = function (date) {\n        return this.format(date, \"ddd, MMM D\");\n    };\n    MomentUtils.prototype.getDateTimePickerHeaderText = function (date) {\n        return this.format(date, \"MMM D\");\n    };\n    MomentUtils.prototype.getMonthText = function (date) {\n        return this.format(date, \"MMMM\");\n    };\n    MomentUtils.prototype.getDayText = function (date) {\n        return this.format(date, \"D\");\n    };\n    MomentUtils.prototype.getHourText = function (date, ampm) {\n        return this.format(date, ampm ? \"hh\" : \"HH\");\n    };\n    MomentUtils.prototype.getMinuteText = function (date) {\n        return this.format(date, \"mm\");\n    };\n    MomentUtils.prototype.getSecondText = function (date) {\n        return this.format(date, \"ss\");\n    };\n    return MomentUtils;\n}());\n\nexport default MomentUtils;\n","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport Modal from '../Modal';\nimport Backdrop from '../Backdrop';\nimport withStyles from '../styles/withStyles';\nimport Slide from '../Slide';\nimport Paper from '../Paper';\nimport capitalize from '../utils/capitalize';\nimport { duration } from '../styles/transitions';\nimport useTheme from '../styles/useTheme';\nexport var styles = function styles(theme) {\n  return {\n    /* Styles applied to the root element. */\n    root: {},\n\n    /* Styles applied to the root element if `variant=\"permanent or persistent\"`. */\n    docked: {\n      flex: '0 0 auto'\n    },\n\n    /* Styles applied to the `Paper` component. */\n    paper: {\n      overflowY: 'auto',\n      display: 'flex',\n      flexDirection: 'column',\n      height: '100%',\n      flex: '1 0 auto',\n      zIndex: theme.zIndex.drawer,\n      WebkitOverflowScrolling: 'touch',\n      // Add iOS momentum scrolling.\n      // temporary style\n      position: 'fixed',\n      top: 0,\n      // We disable the focus ring for mouse, touch and keyboard users.\n      // At some point, it would be better to keep it for keyboard users.\n      // :focus-ring CSS pseudo-class will help.\n      outline: 0\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"left\"`. */\n    paperAnchorLeft: {\n      left: 0,\n      right: 'auto'\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"right\"`. */\n    paperAnchorRight: {\n      left: 'auto',\n      right: 0\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"top\"`. */\n    paperAnchorTop: {\n      top: 0,\n      left: 0,\n      bottom: 'auto',\n      right: 0,\n      height: 'auto',\n      maxHeight: '100%'\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"bottom\"`. */\n    paperAnchorBottom: {\n      top: 'auto',\n      left: 0,\n      bottom: 0,\n      right: 0,\n      height: 'auto',\n      maxHeight: '100%'\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"left\"` and `variant` is not \"temporary\". */\n    paperAnchorDockedLeft: {\n      borderRight: \"1px solid \".concat(theme.palette.divider)\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"top\"` and `variant` is not \"temporary\". */\n    paperAnchorDockedTop: {\n      borderBottom: \"1px solid \".concat(theme.palette.divider)\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"right\"` and `variant` is not \"temporary\". */\n    paperAnchorDockedRight: {\n      borderLeft: \"1px solid \".concat(theme.palette.divider)\n    },\n\n    /* Styles applied to the `Paper` component if `anchor=\"bottom\"` and `variant` is not \"temporary\". */\n    paperAnchorDockedBottom: {\n      borderTop: \"1px solid \".concat(theme.palette.divider)\n    },\n\n    /* Styles applied to the `Modal` component. */\n    modal: {}\n  };\n};\nvar oppositeDirection = {\n  left: 'right',\n  right: 'left',\n  top: 'down',\n  bottom: 'up'\n};\nexport function isHorizontal(anchor) {\n  return ['left', 'right'].indexOf(anchor) !== -1;\n}\nexport function getAnchor(theme, anchor) {\n  return theme.direction === 'rtl' && isHorizontal(anchor) ? oppositeDirection[anchor] : anchor;\n}\nvar defaultTransitionDuration = {\n  enter: duration.enteringScreen,\n  exit: duration.leavingScreen\n};\n/**\n * The props of the [Modal](/api/modal/) component are available\n * when `variant=\"temporary\"` is set.\n */\n\nvar Drawer = /*#__PURE__*/React.forwardRef(function Drawer(props, ref) {\n  var _props$anchor = props.anchor,\n      anchorProp = _props$anchor === void 0 ? 'left' : _props$anchor,\n      BackdropProps = props.BackdropProps,\n      children = props.children,\n      classes = props.classes,\n      className = props.className,\n      _props$elevation = props.elevation,\n      elevation = _props$elevation === void 0 ? 16 : _props$elevation,\n      _props$ModalProps = props.ModalProps;\n  _props$ModalProps = _props$ModalProps === void 0 ? {} : _props$ModalProps;\n\n  var BackdropPropsProp = _props$ModalProps.BackdropProps,\n      ModalProps = _objectWithoutProperties(_props$ModalProps, [\"BackdropProps\"]),\n      onClose = props.onClose,\n      _props$open = props.open,\n      open = _props$open === void 0 ? false : _props$open,\n      _props$PaperProps = props.PaperProps,\n      PaperProps = _props$PaperProps === void 0 ? {} : _props$PaperProps,\n      SlideProps = props.SlideProps,\n      _props$TransitionComp = props.TransitionComponent,\n      TransitionComponent = _props$TransitionComp === void 0 ? Slide : _props$TransitionComp,\n      _props$transitionDura = props.transitionDuration,\n      transitionDuration = _props$transitionDura === void 0 ? defaultTransitionDuration : _props$transitionDura,\n      _props$variant = props.variant,\n      variant = _props$variant === void 0 ? 'temporary' : _props$variant,\n      other = _objectWithoutProperties(props, [\"anchor\", \"BackdropProps\", \"children\", \"classes\", \"className\", \"elevation\", \"ModalProps\", \"onClose\", \"open\", \"PaperProps\", \"SlideProps\", \"TransitionComponent\", \"transitionDuration\", \"variant\"]);\n\n  var theme = useTheme(); // Let's assume that the Drawer will always be rendered on user space.\n  // We use this state is order to skip the appear transition during the\n  // initial mount of the component.\n\n  var mounted = React.useRef(false);\n  React.useEffect(function () {\n    mounted.current = true;\n  }, []);\n  var anchor = getAnchor(theme, anchorProp);\n  var drawer = /*#__PURE__*/React.createElement(Paper, _extends({\n    elevation: variant === 'temporary' ? elevation : 0,\n    square: true\n  }, PaperProps, {\n    className: clsx(classes.paper, classes[\"paperAnchor\".concat(capitalize(anchor))], PaperProps.className, variant !== 'temporary' && classes[\"paperAnchorDocked\".concat(capitalize(anchor))])\n  }), children);\n\n  if (variant === 'permanent') {\n    return /*#__PURE__*/React.createElement(\"div\", _extends({\n      className: clsx(classes.root, classes.docked, className),\n      ref: ref\n    }, other), drawer);\n  }\n\n  var slidingDrawer = /*#__PURE__*/React.createElement(TransitionComponent, _extends({\n    in: open,\n    direction: oppositeDirection[anchor],\n    timeout: transitionDuration,\n    appear: mounted.current\n  }, SlideProps), drawer);\n\n  if (variant === 'persistent') {\n    return /*#__PURE__*/React.createElement(\"div\", _extends({\n      className: clsx(classes.root, classes.docked, className),\n      ref: ref\n    }, other), slidingDrawer);\n  } // variant === temporary\n\n\n  return /*#__PURE__*/React.createElement(Modal, _extends({\n    BackdropProps: _extends({}, BackdropProps, BackdropPropsProp, {\n      transitionDuration: transitionDuration\n    }),\n    BackdropComponent: Backdrop,\n    className: clsx(classes.root, classes.modal, className),\n    open: open,\n    onClose: onClose,\n    ref: ref\n  }, other, ModalProps), slidingDrawer);\n});\nprocess.env.NODE_ENV !== \"production\" ? Drawer.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * Side from which the drawer will appear.\n   */\n  anchor: PropTypes.oneOf(['bottom', 'left', 'right', 'top']),\n\n  /**\n   * @ignore\n   */\n  BackdropProps: PropTypes.object,\n\n  /**\n   * The contents of the drawer.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The elevation of the drawer.\n   */\n  elevation: PropTypes.number,\n\n  /**\n   * Props applied to the [`Modal`](/api/modal/) element.\n   */\n  ModalProps: PropTypes.object,\n\n  /**\n   * Callback fired when the component requests to be closed.\n   *\n   * @param {object} event The event source of the callback.\n   */\n  onClose: PropTypes.func,\n\n  /**\n   * If `true`, the drawer is open.\n   */\n  open: PropTypes.bool,\n\n  /**\n   * Props applied to the [`Paper`](/api/paper/) element.\n   */\n  PaperProps: PropTypes.object,\n\n  /**\n   * Props applied to the [`Slide`](/api/slide/) element.\n   */\n  SlideProps: PropTypes.object,\n\n  /**\n   * The duration for the transition, in milliseconds.\n   * You may specify a single timeout for all transitions, or individually with an object.\n   */\n  transitionDuration: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({\n    appear: PropTypes.number,\n    enter: PropTypes.number,\n    exit: PropTypes.number\n  })]),\n\n  /**\n   * The variant to use.\n   */\n  variant: PropTypes.oneOf(['permanent', 'persistent', 'temporary'])\n} : void 0;\nexport default withStyles(styles, {\n  name: 'MuiDrawer',\n  flip: false\n})(Drawer);","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport * as ReactDOM from 'react-dom';\nimport debounce from '../utils/debounce';\nimport { Transition } from 'react-transition-group';\nimport { elementAcceptingRef } from '@material-ui/utils';\nimport useForkRef from '../utils/useForkRef';\nimport useTheme from '../styles/useTheme';\nimport { duration } from '../styles/transitions';\nimport { reflow, getTransitionProps } from '../transitions/utils'; // Translate the node so he can't be seen on the screen.\n// Later, we gonna translate back the node to his original location\n// with `none`.`\n\nfunction getTranslateValue(direction, node) {\n  var rect = node.getBoundingClientRect();\n  var transform;\n\n  if (node.fakeTransform) {\n    transform = node.fakeTransform;\n  } else {\n    var computedStyle = window.getComputedStyle(node);\n    transform = computedStyle.getPropertyValue('-webkit-transform') || computedStyle.getPropertyValue('transform');\n  }\n\n  var offsetX = 0;\n  var offsetY = 0;\n\n  if (transform && transform !== 'none' && typeof transform === 'string') {\n    var transformValues = transform.split('(')[1].split(')')[0].split(',');\n    offsetX = parseInt(transformValues[4], 10);\n    offsetY = parseInt(transformValues[5], 10);\n  }\n\n  if (direction === 'left') {\n    return \"translateX(\".concat(window.innerWidth, \"px) translateX(\").concat(offsetX - rect.left, \"px)\");\n  }\n\n  if (direction === 'right') {\n    return \"translateX(-\".concat(rect.left + rect.width - offsetX, \"px)\");\n  }\n\n  if (direction === 'up') {\n    return \"translateY(\".concat(window.innerHeight, \"px) translateY(\").concat(offsetY - rect.top, \"px)\");\n  } // direction === 'down'\n\n\n  return \"translateY(-\".concat(rect.top + rect.height - offsetY, \"px)\");\n}\n\nexport function setTranslateValue(direction, node) {\n  var transform = getTranslateValue(direction, node);\n\n  if (transform) {\n    node.style.webkitTransform = transform;\n    node.style.transform = transform;\n  }\n}\nvar defaultTimeout = {\n  enter: duration.enteringScreen,\n  exit: duration.leavingScreen\n};\n/**\n * The Slide transition is used by the [Drawer](/components/drawers/) component.\n * It uses [react-transition-group](https://github.com/reactjs/react-transition-group) internally.\n */\n\nvar Slide = /*#__PURE__*/React.forwardRef(function Slide(props, ref) {\n  var children = props.children,\n      _props$direction = props.direction,\n      direction = _props$direction === void 0 ? 'down' : _props$direction,\n      inProp = props.in,\n      onEnter = props.onEnter,\n      onEntered = props.onEntered,\n      onEntering = props.onEntering,\n      onExit = props.onExit,\n      onExited = props.onExited,\n      onExiting = props.onExiting,\n      style = props.style,\n      _props$timeout = props.timeout,\n      timeout = _props$timeout === void 0 ? defaultTimeout : _props$timeout,\n      _props$TransitionComp = props.TransitionComponent,\n      TransitionComponent = _props$TransitionComp === void 0 ? Transition : _props$TransitionComp,\n      other = _objectWithoutProperties(props, [\"children\", \"direction\", \"in\", \"onEnter\", \"onEntered\", \"onEntering\", \"onExit\", \"onExited\", \"onExiting\", \"style\", \"timeout\", \"TransitionComponent\"]);\n\n  var theme = useTheme();\n  var childrenRef = React.useRef(null);\n  /**\n   * used in cloneElement(children, { ref: handleRef })\n   */\n\n  var handleOwnRef = React.useCallback(function (instance) {\n    // #StrictMode ready\n    childrenRef.current = ReactDOM.findDOMNode(instance);\n  }, []);\n  var handleRefIntermediary = useForkRef(children.ref, handleOwnRef);\n  var handleRef = useForkRef(handleRefIntermediary, ref);\n\n  var normalizedTransitionCallback = function normalizedTransitionCallback(callback) {\n    return function (isAppearing) {\n      if (callback) {\n        // onEnterXxx and onExitXxx callbacks have a different arguments.length value.\n        if (isAppearing === undefined) {\n          callback(childrenRef.current);\n        } else {\n          callback(childrenRef.current, isAppearing);\n        }\n      }\n    };\n  };\n\n  var handleEnter = normalizedTransitionCallback(function (node, isAppearing) {\n    setTranslateValue(direction, node);\n    reflow(node);\n\n    if (onEnter) {\n      onEnter(node, isAppearing);\n    }\n  });\n  var handleEntering = normalizedTransitionCallback(function (node, isAppearing) {\n    var transitionProps = getTransitionProps({\n      timeout: timeout,\n      style: style\n    }, {\n      mode: 'enter'\n    });\n    node.style.webkitTransition = theme.transitions.create('-webkit-transform', _extends({}, transitionProps, {\n      easing: theme.transitions.easing.easeOut\n    }));\n    node.style.transition = theme.transitions.create('transform', _extends({}, transitionProps, {\n      easing: theme.transitions.easing.easeOut\n    }));\n    node.style.webkitTransform = 'none';\n    node.style.transform = 'none';\n\n    if (onEntering) {\n      onEntering(node, isAppearing);\n    }\n  });\n  var handleEntered = normalizedTransitionCallback(onEntered);\n  var handleExiting = normalizedTransitionCallback(onExiting);\n  var handleExit = normalizedTransitionCallback(function (node) {\n    var transitionProps = getTransitionProps({\n      timeout: timeout,\n      style: style\n    }, {\n      mode: 'exit'\n    });\n    node.style.webkitTransition = theme.transitions.create('-webkit-transform', _extends({}, transitionProps, {\n      easing: theme.transitions.easing.sharp\n    }));\n    node.style.transition = theme.transitions.create('transform', _extends({}, transitionProps, {\n      easing: theme.transitions.easing.sharp\n    }));\n    setTranslateValue(direction, node);\n\n    if (onExit) {\n      onExit(node);\n    }\n  });\n  var handleExited = normalizedTransitionCallback(function (node) {\n    // No need for transitions when the component is hidden\n    node.style.webkitTransition = '';\n    node.style.transition = '';\n\n    if (onExited) {\n      onExited(node);\n    }\n  });\n  var updatePosition = React.useCallback(function () {\n    if (childrenRef.current) {\n      setTranslateValue(direction, childrenRef.current);\n    }\n  }, [direction]);\n  React.useEffect(function () {\n    // Skip configuration where the position is screen size invariant.\n    if (inProp || direction === 'down' || direction === 'right') {\n      return undefined;\n    }\n\n    var handleResize = debounce(function () {\n      if (childrenRef.current) {\n        setTranslateValue(direction, childrenRef.current);\n      }\n    });\n    window.addEventListener('resize', handleResize);\n    return function () {\n      handleResize.clear();\n      window.removeEventListener('resize', handleResize);\n    };\n  }, [direction, inProp]);\n  React.useEffect(function () {\n    if (!inProp) {\n      // We need to update the position of the drawer when the direction change and\n      // when it's hidden.\n      updatePosition();\n    }\n  }, [inProp, updatePosition]);\n  return /*#__PURE__*/React.createElement(TransitionComponent, _extends({\n    nodeRef: childrenRef,\n    onEnter: handleEnter,\n    onEntered: handleEntered,\n    onEntering: handleEntering,\n    onExit: handleExit,\n    onExited: handleExited,\n    onExiting: handleExiting,\n    appear: true,\n    in: inProp,\n    timeout: timeout\n  }, other), function (state, childProps) {\n    return /*#__PURE__*/React.cloneElement(children, _extends({\n      ref: handleRef,\n      style: _extends({\n        visibility: state === 'exited' && !inProp ? 'hidden' : undefined\n      }, style, children.props.style)\n    }, childProps));\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? Slide.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * A single child content element.\n   */\n  children: elementAcceptingRef,\n\n  /**\n   * Direction the child node will enter from.\n   */\n  direction: PropTypes.oneOf(['down', 'left', 'right', 'up']),\n\n  /**\n   * If `true`, show the component; triggers the enter or exit animation.\n   */\n  in: PropTypes.bool,\n\n  /**\n   * @ignore\n   */\n  onEnter: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onEntered: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onEntering: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onExit: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onExited: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onExiting: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  style: PropTypes.object,\n\n  /**\n   * The duration for the transition, in milliseconds.\n   * You may specify a single timeout for all transitions, or individually with an object.\n   */\n  timeout: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({\n    appear: PropTypes.number,\n    enter: PropTypes.number,\n    exit: PropTypes.number\n  })])\n} : void 0;\nexport default Slide;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _createSvgIcon = _interopRequireDefault(require(\"./utils/createSvgIcon\"));\n\nvar _default = (0, _createSvgIcon.default)(_react.default.createElement(\"path\", {\n  d: \"M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z\"\n}), 'Tune');\n\nexports.default = _default;","import React from 'react';\nimport createSvgIcon from './utils/createSvgIcon';\nexport default createSvgIcon(React.createElement(\"path\", {\n  d: \"M7 10l5 5 5-5z\"\n}), 'ArrowDropDown');","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport React from 'react';\nimport SvgIcon from '@material-ui/core/SvgIcon';\nexport default function createSvgIcon(path, displayName) {\n  var Component = React.memo(React.forwardRef(function (props, ref) {\n    return React.createElement(SvgIcon, _extends({\n      ref: ref\n    }, props), path);\n  }));\n\n  if (process.env.NODE_ENV !== 'production') {\n    Component.displayName = \"\".concat(displayName, \"Icon\");\n  }\n\n  Component.muiName = SvgIcon.muiName;\n  return Component;\n}",";(function (globalScope) {\r\n  'use strict';\r\n\r\n\r\n  /*\r\n   *  decimal.js v10.2.1\r\n   *  An arbitrary-precision Decimal type for JavaScript.\r\n   *  https://github.com/MikeMcl/decimal.js\r\n   *  Copyright (c) 2020 Michael Mclaughlin <M8ch88l@gmail.com>\r\n   *  MIT Licence\r\n   */\r\n\r\n\r\n  // -----------------------------------  EDITABLE DEFAULTS  ------------------------------------ //\r\n\r\n\r\n    // The maximum exponent magnitude.\r\n    // The limit on the value of `toExpNeg`, `toExpPos`, `minE` and `maxE`.\r\n  var EXP_LIMIT = 9e15,                      // 0 to 9e15\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    MAX_DIGITS = 1e9,                        // 0 to 1e9\r\n\r\n    // Base conversion alphabet.\r\n    NUMERALS = '0123456789abcdef',\r\n\r\n    // The natural logarithm of 10 (1025 digits).\r\n    LN10 = '2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058',\r\n\r\n    // Pi (1025 digits).\r\n    PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789',\r\n\r\n\r\n    // The initial configuration properties of the Decimal constructor.\r\n    DEFAULTS = {\r\n\r\n      // These values must be integers within the stated ranges (inclusive).\r\n      // Most of these values can be changed at run-time using the `Decimal.config` method.\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 when rounding to `precision`.\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 modulo mode used when calculating the modulus: a mod n.\r\n      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n      // The remainder (r) is calculated as: r = a - n * q.\r\n      //\r\n      // UP         0 The remainder is positive if the dividend is negative, else is negative.\r\n      // DOWN       1 The remainder has the same sign as the dividend (JavaScript %).\r\n      // FLOOR      3 The remainder has the same sign as the divisor (Python %).\r\n      // HALF_EVEN  6 The IEEE 754 remainder function.\r\n      // EUCLID     9 Euclidian division. q = sign(n) * floor(a / abs(n)). Always positive.\r\n      //\r\n      // Truncated division (1), floored division (3), the IEEE 754 remainder (6), and Euclidian\r\n      // division (9) are commonly used for the modulus operation. The other rounding modes can also\r\n      // be used, but they may not give useful results.\r\n      modulo: 1,                             // 0 to 9\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 -EXP_LIMIT\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 EXP_LIMIT\r\n\r\n      // The minimum exponent value, beneath which underflow to zero occurs.\r\n      // JavaScript numbers: -324  (5e-324)\r\n      minE: -EXP_LIMIT,                      // -1 to -EXP_LIMIT\r\n\r\n      // The maximum exponent value, above which overflow to Infinity occurs.\r\n      // JavaScript numbers: 308  (1.7976931348623157e+308)\r\n      maxE: EXP_LIMIT,                       // 1 to EXP_LIMIT\r\n\r\n      // Whether to use cryptographically-secure random number generation, if available.\r\n      crypto: false                          // true/false\r\n    },\r\n\r\n\r\n  // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //\r\n\r\n\r\n    Decimal, inexact, noConflict, quadrant,\r\n    external = true,\r\n\r\n    decimalError = '[DecimalError] ',\r\n    invalidArgument = decimalError + 'Invalid argument: ',\r\n    precisionLimitExceeded = decimalError + 'Precision limit exceeded',\r\n    cryptoUnavailable = decimalError + 'crypto unavailable',\r\n\r\n    mathfloor = Math.floor,\r\n    mathpow = Math.pow,\r\n\r\n    isBinary = /^0b([01]+(\\.[01]*)?|\\.[01]+)(p[+-]?\\d+)?$/i,\r\n    isHex = /^0x([0-9a-f]+(\\.[0-9a-f]*)?|\\.[0-9a-f]+)(p[+-]?\\d+)?$/i,\r\n    isOctal = /^0o([0-7]+(\\.[0-7]*)?|\\.[0-7]+)(p[+-]?\\d+)?$/i,\r\n    isDecimal = /^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n\r\n    BASE = 1e7,\r\n    LOG_BASE = 7,\r\n    MAX_SAFE_INTEGER = 9007199254740991,\r\n\r\n    LN10_PRECISION = LN10.length - 1,\r\n    PI_PRECISION = PI.length - 1,\r\n\r\n    // Decimal.prototype object\r\n    P = { name: '[object Decimal]' };\r\n\r\n\r\n  // Decimal prototype methods\r\n\r\n\r\n  /*\r\n   *  absoluteValue             abs\r\n   *  ceil\r\n   *  comparedTo                cmp\r\n   *  cosine                    cos\r\n   *  cubeRoot                  cbrt\r\n   *  decimalPlaces             dp\r\n   *  dividedBy                 div\r\n   *  dividedToIntegerBy        divToInt\r\n   *  equals                    eq\r\n   *  floor\r\n   *  greaterThan               gt\r\n   *  greaterThanOrEqualTo      gte\r\n   *  hyperbolicCosine          cosh\r\n   *  hyperbolicSine            sinh\r\n   *  hyperbolicTangent         tanh\r\n   *  inverseCosine             acos\r\n   *  inverseHyperbolicCosine   acosh\r\n   *  inverseHyperbolicSine     asinh\r\n   *  inverseHyperbolicTangent  atanh\r\n   *  inverseSine               asin\r\n   *  inverseTangent            atan\r\n   *  isFinite\r\n   *  isInteger                 isInt\r\n   *  isNaN\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   *  [maximum]                 [max]\r\n   *  [minimum]                 [min]\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   *  round\r\n   *  sine                      sin\r\n   *  squareRoot                sqrt\r\n   *  tangent                   tan\r\n   *  times                     mul\r\n   *  toBinary\r\n   *  toDecimalPlaces           toDP\r\n   *  toExponential\r\n   *  toFixed\r\n   *  toFraction\r\n   *  toHexadecimal             toHex\r\n   *  toNearest\r\n   *  toNumber\r\n   *  toOctal\r\n   *  toPower                   pow\r\n   *  toPrecision\r\n   *  toSignificantDigits       toSD\r\n   *  toString\r\n   *  truncated                 trunc\r\n   *  valueOf                   toJSON\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 < 0) x.s = 1;\r\n    return finalise(x);\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 in the\r\n   * direction of positive Infinity.\r\n   *\r\n   */\r\n  P.ceil = function () {\r\n    return finalise(new this.constructor(this), this.e + 1, 2);\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   *   NaN  if the value of either Decimal is NaN.\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      xd = x.d,\r\n      yd = (y = new x.constructor(y)).d,\r\n      xs = x.s,\r\n      ys = y.s;\r\n\r\n    // Either NaN or ±Infinity?\r\n    if (!xd || !yd) {\r\n      return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;\r\n    }\r\n\r\n    // Either zero?\r\n    if (!xd[0] || !yd[0]) return xd[0] ? xs : yd[0] ? -ys : 0;\r\n\r\n    // Signs differ?\r\n    if (xs !== ys) return xs;\r\n\r\n    // Compare exponents.\r\n    if (x.e !== y.e) return x.e > y.e ^ xs < 0 ? 1 : -1;\r\n\r\n    xdL = xd.length;\r\n    ydL = yd.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 (xd[i] !== yd[i]) return xd[i] > yd[i] ^ xs < 0 ? 1 : -1;\r\n    }\r\n\r\n    // Compare lengths.\r\n    return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the cosine of the value in radians of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-1, 1]\r\n   *\r\n   * cos(0)         = 1\r\n   * cos(-0)        = 1\r\n   * cos(Infinity)  = NaN\r\n   * cos(-Infinity) = NaN\r\n   * cos(NaN)       = NaN\r\n   *\r\n   */\r\n  P.cosine = P.cos = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.d) return new Ctor(NaN);\r\n\r\n    // cos(0) = cos(-0) = 1\r\n    if (!x.d[0]) return new Ctor(1);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n    Ctor.rounding = 1;\r\n\r\n    x = cosine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(quadrant == 2 || quadrant == 3 ? x.neg() : x, pr, rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   *\r\n   * Return a new Decimal whose value is the cube root of the value of this Decimal, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   *  cbrt(0)  =  0\r\n   *  cbrt(-0) = -0\r\n   *  cbrt(1)  =  1\r\n   *  cbrt(-1) = -1\r\n   *  cbrt(N)  =  N\r\n   *  cbrt(-I) = -I\r\n   *  cbrt(I)  =  I\r\n   *\r\n   * Math.cbrt(x) = (x < 0 ? -Math.pow(-x, 1/3) : Math.pow(x, 1/3))\r\n   *\r\n   */\r\n  P.cubeRoot = P.cbrt = function () {\r\n    var e, m, n, r, rep, s, sd, t, t3, t3plusx,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n    external = false;\r\n\r\n    // Initial estimate.\r\n    s = x.s * mathpow(x.s * x, 1 / 3);\r\n\r\n     // Math.cbrt underflow/overflow?\r\n     // Pass x to Math.pow as integer, then adjust the exponent of the result.\r\n    if (!s || Math.abs(s) == 1 / 0) {\r\n      n = digitsToString(x.d);\r\n      e = x.e;\r\n\r\n      // Adjust n exponent so it is a multiple of 3 away from x exponent.\r\n      if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');\r\n      s = mathpow(n, 1 / 3);\r\n\r\n      // Rarely, e may be one less than the result exponent value.\r\n      e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 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      r.s = x.s;\r\n    } else {\r\n      r = new Ctor(s.toString());\r\n    }\r\n\r\n    sd = (e = Ctor.precision) + 3;\r\n\r\n    // Halley's method.\r\n    // TODO? Compare Newton's method.\r\n    for (;;) {\r\n      t = r;\r\n      t3 = t.times(t).times(t);\r\n      t3plusx = t3.plus(x);\r\n      r = divide(t3plusx.plus(x).times(t), t3plusx.plus(t3), sd + 2, 1);\r\n\r\n      // TODO? Replace with for-loop and checkRoundingDigits.\r\n      if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n        n = n.slice(sd - 3, sd + 1);\r\n\r\n        // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or 4999\r\n        // , i.e. approaching a rounding boundary, continue the iteration.\r\n        if (n == '9999' || !rep && 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          if (!rep) {\r\n            finalise(t, e + 1, 0);\r\n\r\n            if (t.times(t).times(t).eq(x)) {\r\n              r = t;\r\n              break;\r\n            }\r\n          }\r\n\r\n          sd += 4;\r\n          rep = 1;\r\n        } else {\r\n\r\n          // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n          // If not, then there are further digits and m will be truthy.\r\n          if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n            // Truncate to the first rounding digit.\r\n            finalise(r, e + 1, 1);\r\n            m = !r.times(r).times(r).eq(x);\r\n          }\r\n\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    external = true;\r\n\r\n    return finalise(r, e, Ctor.rounding, m);\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 w,\r\n      d = this.d,\r\n      n = NaN;\r\n\r\n    if (d) {\r\n      w = d.length - 1;\r\n      n = (w - mathfloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last word.\r\n      w = d[w];\r\n      if (w) for (; w % 10 == 0; w /= 10) n--;\r\n      if (n < 0) n = 0;\r\n    }\r\n\r\n    return n;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n / 0 = I\r\n   *  n / N = N\r\n   *  n / I = 0\r\n   *  0 / n = 0\r\n   *  0 / 0 = N\r\n   *  0 / N = N\r\n   *  0 / I = 0\r\n   *  N / n = N\r\n   *  N / 0 = N\r\n   *  N / N = N\r\n   *  N / I = N\r\n   *  I / n = I\r\n   *  I / 0 = I\r\n   *  I / N = N\r\n   *  I / I = N\r\n   *\r\n   * Return a new Decimal whose value is the value of this Decimal divided by `y`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\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`, rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.dividedToIntegerBy = P.divToInt = function (y) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n    return finalise(divide(x, new Ctor(y), 0, 1, 1), Ctor.precision, Ctor.rounding);\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) === 0;\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 in the\r\n   * direction of negative Infinity.\r\n   *\r\n   */\r\n  P.floor = function () {\r\n    return finalise(new this.constructor(this), this.e + 1, 3);\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    var k = this.cmp(y);\r\n    return k == 1 || k === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic cosine of the value in radians of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [1, Infinity]\r\n   *\r\n   * cosh(x) = 1 + x^2/2! + x^4/4! + x^6/6! + ...\r\n   *\r\n   * cosh(0)         = 1\r\n   * cosh(-0)        = 1\r\n   * cosh(Infinity)  = Infinity\r\n   * cosh(-Infinity) = Infinity\r\n   * cosh(NaN)       = NaN\r\n   *\r\n   *  x        time taken (ms)   result\r\n   * 1000      9                 9.8503555700852349694e+433\r\n   * 10000     25                4.4034091128314607936e+4342\r\n   * 100000    171               1.4033316802130615897e+43429\r\n   * 1000000   3817              1.5166076984010437725e+434294\r\n   * 10000000  abandoned after 2 minute wait\r\n   *\r\n   * TODO? Compare performance of cosh(x) = 0.5 * (exp(x) + exp(-x))\r\n   *\r\n   */\r\n  P.hyperbolicCosine = P.cosh = function () {\r\n    var k, n, pr, rm, len,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      one = new Ctor(1);\r\n\r\n    if (!x.isFinite()) return new Ctor(x.s ? 1 / 0 : NaN);\r\n    if (x.isZero()) return one;\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n    Ctor.rounding = 1;\r\n    len = x.d.length;\r\n\r\n    // Argument reduction: cos(4x) = 1 - 8cos^2(x) + 8cos^4(x) + 1\r\n    // i.e. cos(x) = 1 - cos^2(x/4)(8 - 8cos^2(x/4))\r\n\r\n    // Estimate the optimum number of times to use the argument reduction.\r\n    // TODO? Estimation reused from cosine() and may not be optimal here.\r\n    if (len < 32) {\r\n      k = Math.ceil(len / 3);\r\n      n = (1 / tinyPow(4, k)).toString();\r\n    } else {\r\n      k = 16;\r\n      n = '2.3283064365386962890625e-10';\r\n    }\r\n\r\n    x = taylorSeries(Ctor, 1, x.times(n), new Ctor(1), true);\r\n\r\n    // Reverse argument reduction\r\n    var cosh2_x,\r\n      i = k,\r\n      d8 = new Ctor(8);\r\n    for (; i--;) {\r\n      cosh2_x = x.times(x);\r\n      x = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));\r\n    }\r\n\r\n    return finalise(x, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic sine of the value in radians of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * sinh(x) = x + x^3/3! + x^5/5! + x^7/7! + ...\r\n   *\r\n   * sinh(0)         = 0\r\n   * sinh(-0)        = -0\r\n   * sinh(Infinity)  = Infinity\r\n   * sinh(-Infinity) = -Infinity\r\n   * sinh(NaN)       = NaN\r\n   *\r\n   * x        time taken (ms)\r\n   * 10       2 ms\r\n   * 100      5 ms\r\n   * 1000     14 ms\r\n   * 10000    82 ms\r\n   * 100000   886 ms            1.4033316802130615897e+43429\r\n   * 200000   2613 ms\r\n   * 300000   5407 ms\r\n   * 400000   8824 ms\r\n   * 500000   13026 ms          8.7080643612718084129e+217146\r\n   * 1000000  48543 ms\r\n   *\r\n   * TODO? Compare performance of sinh(x) = 0.5 * (exp(x) - exp(-x))\r\n   *\r\n   */\r\n  P.hyperbolicSine = P.sinh = function () {\r\n    var k, pr, rm, len,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n    Ctor.rounding = 1;\r\n    len = x.d.length;\r\n\r\n    if (len < 3) {\r\n      x = taylorSeries(Ctor, 2, x, x, true);\r\n    } else {\r\n\r\n      // Alternative argument reduction: sinh(3x) = sinh(x)(3 + 4sinh^2(x))\r\n      // i.e. sinh(x) = sinh(x/3)(3 + 4sinh^2(x/3))\r\n      // 3 multiplications and 1 addition\r\n\r\n      // Argument reduction: sinh(5x) = sinh(x)(5 + sinh^2(x)(20 + 16sinh^2(x)))\r\n      // i.e. sinh(x) = sinh(x/5)(5 + sinh^2(x/5)(20 + 16sinh^2(x/5)))\r\n      // 4 multiplications and 2 additions\r\n\r\n      // Estimate the optimum number of times to use the argument reduction.\r\n      k = 1.4 * Math.sqrt(len);\r\n      k = k > 16 ? 16 : k | 0;\r\n\r\n      x = x.times(1 / tinyPow(5, k));\r\n      x = taylorSeries(Ctor, 2, x, x, true);\r\n\r\n      // Reverse argument reduction\r\n      var sinh2_x,\r\n        d5 = new Ctor(5),\r\n        d16 = new Ctor(16),\r\n        d20 = new Ctor(20);\r\n      for (; k--;) {\r\n        sinh2_x = x.times(x);\r\n        x = x.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));\r\n      }\r\n    }\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(x, pr, rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic tangent of the value in radians of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-1, 1]\r\n   *\r\n   * tanh(x) = sinh(x) / cosh(x)\r\n   *\r\n   * tanh(0)         = 0\r\n   * tanh(-0)        = -0\r\n   * tanh(Infinity)  = 1\r\n   * tanh(-Infinity) = -1\r\n   * tanh(NaN)       = NaN\r\n   *\r\n   */\r\n  P.hyperbolicTangent = P.tanh = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(x.s);\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + 7;\r\n    Ctor.rounding = 1;\r\n\r\n    return divide(x.sinh(), x.cosh(), Ctor.precision = pr, Ctor.rounding = rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arccosine (inverse cosine) in radians of the value of\r\n   * this Decimal.\r\n   *\r\n   * Domain: [-1, 1]\r\n   * Range: [0, pi]\r\n   *\r\n   * acos(x) = pi/2 - asin(x)\r\n   *\r\n   * acos(0)       = pi/2\r\n   * acos(-0)      = pi/2\r\n   * acos(1)       = 0\r\n   * acos(-1)      = pi\r\n   * acos(1/2)     = pi/3\r\n   * acos(-1/2)    = 2*pi/3\r\n   * acos(|x| > 1) = NaN\r\n   * acos(NaN)     = NaN\r\n   *\r\n   */\r\n  P.inverseCosine = P.acos = function () {\r\n    var halfPi,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      k = x.abs().cmp(1),\r\n      pr = Ctor.precision,\r\n      rm = Ctor.rounding;\r\n\r\n    if (k !== -1) {\r\n      return k === 0\r\n        // |x| is 1\r\n        ? x.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0)\r\n        // |x| > 1 or x is NaN\r\n        : new Ctor(NaN);\r\n    }\r\n\r\n    if (x.isZero()) return getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n    // TODO? Special case acos(0.5) = pi/3 and acos(-0.5) = 2*pi/3\r\n\r\n    Ctor.precision = pr + 6;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.asin();\r\n    halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return halfPi.minus(x);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic cosine in radians of the\r\n   * value of this Decimal.\r\n   *\r\n   * Domain: [1, Infinity]\r\n   * Range: [0, Infinity]\r\n   *\r\n   * acosh(x) = ln(x + sqrt(x^2 - 1))\r\n   *\r\n   * acosh(x < 1)     = NaN\r\n   * acosh(NaN)       = NaN\r\n   * acosh(Infinity)  = Infinity\r\n   * acosh(-Infinity) = NaN\r\n   * acosh(0)         = NaN\r\n   * acosh(-0)        = NaN\r\n   * acosh(1)         = 0\r\n   * acosh(-1)        = NaN\r\n   *\r\n   */\r\n  P.inverseHyperbolicCosine = P.acosh = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (x.lte(1)) return new Ctor(x.eq(1) ? 0 : NaN);\r\n    if (!x.isFinite()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(Math.abs(x.e), x.sd()) + 4;\r\n    Ctor.rounding = 1;\r\n    external = false;\r\n\r\n    x = x.times(x).minus(1).sqrt().plus(x);\r\n\r\n    external = true;\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.ln();\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic sine in radians of the value\r\n   * of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * asinh(x) = ln(x + sqrt(x^2 + 1))\r\n   *\r\n   * asinh(NaN)       = NaN\r\n   * asinh(Infinity)  = Infinity\r\n   * asinh(-Infinity) = -Infinity\r\n   * asinh(0)         = 0\r\n   * asinh(-0)        = -0\r\n   *\r\n   */\r\n  P.inverseHyperbolicSine = P.asinh = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + 2 * Math.max(Math.abs(x.e), x.sd()) + 6;\r\n    Ctor.rounding = 1;\r\n    external = false;\r\n\r\n    x = x.times(x).plus(1).sqrt().plus(x);\r\n\r\n    external = true;\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.ln();\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic tangent in radians of the\r\n   * value of this Decimal.\r\n   *\r\n   * Domain: [-1, 1]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * atanh(x) = 0.5 * ln((1 + x) / (1 - x))\r\n   *\r\n   * atanh(|x| > 1)   = NaN\r\n   * atanh(NaN)       = NaN\r\n   * atanh(Infinity)  = NaN\r\n   * atanh(-Infinity) = NaN\r\n   * atanh(0)         = 0\r\n   * atanh(-0)        = -0\r\n   * atanh(1)         = Infinity\r\n   * atanh(-1)        = -Infinity\r\n   *\r\n   */\r\n  P.inverseHyperbolicTangent = P.atanh = function () {\r\n    var pr, rm, wpr, xsd,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(NaN);\r\n    if (x.e >= 0) return new Ctor(x.abs().eq(1) ? x.s / 0 : x.isZero() ? x : NaN);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    xsd = x.sd();\r\n\r\n    if (Math.max(xsd, pr) < 2 * -x.e - 1) return finalise(new Ctor(x), pr, rm, true);\r\n\r\n    Ctor.precision = wpr = xsd - x.e;\r\n\r\n    x = divide(x.plus(1), new Ctor(1).minus(x), wpr + pr, 1);\r\n\r\n    Ctor.precision = pr + 4;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.ln();\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.times(0.5);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arcsine (inverse sine) in radians of the value of this\r\n   * Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-pi/2, pi/2]\r\n   *\r\n   * asin(x) = 2*atan(x/(1 + sqrt(1 - x^2)))\r\n   *\r\n   * asin(0)       = 0\r\n   * asin(-0)      = -0\r\n   * asin(1/2)     = pi/6\r\n   * asin(-1/2)    = -pi/6\r\n   * asin(1)       = pi/2\r\n   * asin(-1)      = -pi/2\r\n   * asin(|x| > 1) = NaN\r\n   * asin(NaN)     = NaN\r\n   *\r\n   * TODO? Compare performance of Taylor series.\r\n   *\r\n   */\r\n  P.inverseSine = P.asin = function () {\r\n    var halfPi, k,\r\n      pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    k = x.abs().cmp(1);\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    if (k !== -1) {\r\n\r\n      // |x| is 1\r\n      if (k === 0) {\r\n        halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n        halfPi.s = x.s;\r\n        return halfPi;\r\n      }\r\n\r\n      // |x| > 1 or x is NaN\r\n      return new Ctor(NaN);\r\n    }\r\n\r\n    // TODO? Special case asin(1/2) = pi/6 and asin(-1/2) = -pi/6\r\n\r\n    Ctor.precision = pr + 6;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.div(new Ctor(1).minus(x.times(x)).sqrt().plus(1)).atan();\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return x.times(2);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arctangent (inverse tangent) in radians of the value\r\n   * of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-pi/2, pi/2]\r\n   *\r\n   * atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n   *\r\n   * atan(0)         = 0\r\n   * atan(-0)        = -0\r\n   * atan(1)         = pi/4\r\n   * atan(-1)        = -pi/4\r\n   * atan(Infinity)  = pi/2\r\n   * atan(-Infinity) = -pi/2\r\n   * atan(NaN)       = NaN\r\n   *\r\n   */\r\n  P.inverseTangent = P.atan = function () {\r\n    var i, j, k, n, px, t, r, wpr, x2,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      pr = Ctor.precision,\r\n      rm = Ctor.rounding;\r\n\r\n    if (!x.isFinite()) {\r\n      if (!x.s) return new Ctor(NaN);\r\n      if (pr + 4 <= PI_PRECISION) {\r\n        r = getPi(Ctor, pr + 4, rm).times(0.5);\r\n        r.s = x.s;\r\n        return r;\r\n      }\r\n    } else if (x.isZero()) {\r\n      return new Ctor(x);\r\n    } else if (x.abs().eq(1) && pr + 4 <= PI_PRECISION) {\r\n      r = getPi(Ctor, pr + 4, rm).times(0.25);\r\n      r.s = x.s;\r\n      return r;\r\n    }\r\n\r\n    Ctor.precision = wpr = pr + 10;\r\n    Ctor.rounding = 1;\r\n\r\n    // TODO? if (x >= 1 && pr <= PI_PRECISION) atan(x) = halfPi * x.s - atan(1 / x);\r\n\r\n    // Argument reduction\r\n    // Ensure |x| < 0.42\r\n    // atan(x) = 2 * atan(x / (1 + sqrt(1 + x^2)))\r\n\r\n    k = Math.min(28, wpr / LOG_BASE + 2 | 0);\r\n\r\n    for (i = k; i; --i) x = x.div(x.times(x).plus(1).sqrt().plus(1));\r\n\r\n    external = false;\r\n\r\n    j = Math.ceil(wpr / LOG_BASE);\r\n    n = 1;\r\n    x2 = x.times(x);\r\n    r = new Ctor(x);\r\n    px = x;\r\n\r\n    // atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n    for (; i !== -1;) {\r\n      px = px.times(x2);\r\n      t = r.minus(px.div(n += 2));\r\n\r\n      px = px.times(x2);\r\n      r = t.plus(px.div(n += 2));\r\n\r\n      if (r.d[j] !== void 0) for (i = j; r.d[i] === t.d[i] && i--;);\r\n    }\r\n\r\n    if (k) r = r.times(2 << (k - 1));\r\n\r\n    external = true;\r\n\r\n    return finalise(r, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is a finite number, otherwise return false.\r\n   *\r\n   */\r\n  P.isFinite = function () {\r\n    return !!this.d;\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.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this Decimal is NaN, otherwise return false.\r\n   *\r\n   */\r\n  P.isNaN = function () {\r\n    return !this.s;\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 or -0, otherwise return false.\r\n   *\r\n   */\r\n  P.isZero = function () {\r\n    return !!this.d && this.d[0] === 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, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * If no base is specified, return log[10](arg).\r\n   *\r\n   * log[base](arg) = ln(arg) / ln(base)\r\n   *\r\n   * The result will always be correctly rounded if the base of the log is 10, and 'almost always'\r\n   * otherwise:\r\n   *\r\n   * Depending on the rounding mode, the result may be incorrectly rounded if the first fifteen\r\n   * rounding digits are [49]99999999999999 or [50]00000000000000. In that case, the maximum error\r\n   * between the result and the correctly rounded result will be one ulp (unit in the last place).\r\n   *\r\n   * log[-b](a)       = NaN\r\n   * log[0](a)        = NaN\r\n   * log[1](a)        = NaN\r\n   * log[NaN](a)      = NaN\r\n   * log[Infinity](a) = NaN\r\n   * log[b](0)        = -Infinity\r\n   * log[b](-0)       = -Infinity\r\n   * log[b](-a)       = NaN\r\n   * log[b](1)        = 0\r\n   * log[b](Infinity) = Infinity\r\n   * log[b](NaN)      = NaN\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 isBase10, d, denominator, k, inf, num, sd, r,\r\n      arg = this,\r\n      Ctor = arg.constructor,\r\n      pr = Ctor.precision,\r\n      rm = Ctor.rounding,\r\n      guard = 5;\r\n\r\n    // Default base is 10.\r\n    if (base == null) {\r\n      base = new Ctor(10);\r\n      isBase10 = true;\r\n    } else {\r\n      base = new Ctor(base);\r\n      d = base.d;\r\n\r\n      // Return NaN if base is negative, or non-finite, or is 0 or 1.\r\n      if (base.s < 0 || !d || !d[0] || base.eq(1)) return new Ctor(NaN);\r\n\r\n      isBase10 = base.eq(10);\r\n    }\r\n\r\n    d = arg.d;\r\n\r\n    // Is arg negative, non-finite, 0 or 1?\r\n    if (arg.s < 0 || !d || !d[0] || arg.eq(1)) {\r\n      return new Ctor(d && !d[0] ? -1 / 0 : arg.s != 1 ? NaN : d ? 0 : 1 / 0);\r\n    }\r\n\r\n    // The result will have a non-terminating decimal expansion if base is 10 and arg is not an\r\n    // integer power of 10.\r\n    if (isBase10) {\r\n      if (d.length > 1) {\r\n        inf = true;\r\n      } else {\r\n        for (k = d[0]; k % 10 === 0;) k /= 10;\r\n        inf = k !== 1;\r\n      }\r\n    }\r\n\r\n    external = false;\r\n    sd = pr + guard;\r\n    num = naturalLogarithm(arg, sd);\r\n    denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n\r\n    // The result will have 5 rounding digits.\r\n    r = divide(num, denominator, sd, 1);\r\n\r\n    // If at a rounding boundary, i.e. the result's rounding digits are [49]9999 or [50]0000,\r\n    // calculate 10 further digits.\r\n    //\r\n    // If the result is known to have an infinite decimal expansion, repeat this until it is clear\r\n    // that the result is above or below the boundary. Otherwise, if after calculating the 10\r\n    // further digits, the last 14 are nines, round up and assume the result is exact.\r\n    // Also assume the result is exact if the last 14 are zero.\r\n    //\r\n    // Example of a result that will be incorrectly rounded:\r\n    // log[1048576](4503599627370502) = 2.60000000000000009610279511444746...\r\n    // The above result correctly rounded using ROUND_CEIL to 1 decimal place should be 2.7, but it\r\n    // will be given as 2.6 as there are 15 zeros immediately after the requested decimal place, so\r\n    // the exact result would be assumed to be 2.6, which rounded using ROUND_CEIL to 1 decimal\r\n    // place is still 2.6.\r\n    if (checkRoundingDigits(r.d, k = pr, rm)) {\r\n\r\n      do {\r\n        sd += 10;\r\n        num = naturalLogarithm(arg, sd);\r\n        denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n        r = divide(num, denominator, sd, 1);\r\n\r\n        if (!inf) {\r\n\r\n          // Check for 14 nines from the 2nd rounding digit, as the first may be 4.\r\n          if (+digitsToString(r.d).slice(k + 1, k + 15) + 1 == 1e14) {\r\n            r = finalise(r, pr + 1, 0);\r\n          }\r\n\r\n          break;\r\n        }\r\n      } while (checkRoundingDigits(r.d, k += 10, rm));\r\n    }\r\n\r\n    external = true;\r\n\r\n    return finalise(r, pr, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the maximum of the arguments and the value of this Decimal.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n  P.max = function () {\r\n    Array.prototype.push.call(arguments, this);\r\n    return maxOrMin(this.constructor, arguments, 'lt');\r\n  };\r\n   */\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the minimum of the arguments and the value of this Decimal.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n  P.min = function () {\r\n    Array.prototype.push.call(arguments, this);\r\n    return maxOrMin(this.constructor, arguments, 'gt');\r\n  };\r\n   */\r\n\r\n\r\n  /*\r\n   *  n - 0 = n\r\n   *  n - N = N\r\n   *  n - I = -I\r\n   *  0 - n = -n\r\n   *  0 - 0 = 0\r\n   *  0 - N = N\r\n   *  0 - I = -I\r\n   *  N - n = N\r\n   *  N - 0 = N\r\n   *  N - N = N\r\n   *  N - I = N\r\n   *  I - n = I\r\n   *  I - 0 = I\r\n   *  I - N = N\r\n   *  I - I = N\r\n   *\r\n   * Return a new Decimal whose value is the value of this Decimal minus `y`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.minus = P.sub = function (y) {\r\n    var d, e, i, j, k, len, pr, rm, xd, xe, xLTy, yd,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    y = new Ctor(y);\r\n\r\n    // If either is not finite...\r\n    if (!x.d || !y.d) {\r\n\r\n      // Return NaN if either is NaN.\r\n      if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n      // Return y negated if x is finite and y is ±Infinity.\r\n      else if (x.d) y.s = -y.s;\r\n\r\n      // Return x if y is finite and x is ±Infinity.\r\n      // Return x if both are ±Infinity with different signs.\r\n      // Return NaN if both are ±Infinity with the same sign.\r\n      else y = new Ctor(y.d || x.s !== y.s ? x : NaN);\r\n\r\n      return y;\r\n    }\r\n\r\n    // If signs differ...\r\n    if (x.s != y.s) {\r\n      y.s = -y.s;\r\n      return x.plus(y);\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    // If either is zero...\r\n    if (!xd[0] || !yd[0]) {\r\n\r\n      // Return y negated if x is zero and y is non-zero.\r\n      if (yd[0]) y.s = -y.s;\r\n\r\n      // Return x if y is zero and x is non-zero.\r\n      else if (xd[0]) y = new Ctor(x);\r\n\r\n      // Return zero if both are zero.\r\n      // From IEEE 754 (2008) 6.3: 0 - 0 = -0 - -0 = -0 when rounding to -Infinity.\r\n      else return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n      return external ? finalise(y, pr, rm) : y;\r\n    }\r\n\r\n    // x and y are finite, non-zero numbers with the same sign.\r\n\r\n    // Calculate base 1e7 exponents.\r\n    e = mathfloor(y.e / LOG_BASE);\r\n    xe = mathfloor(x.e / LOG_BASE);\r\n\r\n    xd = xd.slice();\r\n    k = xe - e;\r\n\r\n    // If base 1e7 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\r\n      // zeros needing to be prepended, but this can be avoided while still ensuring correct\r\n      // rounding by 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\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(rm === 3 ? -0 : 0);\r\n\r\n    y.d = xd;\r\n    y.e = getBase10Exponent(xd, e);\r\n\r\n    return external ? finalise(y, pr, rm) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   *   n % 0 =  N\r\n   *   n % N =  N\r\n   *   n % I =  n\r\n   *   0 % n =  0\r\n   *  -0 % n = -0\r\n   *   0 % 0 =  N\r\n   *   0 % N =  N\r\n   *   0 % I =  0\r\n   *   N % n =  N\r\n   *   N % 0 =  N\r\n   *   N % N =  N\r\n   *   N % I =  N\r\n   *   I % n =  N\r\n   *   I % 0 =  N\r\n   *   I % N =  N\r\n   *   I % I =  N\r\n   *\r\n   * Return a new Decimal whose value is the value of this Decimal modulo `y`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * The result depends on the modulo mode.\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\r\n    y = new Ctor(y);\r\n\r\n    // Return NaN if x is ±Infinity or NaN, or y is NaN or ±0.\r\n    if (!x.d || !y.s || y.d && !y.d[0]) return new Ctor(NaN);\r\n\r\n    // Return x if y is ±Infinity or x is ±0.\r\n    if (!y.d || x.d && !x.d[0]) {\r\n      return finalise(new Ctor(x), Ctor.precision, Ctor.rounding);\r\n    }\r\n\r\n    // Prevent rounding of intermediate calculations.\r\n    external = false;\r\n\r\n    if (Ctor.modulo == 9) {\r\n\r\n      // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n      // result = x - q * y    where  0 <= result < abs(y)\r\n      q = divide(x, y.abs(), 0, 3, 1);\r\n      q.s *= y.s;\r\n    } else {\r\n      q = divide(x, y, 0, Ctor.modulo, 1);\r\n    }\r\n\r\n    q = q.times(y);\r\n\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, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.naturalExponential = P.exp = function () {\r\n    return naturalExponential(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   * rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.naturalLogarithm = P.ln = function () {\r\n    return naturalLogarithm(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;\r\n    return finalise(x);\r\n  };\r\n\r\n\r\n  /*\r\n   *  n + 0 = n\r\n   *  n + N = N\r\n   *  n + I = I\r\n   *  0 + n = n\r\n   *  0 + 0 = 0\r\n   *  0 + N = N\r\n   *  0 + I = I\r\n   *  N + n = N\r\n   *  N + 0 = N\r\n   *  N + N = N\r\n   *  N + I = N\r\n   *  I + n = I\r\n   *  I + 0 = I\r\n   *  I + N = N\r\n   *  I + I = I\r\n   *\r\n   * Return a new Decimal whose value is the value of this Decimal plus `y`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   */\r\n  P.plus = P.add = function (y) {\r\n    var carry, d, e, i, k, len, pr, rm, xd, yd,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    y = new Ctor(y);\r\n\r\n    // If either is not finite...\r\n    if (!x.d || !y.d) {\r\n\r\n      // Return NaN if either is NaN.\r\n      if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n      // Return x if y is finite and x is ±Infinity.\r\n      // Return x if both are ±Infinity with the same sign.\r\n      // Return NaN if both are ±Infinity with different signs.\r\n      // Return y if x is finite and y is ±Infinity.\r\n      else if (!x.d) y = new Ctor(y.d || x.s === y.s ? x : NaN);\r\n\r\n      return y;\r\n    }\r\n\r\n     // If signs differ...\r\n    if (x.s != y.s) {\r\n      y.s = -y.s;\r\n      return x.minus(y);\r\n    }\r\n\r\n    xd = x.d;\r\n    yd = y.d;\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    // If either is zero...\r\n    if (!xd[0] || !yd[0]) {\r\n\r\n      // Return x if y is zero.\r\n      // Return y if y is non-zero.\r\n      if (!yd[0]) y = new Ctor(x);\r\n\r\n      return external ? finalise(y, pr, rm) : y;\r\n    }\r\n\r\n    // x and y are finite, non-zero numbers with the same sign.\r\n\r\n    // Calculate base 1e7 exponents.\r\n    k = mathfloor(x.e / LOG_BASE);\r\n    e = mathfloor(y.e / LOG_BASE);\r\n\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\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 = getBase10Exponent(xd, e);\r\n\r\n    return external ? finalise(y, pr, rm) : 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 k,\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    if (x.d) {\r\n      k = getPrecision(x.d);\r\n      if (z && x.e + 1 > k) k = x.e + 1;\r\n    } else {\r\n      k = NaN;\r\n    }\r\n\r\n    return k;\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.round = function () {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    return finalise(new Ctor(x), x.e + 1, Ctor.rounding);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the sine of the value in radians of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-1, 1]\r\n   *\r\n   * sin(x) = x - x^3/3! + x^5/5! - ...\r\n   *\r\n   * sin(0)         = 0\r\n   * sin(-0)        = -0\r\n   * sin(Infinity)  = NaN\r\n   * sin(-Infinity) = NaN\r\n   * sin(NaN)       = NaN\r\n   *\r\n   */\r\n  P.sine = P.sin = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(NaN);\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n    Ctor.rounding = 1;\r\n\r\n    x = sine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(quadrant > 2 ? x.neg() : x, pr, rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of this Decimal, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   *  sqrt(-n) =  N\r\n   *  sqrt(N)  =  N\r\n   *  sqrt(-I) =  N\r\n   *  sqrt(I)  =  I\r\n   *  sqrt(0)  =  0\r\n   *  sqrt(-0) = -0\r\n   *\r\n   */\r\n  P.squareRoot = P.sqrt = function () {\r\n    var m, n, sd, r, rep, t,\r\n      x = this,\r\n      d = x.d,\r\n      e = x.e,\r\n      s = x.s,\r\n      Ctor = x.constructor;\r\n\r\n    // Negative/NaN/Infinity/zero?\r\n    if (s !== 1 || !d || !d[0]) {\r\n      return new Ctor(!s || s < 0 && (!d || d[0]) ? NaN : d ? x : 1 / 0);\r\n    }\r\n\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(d);\r\n\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    sd = (e = Ctor.precision) + 3;\r\n\r\n    // Newton-Raphson iteration.\r\n    for (;;) {\r\n      t = r;\r\n      r = t.plus(divide(x, t, sd + 2, 1)).times(0.5);\r\n\r\n      // TODO? Replace with for-loop and checkRoundingDigits.\r\n      if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n        n = n.slice(sd - 3, sd + 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 (n == '9999' || !rep && 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          if (!rep) {\r\n            finalise(t, e + 1, 0);\r\n\r\n            if (t.times(t).eq(x)) {\r\n              r = t;\r\n              break;\r\n            }\r\n          }\r\n\r\n          sd += 4;\r\n          rep = 1;\r\n        } else {\r\n\r\n          // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n          // If not, then there are further digits and m will be truthy.\r\n          if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n            // Truncate to the first rounding digit.\r\n            finalise(r, e + 1, 1);\r\n            m = !r.times(r).eq(x);\r\n          }\r\n\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    external = true;\r\n\r\n    return finalise(r, e, Ctor.rounding, m);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the tangent of the value in radians of this Decimal.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-Infinity, Infinity]\r\n   *\r\n   * tan(0)         = 0\r\n   * tan(-0)        = -0\r\n   * tan(Infinity)  = NaN\r\n   * tan(-Infinity) = NaN\r\n   * tan(NaN)       = NaN\r\n   *\r\n   */\r\n  P.tangent = P.tan = function () {\r\n    var pr, rm,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (!x.isFinite()) return new Ctor(NaN);\r\n    if (x.isZero()) return new Ctor(x);\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n    Ctor.precision = pr + 10;\r\n    Ctor.rounding = 1;\r\n\r\n    x = x.sin();\r\n    x.s = 1;\r\n    x = divide(x, new Ctor(1).minus(x.times(x)).sqrt(), pr + 10, 0);\r\n\r\n    Ctor.precision = pr;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(quadrant == 2 || quadrant == 4 ? x.neg() : x, pr, rm, true);\r\n  };\r\n\r\n\r\n  /*\r\n   *  n * 0 = 0\r\n   *  n * N = N\r\n   *  n * I = I\r\n   *  0 * n = 0\r\n   *  0 * 0 = 0\r\n   *  0 * N = N\r\n   *  0 * I = N\r\n   *  N * n = N\r\n   *  N * 0 = N\r\n   *  N * N = N\r\n   *  N * I = N\r\n   *  I * n = I\r\n   *  I * 0 = N\r\n   *  I * N = N\r\n   *  I * I = I\r\n   *\r\n   * Return a new Decimal whose value is this Decimal times `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\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    y.s *= x.s;\r\n\r\n     // If either is NaN, ±Infinity or ±0...\r\n    if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n      return new Ctor(!y.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd\r\n\r\n        // Return NaN if either is NaN.\r\n        // Return NaN if x is ±0 and y is ±Infinity, or y is ±0 and x is ±Infinity.\r\n        ? NaN\r\n\r\n        // Return ±Infinity if either is ±Infinity.\r\n        // Return ±0 if either is ±0.\r\n        : !xd || !yd ? y.s / 0 : y.s * 0);\r\n    }\r\n\r\n    e = mathfloor(x.e / LOG_BASE) + mathfloor(y.e / LOG_BASE);\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 = getBase10Exponent(r, e);\r\n\r\n    return external ? finalise(y, Ctor.precision, Ctor.rounding) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal in base 2, round to `sd` significant\r\n   * digits using rounding mode `rm`.\r\n   *\r\n   * If the optional `sd` argument is present then return binary exponential 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.toBinary = function (sd, rm) {\r\n    return toStringBinary(this, 2, sd, rm);\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 finalise(x, dp + x.e + 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 = finiteToString(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 = finalise(new Ctor(x), dp + 1, rm);\r\n      str = finiteToString(x, true, dp + 1);\r\n    }\r\n\r\n    return x.isNeg() && !x.isZero() ? '-' + str : 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) {\r\n      str = finiteToString(x);\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      y = finalise(new Ctor(x), dp + x.e + 1, rm);\r\n      str = finiteToString(y, false, dp + y.e + 1);\r\n    }\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 an array representing the value of this Decimal as a simple fraction with an integer\r\n   * numerator and an integer denominator.\r\n   *\r\n   * The denominator will be a positive non-zero value less than or equal to the specified maximum\r\n   * denominator. If a maximum denominator is not specified, the denominator will be the lowest\r\n   * value necessary to represent the number exactly.\r\n   *\r\n   * [maxD] {number|string|Decimal} Maximum denominator. Integer >= 1 and < Infinity.\r\n   *\r\n   */\r\n  P.toFraction = function (maxD) {\r\n    var d, d0, d1, d2, e, k, n, n0, n1, pr, q, r,\r\n      x = this,\r\n      xd = x.d,\r\n      Ctor = x.constructor;\r\n\r\n    if (!xd) return new Ctor(x);\r\n\r\n    n1 = d0 = new Ctor(1);\r\n    d1 = n0 = new Ctor(0);\r\n\r\n    d = new Ctor(d1);\r\n    e = d.e = getPrecision(xd) - x.e - 1;\r\n    k = e % LOG_BASE;\r\n    d.d[0] = mathpow(10, k < 0 ? LOG_BASE + k : k);\r\n\r\n    if (maxD == null) {\r\n\r\n      // d is 10**e, the minimum max-denominator needed.\r\n      maxD = e > 0 ? d : n1;\r\n    } else {\r\n      n = new Ctor(maxD);\r\n      if (!n.isInt() || n.lt(n1)) throw Error(invalidArgument + n);\r\n      maxD = n.gt(d) ? (e > 0 ? d : n1) : n;\r\n    }\r\n\r\n    external = false;\r\n    n = new Ctor(digitsToString(xd));\r\n    pr = Ctor.precision;\r\n    Ctor.precision = e = xd.length * LOG_BASE * 2;\r\n\r\n    for (;;)  {\r\n      q = divide(n, d, 0, 1, 1);\r\n      d2 = d0.plus(q.times(d1));\r\n      if (d2.cmp(maxD) == 1) break;\r\n      d0 = d1;\r\n      d1 = d2;\r\n      d2 = n1;\r\n      n1 = n0.plus(q.times(d2));\r\n      n0 = d2;\r\n      d2 = d;\r\n      d = n.minus(q.times(d2));\r\n      n = d2;\r\n    }\r\n\r\n    d2 = divide(maxD.minus(d0), d1, 0, 1, 1);\r\n    n0 = n0.plus(d2.times(n1));\r\n    d0 = d0.plus(d2.times(d1));\r\n    n0.s = n1.s = x.s;\r\n\r\n    // Determine which fraction is closer to x, n0/d0 or n1/d1?\r\n    r = divide(n1, d1, e, 1).minus(x).abs().cmp(divide(n0, d0, e, 1).minus(x).abs()) < 1\r\n        ? [n1, d1] : [n0, d0];\r\n\r\n    Ctor.precision = pr;\r\n    external = true;\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 in base 16, round to `sd` significant\r\n   * digits using rounding mode `rm`.\r\n   *\r\n   * If the optional `sd` argument is present then return binary exponential 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.toHexadecimal = P.toHex = function (sd, rm) {\r\n    return toStringBinary(this, 16, sd, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding\r\n   * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.\r\n   *\r\n   * The return value will always have the same sign as this Decimal, unless either this Decimal\r\n   * or `y` is NaN, in which case the return value will be also be NaN.\r\n   *\r\n   * The return value is not affected by the value of `precision`.\r\n   *\r\n   * y {number|string|Decimal} The magnitude to round to a multiple of.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * 'toNearest() rounding mode not an integer: {rm}'\r\n   * 'toNearest() rounding mode out of range: {rm}'\r\n   *\r\n   */\r\n  P.toNearest = function (y, rm) {\r\n    var x = this,\r\n      Ctor = x.constructor;\r\n\r\n    x = new Ctor(x);\r\n\r\n    if (y == null) {\r\n\r\n      // If x is not finite, return x.\r\n      if (!x.d) return x;\r\n\r\n      y = new Ctor(1);\r\n      rm = Ctor.rounding;\r\n    } else {\r\n      y = new Ctor(y);\r\n      if (rm === void 0) {\r\n        rm = Ctor.rounding;\r\n      } else {\r\n        checkInt32(rm, 0, 8);\r\n      }\r\n\r\n      // If x is not finite, return x if y is not NaN, else NaN.\r\n      if (!x.d) return y.s ? x : y;\r\n\r\n      // If y is not finite, return Infinity with the sign of x if y is Infinity, else NaN.\r\n      if (!y.d) {\r\n        if (y.s) y.s = x.s;\r\n        return y;\r\n      }\r\n    }\r\n\r\n    // If y is not zero, calculate the nearest multiple of y to x.\r\n    if (y.d[0]) {\r\n      external = false;\r\n      x = divide(x, y, 0, rm, 1).times(y);\r\n      external = true;\r\n      finalise(x);\r\n\r\n    // If y is zero, return zero with the sign of x.\r\n    } else {\r\n      y.s = x.s;\r\n      x = y;\r\n    }\r\n\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the value of this Decimal converted to a number primitive.\r\n   * Zero keeps its sign.\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 string representing the value of this Decimal in base 8, round to `sd` significant\r\n   * digits using rounding mode `rm`.\r\n   *\r\n   * If the optional `sd` argument is present then return binary exponential 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.toOctal = function (sd, rm) {\r\n    return toStringBinary(this, 8, sd, rm);\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`, rounded\r\n   * to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * ECMAScript compliant.\r\n   *\r\n   *   pow(x, NaN)                           = NaN\r\n   *   pow(x, ±0)                            = 1\r\n\r\n   *   pow(NaN, non-zero)                    = NaN\r\n   *   pow(abs(x) > 1, +Infinity)            = +Infinity\r\n   *   pow(abs(x) > 1, -Infinity)            = +0\r\n   *   pow(abs(x) == 1, ±Infinity)           = NaN\r\n   *   pow(abs(x) < 1, +Infinity)            = +0\r\n   *   pow(abs(x) < 1, -Infinity)            = +Infinity\r\n   *   pow(+Infinity, y > 0)                 = +Infinity\r\n   *   pow(+Infinity, y < 0)                 = +0\r\n   *   pow(-Infinity, odd integer > 0)       = -Infinity\r\n   *   pow(-Infinity, even integer > 0)      = +Infinity\r\n   *   pow(-Infinity, odd integer < 0)       = -0\r\n   *   pow(-Infinity, even integer < 0)      = +0\r\n   *   pow(+0, y > 0)                        = +0\r\n   *   pow(+0, y < 0)                        = +Infinity\r\n   *   pow(-0, odd integer > 0)              = -0\r\n   *   pow(-0, even integer > 0)             = +0\r\n   *   pow(-0, odd integer < 0)              = -Infinity\r\n   *   pow(-0, even integer < 0)             = +Infinity\r\n   *   pow(finite x < 0, finite non-integer) = NaN\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   * Assuming the first 15 rounding digits are each equally likely to be any digit 0-9, the\r\n   * probability of an incorrectly rounded result\r\n   * P([49]9{14} | [50]0{14}) = 2 * 0.2 * 10^-14 = 4e-15 = 1/2.5e+14\r\n   * i.e. 1 in 250,000,000,000,000\r\n   *\r\n   * If a result is incorrectly rounded the maximum error will be 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, rm, s,\r\n      x = this,\r\n      Ctor = x.constructor,\r\n      yn = +(y = new Ctor(y));\r\n\r\n    // Either ±Infinity, NaN or ±0?\r\n    if (!x.d || !y.d || !x.d[0] || !y.d[0]) return new Ctor(mathpow(+x, yn));\r\n\r\n    x = new Ctor(x);\r\n\r\n    if (x.eq(1)) return x;\r\n\r\n    pr = Ctor.precision;\r\n    rm = Ctor.rounding;\r\n\r\n    if (y.eq(1)) return finalise(x, pr, rm);\r\n\r\n    // y exponent\r\n    e = mathfloor(y.e / LOG_BASE);\r\n\r\n    // If y is a small integer use the 'exponentiation by squaring' algorithm.\r\n    if (e >= y.d.length - 1 && (k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {\r\n      r = intPow(Ctor, x, k, pr);\r\n      return y.s < 0 ? new Ctor(1).div(r) : finalise(r, pr, rm);\r\n    }\r\n\r\n    s = x.s;\r\n\r\n    // if x is negative\r\n    if (s < 0) {\r\n\r\n      // if y is not an integer\r\n      if (e < y.d.length - 1) return new Ctor(NaN);\r\n\r\n      // Result is positive if x is negative and the last digit of integer y is even.\r\n      if ((y.d[e] & 1) == 0) s = 1;\r\n\r\n      // if x.eq(-1)\r\n      if (x.e == 0 && x.d[0] == 1 && x.d.length == 1) {\r\n        x.s = s;\r\n        return x;\r\n      }\r\n    }\r\n\r\n    // Estimate result exponent.\r\n    // x^y = 10^e,  where e = y * log10(x)\r\n    // log10(x) = log10(x_significand) + x_exponent\r\n    // log10(x_significand) = ln(x_significand) / ln(10)\r\n    k = mathpow(+x, yn);\r\n    e = k == 0 || !isFinite(k)\r\n      ? mathfloor(yn * (Math.log('0.' + digitsToString(x.d)) / Math.LN10 + x.e + 1))\r\n      : new Ctor(k + '').e;\r\n\r\n    // Exponent estimate may be incorrect e.g. x: 0.999999999999999999, y: 2.29, e: 0, r.e: -1.\r\n\r\n    // Overflow/underflow?\r\n    if (e > Ctor.maxE + 1 || e < Ctor.minE - 1) return new Ctor(e > 0 ? s / 0 : 0);\r\n\r\n    external = false;\r\n    Ctor.rounding = x.s = 1;\r\n\r\n    // Estimate the extra guard digits needed to ensure five correct rounding digits from\r\n    // naturalLogarithm(x). Example of failure without these extra digits (precision: 10):\r\n    // new Decimal(2.32456).pow('2087987436534566.46411')\r\n    // should be 1.162377823e+764914905173815, but is 1.162355823e+764914905173815\r\n    k = Math.min(12, (e + '').length);\r\n\r\n    // r = x^y = exp(y*ln(x))\r\n    r = naturalExponential(y.times(naturalLogarithm(x, pr + k)), pr);\r\n\r\n    // r may be Infinity, e.g. (0.9999999999999999).pow(-1e+40)\r\n    if (r.d) {\r\n\r\n      // Truncate to the required precision plus five rounding digits.\r\n      r = finalise(r, pr + 5, 1);\r\n\r\n      // If the rounding digits are [49]9999 or [50]0000 increase the precision by 10 and recalculate\r\n      // the result.\r\n      if (checkRoundingDigits(r.d, pr, rm)) {\r\n        e = pr + 10;\r\n\r\n        // Truncate to the increased precision plus five rounding digits.\r\n        r = finalise(naturalExponential(y.times(naturalLogarithm(x, e + k)), e), e + 5, 1);\r\n\r\n        // Check for 14 nines from the 2nd rounding digit (the first rounding digit may be 4 or 9).\r\n        if (+digitsToString(r.d).slice(pr + 1, pr + 15) + 1 == 1e14) {\r\n          r = finalise(r, pr + 1, 0);\r\n        }\r\n      }\r\n    }\r\n\r\n    r.s = s;\r\n    external = true;\r\n    Ctor.rounding = rm;\r\n\r\n    return finalise(r, pr, rm);\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 str,\r\n      x = this,\r\n      Ctor = x.constructor;\r\n\r\n    if (sd === void 0) {\r\n      str = finiteToString(x, x.e <= Ctor.toExpNeg || x.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 = finalise(new Ctor(x), sd, rm);\r\n      str = finiteToString(x, sd <= x.e || x.e <= Ctor.toExpNeg, sd);\r\n    }\r\n\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 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   * 'toSD() digits out of range: {sd}'\r\n   * 'toSD() digits not an integer: {sd}'\r\n   * 'toSD() rounding mode not an integer: {rm}'\r\n   * 'toSD() rounding mode out of range: {rm}'\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 finalise(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 = function () {\r\n    var x = this,\r\n      Ctor = x.constructor,\r\n      str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\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 truncated to a whole number.\r\n   *\r\n   */\r\n  P.truncated = P.trunc = function () {\r\n    return finalise(new this.constructor(this), this.e + 1, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this Decimal.\r\n   * Unlike `toString`, negative zero will include the minus sign.\r\n   *\r\n   */\r\n  P.valueOf = P.toJSON = function () {\r\n    var x = this,\r\n      Ctor = x.constructor,\r\n      str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n    return x.isNeg() ? '-' + str : str;\r\n  };\r\n\r\n\r\n  /*\r\n  // Add aliases to match BigDecimal method names.\r\n  // P.add = P.plus;\r\n  P.subtract = P.minus;\r\n  P.multiply = P.times;\r\n  P.divide = P.div;\r\n  P.remainder = P.mod;\r\n  P.compareTo = P.cmp;\r\n  P.negate = P.neg;\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   *  digitsToString           P.cubeRoot, P.logarithm, P.squareRoot, P.toFraction, P.toPower,\r\n   *                           finiteToString, naturalExponential, naturalLogarithm\r\n   *  checkInt32               P.toDecimalPlaces, P.toExponential, P.toFixed, P.toNearest,\r\n   *                           P.toPrecision, P.toSignificantDigits, toStringBinary, random\r\n   *  checkRoundingDigits      P.logarithm, P.toPower, naturalExponential, naturalLogarithm\r\n   *  convertBase              toStringBinary, parseOther\r\n   *  cos                      P.cos\r\n   *  divide                   P.atanh, P.cubeRoot, P.dividedBy, P.dividedToIntegerBy,\r\n   *                           P.logarithm, P.modulo, P.squareRoot, P.tan, P.tanh, P.toFraction,\r\n   *                           P.toNearest, toStringBinary, naturalExponential, naturalLogarithm,\r\n   *                           taylorSeries, atan2, parseOther\r\n   *  finalise                 P.absoluteValue, P.atan, P.atanh, P.ceil, P.cos, P.cosh,\r\n   *                           P.cubeRoot, P.dividedToIntegerBy, P.floor, P.logarithm, P.minus,\r\n   *                           P.modulo, P.negated, P.plus, P.round, P.sin, P.sinh, P.squareRoot,\r\n   *                           P.tan, P.times, P.toDecimalPlaces, P.toExponential, P.toFixed,\r\n   *                           P.toNearest, P.toPower, P.toPrecision, P.toSignificantDigits,\r\n   *                           P.truncated, divide, getLn10, getPi, naturalExponential,\r\n   *                           naturalLogarithm, ceil, floor, round, trunc\r\n   *  finiteToString           P.toExponential, P.toFixed, P.toPrecision, P.toString, P.valueOf,\r\n   *                           toStringBinary\r\n   *  getBase10Exponent        P.minus, P.plus, P.times, parseOther\r\n   *  getLn10                  P.logarithm, naturalLogarithm\r\n   *  getPi                    P.acos, P.asin, P.atan, toLessThanHalfPi, atan2\r\n   *  getPrecision             P.precision, P.toFraction\r\n   *  getZeroString            digitsToString, finiteToString\r\n   *  intPow                   P.toPower, parseOther\r\n   *  isOdd                    toLessThanHalfPi\r\n   *  maxOrMin                 max, min\r\n   *  naturalExponential       P.naturalExponential, P.toPower\r\n   *  naturalLogarithm         P.acosh, P.asinh, P.atanh, P.logarithm, P.naturalLogarithm,\r\n   *                           P.toPower, naturalExponential\r\n   *  nonFiniteToString        finiteToString, toStringBinary\r\n   *  parseDecimal             Decimal\r\n   *  parseOther               Decimal\r\n   *  sin                      P.sin\r\n   *  taylorSeries             P.cosh, P.sinh, cos, sin\r\n   *  toLessThanHalfPi         P.cos, P.sin\r\n   *  toStringBinary           P.toBinary, P.toHexadecimal, P.toOctal\r\n   *  truncate                 intPow\r\n   *\r\n   *  Throws:                  P.logarithm, P.precision, P.toFraction, checkInt32, getLn10, getPi,\r\n   *                           naturalLogarithm, config, parseOther, random, Decimal\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  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  /*\r\n   * Check 5 rounding digits if `repeating` is null, 4 otherwise.\r\n   * `repeating == null` if caller is `log` or `pow`,\r\n   * `repeating != null` if caller is `naturalLogarithm` or `naturalExponential`.\r\n   */\r\n  function checkRoundingDigits(d, i, rm, repeating) {\r\n    var di, k, r, rd;\r\n\r\n    // Get the length of the first word of the array d.\r\n    for (k = d[0]; k >= 10; k /= 10) --i;\r\n\r\n    // Is the rounding digit in the first word of d?\r\n    if (--i < 0) {\r\n      i += LOG_BASE;\r\n      di = 0;\r\n    } else {\r\n      di = Math.ceil((i + 1) / LOG_BASE);\r\n      i %= LOG_BASE;\r\n    }\r\n\r\n    // i is the index (0 - 6) of the rounding digit.\r\n    // E.g. if within the word 3487563 the first rounding digit is 5,\r\n    // then i = 4, k = 1000, rd = 3487563 % 1000 = 563\r\n    k = mathpow(10, LOG_BASE - i);\r\n    rd = d[di] % k | 0;\r\n\r\n    if (repeating == null) {\r\n      if (i < 3) {\r\n        if (i == 0) rd = rd / 100 | 0;\r\n        else if (i == 1) rd = rd / 10 | 0;\r\n        r = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 50000 || rd == 0;\r\n      } else {\r\n        r = (rm < 4 && rd + 1 == k || rm > 3 && rd + 1 == k / 2) &&\r\n          (d[di + 1] / k / 100 | 0) == mathpow(10, i - 2) - 1 ||\r\n            (rd == k / 2 || rd == 0) && (d[di + 1] / k / 100 | 0) == 0;\r\n      }\r\n    } else {\r\n      if (i < 4) {\r\n        if (i == 0) rd = rd / 1000 | 0;\r\n        else if (i == 1) rd = rd / 100 | 0;\r\n        else if (i == 2) rd = rd / 10 | 0;\r\n        r = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;\r\n      } else {\r\n        r = ((repeating || rm < 4) && rd + 1 == k ||\r\n        (!repeating && rm > 3) && rd + 1 == k / 2) &&\r\n          (d[di + 1] / k / 1000 | 0) == mathpow(10, i - 3) - 1;\r\n      }\r\n    }\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  // Convert string of `baseIn` to an array of numbers of `baseOut`.\r\n  // Eg. convertBase('255', 10, 16) returns [15, 15].\r\n  // Eg. convertBase('ff', 16, 10) returns [2, 5, 5].\r\n  function convertBase(str, baseIn, baseOut) {\r\n    var j,\r\n      arr = [0],\r\n      arrL,\r\n      i = 0,\r\n      strL = str.length;\r\n\r\n    for (; i < strL;) {\r\n      for (arrL = arr.length; arrL--;) arr[arrL] *= baseIn;\r\n      arr[0] += NUMERALS.indexOf(str.charAt(i++));\r\n      for (j = 0; j < arr.length; j++) {\r\n        if (arr[j] > baseOut - 1) {\r\n          if (arr[j + 1] === void 0) arr[j + 1] = 0;\r\n          arr[j + 1] += arr[j] / baseOut | 0;\r\n          arr[j] %= baseOut;\r\n        }\r\n      }\r\n    }\r\n\r\n    return arr.reverse();\r\n  }\r\n\r\n\r\n  /*\r\n   * cos(x) = 1 - x^2/2! + x^4/4! - ...\r\n   * |x| < pi/2\r\n   *\r\n   */\r\n  function cosine(Ctor, x) {\r\n    var k, y,\r\n      len = x.d.length;\r\n\r\n    // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1\r\n    // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1\r\n\r\n    // Estimate the optimum number of times to use the argument reduction.\r\n    if (len < 32) {\r\n      k = Math.ceil(len / 3);\r\n      y = (1 / tinyPow(4, k)).toString();\r\n    } else {\r\n      k = 16;\r\n      y = '2.3283064365386962890625e-10';\r\n    }\r\n\r\n    Ctor.precision += k;\r\n\r\n    x = taylorSeries(Ctor, 1, x.times(y), new Ctor(1));\r\n\r\n    // Reverse argument reduction\r\n    for (var i = k; i--;) {\r\n      var cos2x = x.times(x);\r\n      x = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);\r\n    }\r\n\r\n    Ctor.precision -= k;\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Perform division in the specified base.\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, base) {\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, base) {\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, rm, dp, base) {\r\n      var cmp, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0,\r\n        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 NaN, Infinity or 0?\r\n      if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n        return new Ctor(// Return NaN if either NaN, or both Infinity or 0.\r\n          !x.s || !y.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN :\r\n\r\n          // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.\r\n          xd && xd[0] == 0 || !yd ? sign * 0 : sign / 0);\r\n      }\r\n\r\n      if (base) {\r\n        logBase = 1;\r\n        e = x.e - y.e;\r\n      } else {\r\n        base = BASE;\r\n        logBase = LOG_BASE;\r\n        e = mathfloor(x.e / logBase) - mathfloor(y.e / logBase);\r\n      }\r\n\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      // The digit array of a Decimal from toStringBinary may have trailing zeros.\r\n      for (i = 0; yd[i] == (xd[i] || 0); i++);\r\n\r\n      if (yd[i] > (xd[i] || 0)) e--;\r\n\r\n      if (pr == null) {\r\n        sd = pr = Ctor.precision;\r\n        rm = Ctor.rounding;\r\n      } else if (dp) {\r\n        sd = pr + (x.e - y.e) + 1;\r\n      } else {\r\n        sd = pr;\r\n      }\r\n\r\n      if (sd < 0) {\r\n        qd.push(1);\r\n        more = true;\r\n      } else {\r\n\r\n        // Convert precision in number of base 10 digits to base 1e7 digits.\r\n        sd = sd / logBase + 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          more = k || i < xL;\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, base);\r\n            xd = multiplyInteger(xd, k, base);\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, base);\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, base);\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, base);\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, base);\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          more = rem[0] !== void 0;\r\n        }\r\n\r\n        // Leading zero?\r\n        if (!qd[0]) qd.shift();\r\n      }\r\n\r\n      // logBase is 1 when divide is being used for base conversion.\r\n      if (logBase == 1) {\r\n        q.e = e;\r\n        inexact = more;\r\n      } else {\r\n\r\n        // To calculate q.e, first get the number of digits of qd[0].\r\n        for (i = 1, k = qd[0]; k >= 10; k /= 10) i++;\r\n        q.e = i + e * logBase - 1;\r\n\r\n        finalise(q, dp ? pr + q.e + 1 : pr, rm, more);\r\n      }\r\n\r\n      return q;\r\n    };\r\n  })();\r\n\r\n\r\n  /*\r\n   * Round `x` to `sd` significant digits using rounding mode `rm`.\r\n   * Check for over/under-flow.\r\n   */\r\n   function finalise(x, sd, rm, isTruncated) {\r\n    var digits, i, j, k, rd, roundUp, w, xd, xdi,\r\n      Ctor = x.constructor;\r\n\r\n    // Don't round if sd is null or undefined.\r\n    out: if (sd != null) {\r\n      xd = x.d;\r\n\r\n      // Infinity/NaN.\r\n      if (!xd) return x;\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 containing rd, a base 1e7 number.\r\n      // xdi: the index of w within xd.\r\n      // digits: 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 (digits = 1, k = xd[0]; k >= 10; k /= 10) digits++;\r\n      i = sd - digits;\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\r\n        // Get the rounding digit at index j of w.\r\n        rd = w / mathpow(10, digits - j - 1) % 10 | 0;\r\n      } else {\r\n        xdi = Math.ceil((i + 1) / LOG_BASE);\r\n        k = xd.length;\r\n        if (xdi >= k) {\r\n          if (isTruncated) {\r\n\r\n            // Needed by `naturalExponential`, `naturalLogarithm` and `squareRoot`.\r\n            for (; k++ <= xdi;) xd.push(0);\r\n            w = rd = 0;\r\n            digits = 1;\r\n            i %= LOG_BASE;\r\n            j = i - LOG_BASE + 1;\r\n          } else {\r\n            break out;\r\n          }\r\n        } else {\r\n          w = k = xd[xdi];\r\n\r\n          // Get the number of digits of w.\r\n          for (digits = 1; k >= 10; k /= 10) digits++;\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 - digits.\r\n          j = i - LOG_BASE + digits;\r\n\r\n          // Get the rounding digit at index j of w.\r\n          rd = j < 0 ? 0 : w / mathpow(10, digits - j - 1) % 10 | 0;\r\n        }\r\n      }\r\n\r\n      // Are there any non-zero digits after the rounding digit?\r\n      isTruncated = isTruncated || sd < 0 ||\r\n        xd[xdi + 1] !== void 0 || (j < 0 ? w : w % mathpow(10, digits - j - 1));\r\n\r\n      // The expression `w % mathpow(10, digits - j - 1)` returns all the digits of w to the right\r\n      // of the digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression\r\n      // will give 714.\r\n\r\n      roundUp = rm < 4\r\n        ? (rd || isTruncated) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n        : rd > 5 || rd == 5 && (rm == 4 || isTruncated || 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, digits - j) : 0 : xd[xdi - 1]) % 10) & 1 ||\r\n            rm == (x.s < 0 ? 8 : 7));\r\n\r\n      if (sd < 1 || !xd[0]) {\r\n        xd.length = 0;\r\n        if (roundUp) {\r\n\r\n          // Convert sd to decimal places.\r\n          sd -= x.e + 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 = -sd || 0;\r\n        } else {\r\n\r\n          // Zero.\r\n          xd[0] = x.e = 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, digits - j) % mathpow(10, j) | 0) * k : 0;\r\n      }\r\n\r\n      if (roundUp) {\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\r\n            // i will be the length of xd[0] before k is added.\r\n            for (i = 1, j = xd[0]; j >= 10; j /= 10) i++;\r\n            j = xd[0] += k;\r\n            for (k = 1; j >= 10; j /= 10) k++;\r\n\r\n            // if i != k the length has increased.\r\n            if (i != k) {\r\n              x.e++;\r\n              if (xd[0] == BASE) xd[0] = 1;\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\r\n    if (external) {\r\n\r\n      // Overflow?\r\n      if (x.e > Ctor.maxE) {\r\n\r\n        // Infinity.\r\n        x.d = null;\r\n        x.e = NaN;\r\n\r\n      // Underflow?\r\n      } else if (x.e < Ctor.minE) {\r\n\r\n        // Zero.\r\n        x.e = 0;\r\n        x.d = [0];\r\n        // Ctor.underflow = true;\r\n      } // else Ctor.underflow = false;\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  function finiteToString(x, isExp, sd) {\r\n    if (!x.isFinite()) return nonFiniteToString(x);\r\n    var k,\r\n      e = x.e,\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 + (x.e < 0 ? 'e' : 'e+') + x.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 str;\r\n  }\r\n\r\n\r\n  // Calculate the base 10 exponent from the base 1e7 exponent.\r\n  function getBase10Exponent(digits, e) {\r\n    var w = digits[0];\r\n\r\n    // Add the number of digits of the first word of the digits array.\r\n    for ( e *= LOG_BASE; w >= 10; w /= 10) e++;\r\n    return e;\r\n  }\r\n\r\n\r\n  function getLn10(Ctor, sd, pr) {\r\n    if (sd > LN10_PRECISION) {\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(precisionLimitExceeded);\r\n    }\r\n    return finalise(new Ctor(LN10), sd, 1, true);\r\n  }\r\n\r\n\r\n  function getPi(Ctor, sd, rm) {\r\n    if (sd > PI_PRECISION) throw Error(precisionLimitExceeded);\r\n    return finalise(new Ctor(PI), sd, rm, true);\r\n  }\r\n\r\n\r\n  function getPrecision(digits) {\r\n    var w = digits.length - 1,\r\n      len = w * LOG_BASE + 1;\r\n\r\n    w = digits[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) len--;\r\n\r\n      // Add the number of digits of the first word.\r\n      for (w = digits[0]; w >= 10; w /= 10) len++;\r\n    }\r\n\r\n    return len;\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 value of Decimal `x` to the power `n`, where `n` is an\r\n   * integer of type number.\r\n   *\r\n   * Implements 'exponentiation by squaring'. Called by `pow` and `parseOther`.\r\n   *\r\n   */\r\n  function intPow(Ctor, x, n, pr) {\r\n    var isTruncated,\r\n      r = new Ctor(1),\r\n\r\n      // Max n of 9007199254740991 takes 53 loop iterations.\r\n      // Maximum digits array length; leaves [28, 34] guard digits.\r\n      k = Math.ceil(pr / LOG_BASE + 4);\r\n\r\n    external = false;\r\n\r\n    for (;;) {\r\n      if (n % 2) {\r\n        r = r.times(x);\r\n        if (truncate(r.d, k)) isTruncated = true;\r\n      }\r\n\r\n      n = mathfloor(n / 2);\r\n      if (n === 0) {\r\n\r\n        // To ensure correct rounding when r.d is truncated, increment the last word if it is zero.\r\n        n = r.d.length - 1;\r\n        if (isTruncated && r.d[n] === 0) ++r.d[n];\r\n        break;\r\n      }\r\n\r\n      x = x.times(x);\r\n      truncate(x.d, k);\r\n    }\r\n\r\n    external = true;\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  function isOdd(n) {\r\n    return n.d[n.d.length - 1] & 1;\r\n  }\r\n\r\n\r\n  /*\r\n   * Handle `max` and `min`. `ltgt` is 'lt' or 'gt'.\r\n   */\r\n  function maxOrMin(Ctor, args, ltgt) {\r\n    var y,\r\n      x = new Ctor(args[0]),\r\n      i = 0;\r\n\r\n    for (; ++i < args.length;) {\r\n      y = new Ctor(args[i]);\r\n      if (!y.s) {\r\n        x = y;\r\n        break;\r\n      } else if (x[ltgt](y)) {\r\n        x = y;\r\n      }\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of `x` rounded to `sd` significant\r\n   * 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   * Max integer argument: exp('20723265836946413') = 6.3e+9000000000000000\r\n   * Min integer argument: exp('-20723265836946411') = 1.2e-9000000000000000\r\n   * (Math object integer min/max: Math.exp(709) = 8.2e+307, Math.exp(-745) = 5e-324)\r\n   *\r\n   *  exp(Infinity)  = Infinity\r\n   *  exp(-Infinity) = 0\r\n   *  exp(NaN)       = NaN\r\n   *  exp(±0)        = 1\r\n   *\r\n   *  exp(x) is non-terminating for any finite, non-zero x.\r\n   *\r\n   *  The result will always be correctly rounded.\r\n   *\r\n   */\r\n  function naturalExponential(x, sd) {\r\n    var denominator, guard, j, pow, sum, t, wpr,\r\n      rep = 0,\r\n      i = 0,\r\n      k = 0,\r\n      Ctor = x.constructor,\r\n      rm = Ctor.rounding,\r\n      pr = Ctor.precision;\r\n\r\n    // 0/NaN/Infinity?\r\n    if (!x.d || !x.d[0] || x.e > 17) {\r\n\r\n      return new Ctor(x.d\r\n        ? !x.d[0] ? 1 : x.s < 0 ? 0 : 1 / 0\r\n        : x.s ? x.s < 0 ? 0 : x : 0 / 0);\r\n    }\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 abs(x) >= 0.1\r\n    while (x.e > -2) {\r\n\r\n      // x = x / 2^5\r\n      x = x.times(t);\r\n      k += 5;\r\n    }\r\n\r\n    // Use 2 * log10(2^k) + 5 (empirically derived) to estimate the increase in precision\r\n    // 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(1);\r\n    Ctor.precision = wpr;\r\n\r\n    for (;;) {\r\n      pow = finalise(pow.times(x), wpr, 1);\r\n      denominator = denominator.times(++i);\r\n      t = sum.plus(divide(pow, denominator, wpr, 1));\r\n\r\n      if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n        j = k;\r\n        while (j--) sum = finalise(sum.times(sum), wpr, 1);\r\n\r\n        // Check to see if the first 4 rounding digits are [49]999.\r\n        // If so, repeat the summation with a higher precision, otherwise\r\n        // e.g. with precision: 18, rounding: 1\r\n        // exp(18.404272462595034083567793919843761) = 98372560.1229999999 (should be 98372560.123)\r\n        // `wpr - guard` is the index of first rounding digit.\r\n        if (sd == null) {\r\n\r\n          if (rep < 3 && checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n            Ctor.precision = wpr += 10;\r\n            denominator = pow = t = new Ctor(1);\r\n            i = 0;\r\n            rep++;\r\n          } else {\r\n            return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n          }\r\n        } else {\r\n          Ctor.precision = pr;\r\n          return sum;\r\n        }\r\n      }\r\n\r\n      sum = t;\r\n    }\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of `x` rounded to `sd` significant\r\n   * digits.\r\n   *\r\n   *  ln(-n)        = NaN\r\n   *  ln(0)         = -Infinity\r\n   *  ln(-0)        = -Infinity\r\n   *  ln(1)         = 0\r\n   *  ln(Infinity)  = Infinity\r\n   *  ln(-Infinity) = NaN\r\n   *  ln(NaN)       = NaN\r\n   *\r\n   *  ln(n) (n != 1) is non-terminating.\r\n   *\r\n   */\r\n  function naturalLogarithm(y, sd) {\r\n    var c, c0, denominator, e, numerator, rep, sum, t, wpr, x1, 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      rm = Ctor.rounding,\r\n      pr = Ctor.precision;\r\n\r\n    // Is x negative or Infinity, NaN, 0 or 1?\r\n    if (x.s < 0 || !xd || !xd[0] || !x.e && xd[0] == 1 && xd.length == 1) {\r\n      return new Ctor(xd && !xd[0] ? -1 / 0 : x.s != 1 ? NaN : xd ? 0 : x);\r\n    }\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    Ctor.precision = wpr += guard;\r\n    c = digitsToString(xd);\r\n    c0 = c.charAt(0);\r\n\r\n    if (Math.abs(e = x.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 = x.e;\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 = naturalLogarithm(new Ctor(c0 + '.' + c.slice(1)), wpr - guard).plus(t);\r\n      Ctor.precision = pr;\r\n\r\n      return sd == null ? finalise(x, pr, rm, external = true) : x;\r\n    }\r\n\r\n    // x1 is x reduced to a value near 1.\r\n    x1 = x;\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(1), x.plus(1), wpr, 1);\r\n    x2 = finalise(x.times(x), wpr, 1);\r\n    denominator = 3;\r\n\r\n    for (;;) {\r\n      numerator = finalise(numerator.times(x2), wpr, 1);\r\n      t = sum.plus(divide(numerator, new Ctor(denominator), wpr, 1));\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. Check that e is not 0 because, besides preventing an\r\n        // unnecessary calculation, -0 + 0 = +0 and to ensure correct rounding -0 needs to stay -0.\r\n        if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ''));\r\n        sum = divide(sum, new Ctor(n), wpr, 1);\r\n\r\n        // Is rm > 3 and the first 4 rounding digits 4999, or rm < 4 (or the summation has\r\n        // been repeated previously) and the first 4 rounding digits 9999?\r\n        // If so, restart the summation with a higher precision, otherwise\r\n        // e.g. with precision: 12, rounding: 1\r\n        // ln(135520028.6126091714265381533) = 18.7246299999 when it should be 18.72463.\r\n        // `wpr - guard` is the index of first rounding digit.\r\n        if (sd == null) {\r\n          if (checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n            Ctor.precision = wpr += guard;\r\n            t = numerator = x = divide(x1.minus(1), x1.plus(1), wpr, 1);\r\n            x2 = finalise(x.times(x), wpr, 1);\r\n            denominator = rep = 1;\r\n          } else {\r\n            return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n          }\r\n        } else {\r\n          Ctor.precision = pr;\r\n          return sum;\r\n        }\r\n      }\r\n\r\n      sum = t;\r\n      denominator += 2;\r\n    }\r\n  }\r\n\r\n\r\n  // ±Infinity, NaN.\r\n  function nonFiniteToString(x) {\r\n    // Unsigned.\r\n    return String(x.s * x.s / 0);\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      x.e = e = e - i - 1;\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) {\r\n\r\n        // Overflow?\r\n        if (x.e > x.constructor.maxE) {\r\n\r\n          // Infinity.\r\n          x.d = null;\r\n          x.e = NaN;\r\n\r\n        // Underflow?\r\n        } else if (x.e < x.constructor.minE) {\r\n\r\n          // Zero.\r\n          x.e = 0;\r\n          x.d = [0];\r\n          // x.constructor.underflow = true;\r\n        } // else x.constructor.underflow = false;\r\n      }\r\n    } else {\r\n\r\n      // Zero.\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   * Parse the value of a new Decimal `x` from a string `str`, which is not a decimal value.\r\n   */\r\n  function parseOther(x, str) {\r\n    var base, Ctor, divisor, i, isFloat, len, p, xd, xe;\r\n\r\n    if (str === 'Infinity' || str === 'NaN') {\r\n      if (!+str) x.s = NaN;\r\n      x.e = NaN;\r\n      x.d = null;\r\n      return x;\r\n    }\r\n\r\n    if (isHex.test(str))  {\r\n      base = 16;\r\n      str = str.toLowerCase();\r\n    } else if (isBinary.test(str))  {\r\n      base = 2;\r\n    } else if (isOctal.test(str))  {\r\n      base = 8;\r\n    } else {\r\n      throw Error(invalidArgument + str);\r\n    }\r\n\r\n    // Is there a binary exponent part?\r\n    i = str.search(/p/i);\r\n\r\n    if (i > 0) {\r\n      p = +str.slice(i + 1);\r\n      str = str.substring(2, i);\r\n    } else {\r\n      str = str.slice(2);\r\n    }\r\n\r\n    // Convert `str` as an integer then divide the result by `base` raised to a power such that the\r\n    // fraction part will be restored.\r\n    i = str.indexOf('.');\r\n    isFloat = i >= 0;\r\n    Ctor = x.constructor;\r\n\r\n    if (isFloat) {\r\n      str = str.replace('.', '');\r\n      len = str.length;\r\n      i = len - i;\r\n\r\n      // log[10](16) = 1.2041... , log[10](88) = 1.9444....\r\n      divisor = intPow(Ctor, new Ctor(base), i, i * 2);\r\n    }\r\n\r\n    xd = convertBase(str, base, BASE);\r\n    xe = xd.length - 1;\r\n\r\n    // Remove trailing zeros.\r\n    for (i = xe; xd[i] === 0; --i) xd.pop();\r\n    if (i < 0) return new Ctor(x.s * 0);\r\n    x.e = getBase10Exponent(xd, xe);\r\n    x.d = xd;\r\n    external = false;\r\n\r\n    // At what precision to perform the division to ensure exact conversion?\r\n    // maxDecimalIntegerPartDigitCount = ceil(log[10](b) * otherBaseIntegerPartDigitCount)\r\n    // log[10](2) = 0.30103, log[10](8) = 0.90309, log[10](16) = 1.20412\r\n    // E.g. ceil(1.2 * 3) = 4, so up to 4 decimal digits are needed to represent 3 hex int digits.\r\n    // maxDecimalFractionPartDigitCount = {Hex:4|Oct:3|Bin:1} * otherBaseFractionPartDigitCount\r\n    // Therefore using 4 * the number of digits of str will always be enough.\r\n    if (isFloat) x = divide(x, divisor, len * 4);\r\n\r\n    // Multiply by the binary exponent part if present.\r\n    if (p) x = x.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));\r\n    external = true;\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * sin(x) = x - x^3/3! + x^5/5! - ...\r\n   * |x| < pi/2\r\n   *\r\n   */\r\n  function sine(Ctor, x) {\r\n    var k,\r\n      len = x.d.length;\r\n\r\n    if (len < 3) return taylorSeries(Ctor, 2, x, x);\r\n\r\n    // Argument reduction: sin(5x) = 16*sin^5(x) - 20*sin^3(x) + 5*sin(x)\r\n    // i.e. sin(x) = 16*sin^5(x/5) - 20*sin^3(x/5) + 5*sin(x/5)\r\n    // and  sin(x) = sin(x/5)(5 + sin^2(x/5)(16sin^2(x/5) - 20))\r\n\r\n    // Estimate the optimum number of times to use the argument reduction.\r\n    k = 1.4 * Math.sqrt(len);\r\n    k = k > 16 ? 16 : k | 0;\r\n\r\n    x = x.times(1 / tinyPow(5, k));\r\n    x = taylorSeries(Ctor, 2, x, x);\r\n\r\n    // Reverse argument reduction\r\n    var sin2_x,\r\n      d5 = new Ctor(5),\r\n      d16 = new Ctor(16),\r\n      d20 = new Ctor(20);\r\n    for (; k--;) {\r\n      sin2_x = x.times(x);\r\n      x = x.times(d5.plus(sin2_x.times(d16.times(sin2_x).minus(d20))));\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  // Calculate Taylor series for `cos`, `cosh`, `sin` and `sinh`.\r\n  function taylorSeries(Ctor, n, x, y, isHyperbolic) {\r\n    var j, t, u, x2,\r\n      i = 1,\r\n      pr = Ctor.precision,\r\n      k = Math.ceil(pr / LOG_BASE);\r\n\r\n    external = false;\r\n    x2 = x.times(x);\r\n    u = new Ctor(y);\r\n\r\n    for (;;) {\r\n      t = divide(u.times(x2), new Ctor(n++ * n++), pr, 1);\r\n      u = isHyperbolic ? y.plus(t) : y.minus(t);\r\n      y = divide(t.times(x2), new Ctor(n++ * n++), pr, 1);\r\n      t = u.plus(y);\r\n\r\n      if (t.d[k] !== void 0) {\r\n        for (j = k; t.d[j] === u.d[j] && j--;);\r\n        if (j == -1) break;\r\n      }\r\n\r\n      j = u;\r\n      u = y;\r\n      y = t;\r\n      t = j;\r\n      i++;\r\n    }\r\n\r\n    external = true;\r\n    t.d.length = k + 1;\r\n\r\n    return t;\r\n  }\r\n\r\n\r\n  // Exponent e must be positive and non-zero.\r\n  function tinyPow(b, e) {\r\n    var n = b;\r\n    while (--e) n *= b;\r\n    return n;\r\n  }\r\n\r\n\r\n  // Return the absolute value of `x` reduced to less than or equal to half pi.\r\n  function toLessThanHalfPi(Ctor, x) {\r\n    var t,\r\n      isNeg = x.s < 0,\r\n      pi = getPi(Ctor, Ctor.precision, 1),\r\n      halfPi = pi.times(0.5);\r\n\r\n    x = x.abs();\r\n\r\n    if (x.lte(halfPi)) {\r\n      quadrant = isNeg ? 4 : 1;\r\n      return x;\r\n    }\r\n\r\n    t = x.divToInt(pi);\r\n\r\n    if (t.isZero()) {\r\n      quadrant = isNeg ? 3 : 2;\r\n    } else {\r\n      x = x.minus(t.times(pi));\r\n\r\n      // 0 <= x < pi\r\n      if (x.lte(halfPi)) {\r\n        quadrant = isOdd(t) ? (isNeg ? 2 : 3) : (isNeg ? 4 : 1);\r\n        return x;\r\n      }\r\n\r\n      quadrant = isOdd(t) ? (isNeg ? 1 : 4) : (isNeg ? 3 : 2);\r\n    }\r\n\r\n    return x.minus(pi).abs();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return the value of Decimal `x` as a string in base `baseOut`.\r\n   *\r\n   * If the optional `sd` argument is present include a binary exponent suffix.\r\n   */\r\n  function toStringBinary(x, baseOut, sd, rm) {\r\n    var base, e, i, k, len, roundUp, str, xd, y,\r\n      Ctor = x.constructor,\r\n      isExp = sd !== void 0;\r\n\r\n    if (isExp) {\r\n      checkInt32(sd, 1, MAX_DIGITS);\r\n      if (rm === void 0) rm = Ctor.rounding;\r\n      else checkInt32(rm, 0, 8);\r\n    } else {\r\n      sd = Ctor.precision;\r\n      rm = Ctor.rounding;\r\n    }\r\n\r\n    if (!x.isFinite()) {\r\n      str = nonFiniteToString(x);\r\n    } else {\r\n      str = finiteToString(x);\r\n      i = str.indexOf('.');\r\n\r\n      // Use exponential notation according to `toExpPos` and `toExpNeg`? No, but if required:\r\n      // maxBinaryExponent = floor((decimalExponent + 1) * log[2](10))\r\n      // minBinaryExponent = floor(decimalExponent * log[2](10))\r\n      // log[2](10) = 3.321928094887362347870319429489390175864\r\n\r\n      if (isExp) {\r\n        base = 2;\r\n        if (baseOut == 16) {\r\n          sd = sd * 4 - 3;\r\n        } else if (baseOut == 8) {\r\n          sd = sd * 3 - 2;\r\n        }\r\n      } else {\r\n        base = baseOut;\r\n      }\r\n\r\n      // Convert the number as an integer then divide the result by its base raised to a power such\r\n      // that the fraction part will be restored.\r\n\r\n      // Non-integer.\r\n      if (i >= 0) {\r\n        str = str.replace('.', '');\r\n        y = new Ctor(1);\r\n        y.e = str.length - i;\r\n        y.d = convertBase(finiteToString(y), 10, base);\r\n        y.e = y.d.length;\r\n      }\r\n\r\n      xd = convertBase(str, 10, base);\r\n      e = len = xd.length;\r\n\r\n      // Remove trailing zeros.\r\n      for (; xd[--len] == 0;) xd.pop();\r\n\r\n      if (!xd[0]) {\r\n        str = isExp ? '0p+0' : '0';\r\n      } else {\r\n        if (i < 0) {\r\n          e--;\r\n        } else {\r\n          x = new Ctor(x);\r\n          x.d = xd;\r\n          x.e = e;\r\n          x = divide(x, y, sd, rm, 0, base);\r\n          xd = x.d;\r\n          e = x.e;\r\n          roundUp = inexact;\r\n        }\r\n\r\n        // The rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        i = xd[sd];\r\n        k = base / 2;\r\n        roundUp = roundUp || xd[sd + 1] !== void 0;\r\n\r\n        roundUp = rm < 4\r\n          ? (i !== void 0 || roundUp) && (rm === 0 || rm === (x.s < 0 ? 3 : 2))\r\n          : i > k || i === k && (rm === 4 || roundUp || rm === 6 && xd[sd - 1] & 1 ||\r\n            rm === (x.s < 0 ? 8 : 7));\r\n\r\n        xd.length = sd;\r\n\r\n        if (roundUp) {\r\n\r\n          // Rounding up may mean the previous digit has to be rounded up and so on.\r\n          for (; ++xd[--sd] > base - 1;) {\r\n            xd[sd] = 0;\r\n            if (!sd) {\r\n              ++e;\r\n              xd.unshift(1);\r\n            }\r\n          }\r\n        }\r\n\r\n        // Determine trailing zeros.\r\n        for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n        // E.g. [4, 11, 15] becomes 4bf.\r\n        for (i = 0, str = ''; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n\r\n        // Add binary exponent suffix?\r\n        if (isExp) {\r\n          if (len > 1) {\r\n            if (baseOut == 16 || baseOut == 8) {\r\n              i = baseOut == 16 ? 4 : 3;\r\n              for (--len; len % i; len++) str += '0';\r\n              xd = convertBase(str, base, baseOut);\r\n              for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n              // xd[0] will always be be 1\r\n              for (i = 1, str = '1.'; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n            } else {\r\n              str = str.charAt(0) + '.' + str.slice(1);\r\n            }\r\n          }\r\n\r\n          str =  str + (e < 0 ? 'p' : 'p+') + e;\r\n        } else if (e < 0) {\r\n          for (; ++e;) str = '0' + str;\r\n          str = '0.' + str;\r\n        } else {\r\n          if (++e > len) for (e -= len; e-- ;) str += '0';\r\n          else if (e < len) str = str.slice(0, e) + '.' + str.slice(e);\r\n        }\r\n      }\r\n\r\n      str = (baseOut == 16 ? '0x' : baseOut == 2 ? '0b' : baseOut == 8 ? '0o' : '') + str;\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   *  abs\r\n   *  acos\r\n   *  acosh\r\n   *  add\r\n   *  asin\r\n   *  asinh\r\n   *  atan\r\n   *  atanh\r\n   *  atan2\r\n   *  cbrt\r\n   *  ceil\r\n   *  clone\r\n   *  config\r\n   *  cos\r\n   *  cosh\r\n   *  div\r\n   *  exp\r\n   *  floor\r\n   *  hypot\r\n   *  ln\r\n   *  log\r\n   *  log2\r\n   *  log10\r\n   *  max\r\n   *  min\r\n   *  mod\r\n   *  mul\r\n   *  pow\r\n   *  random\r\n   *  round\r\n   *  set\r\n   *  sign\r\n   *  sin\r\n   *  sinh\r\n   *  sqrt\r\n   *  sub\r\n   *  tan\r\n   *  tanh\r\n   *  trunc\r\n   */\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the absolute value of `x`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function abs(x) {\r\n    return new this(x).abs();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arccosine in radians of `x`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function acos(x) {\r\n    return new this(x).acos();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic cosine of `x`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function acosh(x) {\r\n    return new this(x).acosh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the sum of `x` and `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function add(x, y) {\r\n    return new this(x).plus(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arcsine in radians of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function asin(x) {\r\n    return new this(x).asin();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic sine of `x`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function asinh(x) {\r\n    return new this(x).asinh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arctangent in radians of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function atan(x) {\r\n    return new this(x).atan();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the inverse of the hyperbolic tangent of `x`, rounded to\r\n   * `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function atanh(x) {\r\n    return new this(x).atanh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the arctangent in radians of `y/x` in the range -pi to pi\r\n   * (inclusive), rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * Domain: [-Infinity, Infinity]\r\n   * Range: [-pi, pi]\r\n   *\r\n   * y {number|string|Decimal} The y-coordinate.\r\n   * x {number|string|Decimal} The x-coordinate.\r\n   *\r\n   * atan2(±0, -0)               = ±pi\r\n   * atan2(±0, +0)               = ±0\r\n   * atan2(±0, -x)               = ±pi for x > 0\r\n   * atan2(±0, x)                = ±0 for x > 0\r\n   * atan2(-y, ±0)               = -pi/2 for y > 0\r\n   * atan2(y, ±0)                = pi/2 for y > 0\r\n   * atan2(±y, -Infinity)        = ±pi for finite y > 0\r\n   * atan2(±y, +Infinity)        = ±0 for finite y > 0\r\n   * atan2(±Infinity, x)         = ±pi/2 for finite x\r\n   * atan2(±Infinity, -Infinity) = ±3*pi/4\r\n   * atan2(±Infinity, +Infinity) = ±pi/4\r\n   * atan2(NaN, x) = NaN\r\n   * atan2(y, NaN) = NaN\r\n   *\r\n   */\r\n  function atan2(y, x) {\r\n    y = new this(y);\r\n    x = new this(x);\r\n    var r,\r\n      pr = this.precision,\r\n      rm = this.rounding,\r\n      wpr = pr + 4;\r\n\r\n    // Either NaN\r\n    if (!y.s || !x.s) {\r\n      r = new this(NaN);\r\n\r\n    // Both ±Infinity\r\n    } else if (!y.d && !x.d) {\r\n      r = getPi(this, wpr, 1).times(x.s > 0 ? 0.25 : 0.75);\r\n      r.s = y.s;\r\n\r\n    // x is ±Infinity or y is ±0\r\n    } else if (!x.d || y.isZero()) {\r\n      r = x.s < 0 ? getPi(this, pr, rm) : new this(0);\r\n      r.s = y.s;\r\n\r\n    // y is ±Infinity or x is ±0\r\n    } else if (!y.d || x.isZero()) {\r\n      r = getPi(this, wpr, 1).times(0.5);\r\n      r.s = y.s;\r\n\r\n    // Both non-zero and finite\r\n    } else if (x.s < 0) {\r\n      this.precision = wpr;\r\n      this.rounding = 1;\r\n      r = this.atan(divide(y, x, wpr, 1));\r\n      x = getPi(this, wpr, 1);\r\n      this.precision = pr;\r\n      this.rounding = rm;\r\n      r = y.s < 0 ? r.minus(x) : r.plus(x);\r\n    } else {\r\n      r = this.atan(divide(y, x, wpr, 1));\r\n    }\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the cube root of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function cbrt(x) {\r\n    return new this(x).cbrt();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` rounded to an integer using `ROUND_CEIL`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function ceil(x) {\r\n    return finalise(x = new this(x), x.e + 1, 2);\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   *   maxE       {number}\r\n   *   minE       {number}\r\n   *   modulo     {number}\r\n   *   crypto     {boolean|number}\r\n   *   defaults   {true}\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') throw Error(decimalError + 'Object expected');\r\n    var i, p, v,\r\n      useDefaults = obj.defaults === true,\r\n      ps = [\r\n        'precision', 1, MAX_DIGITS,\r\n        'rounding', 0, 8,\r\n        'toExpNeg', -EXP_LIMIT, 0,\r\n        'toExpPos', 0, EXP_LIMIT,\r\n        'maxE', 0, EXP_LIMIT,\r\n        'minE', -EXP_LIMIT, 0,\r\n        'modulo', 0, 9\r\n      ];\r\n\r\n    for (i = 0; i < ps.length; i += 3) {\r\n      if (p = ps[i], useDefaults) this[p] = DEFAULTS[p];\r\n      if ((v = obj[p]) !== 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 (p = 'crypto', useDefaults) this[p] = DEFAULTS[p];\r\n    if ((v = obj[p]) !== void 0) {\r\n      if (v === true || v === false || v === 0 || v === 1) {\r\n        if (v) {\r\n          if (typeof crypto != 'undefined' && crypto &&\r\n            (crypto.getRandomValues || crypto.randomBytes)) {\r\n            this[p] = true;\r\n          } else {\r\n            throw Error(cryptoUnavailable);\r\n          }\r\n        } else {\r\n          this[p] = false;\r\n        }\r\n      } else {\r\n        throw Error(invalidArgument + p + ': ' + v);\r\n      }\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the cosine of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function cos(x) {\r\n    return new this(x).cos();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic cosine of `x`, rounded to precision\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function cosh(x) {\r\n    return new this(x).cosh();\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     * v {number|string|Decimal} A numeric value.\r\n     *\r\n     */\r\n    function Decimal(v) {\r\n      var e, i, t,\r\n        x = this;\r\n\r\n      // Decimal called without new.\r\n      if (!(x instanceof Decimal)) return new Decimal(v);\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 (v instanceof Decimal) {\r\n        x.s = v.s;\r\n\r\n        if (external) {\r\n          if (!v.d || v.e > Decimal.maxE) {\r\n\r\n            // Infinity.\r\n            x.e = NaN;\r\n            x.d = null;\r\n          } else if (v.e < Decimal.minE) {\r\n\r\n            // Zero.\r\n            x.e = 0;\r\n            x.d = [0];\r\n          } else {\r\n            x.e = v.e;\r\n            x.d = v.d.slice();\r\n          }\r\n        } else {\r\n          x.e = v.e;\r\n          x.d = v.d ? v.d.slice() : v.d;\r\n        }\r\n\r\n        return;\r\n      }\r\n\r\n      t = typeof v;\r\n\r\n      if (t === 'number') {\r\n        if (v === 0) {\r\n          x.s = 1 / v < 0 ? -1 : 1;\r\n          x.e = 0;\r\n          x.d = [0];\r\n          return;\r\n        }\r\n\r\n        if (v < 0) {\r\n          v = -v;\r\n          x.s = -1;\r\n        } else {\r\n          x.s = 1;\r\n        }\r\n\r\n        // Fast path for small integers.\r\n        if (v === ~~v && v < 1e7) {\r\n          for (e = 0, i = v; i >= 10; i /= 10) e++;\r\n\r\n          if (external) {\r\n            if (e > Decimal.maxE) {\r\n              x.e = NaN;\r\n              x.d = null;\r\n            } else if (e < Decimal.minE) {\r\n              x.e = 0;\r\n              x.d = [0];\r\n            } else {\r\n              x.e = e;\r\n              x.d = [v];\r\n            }\r\n          } else {\r\n            x.e = e;\r\n            x.d = [v];\r\n          }\r\n\r\n          return;\r\n\r\n        // Infinity, NaN.\r\n        } else if (v * 0 !== 0) {\r\n          if (!v) x.s = NaN;\r\n          x.e = NaN;\r\n          x.d = null;\r\n          return;\r\n        }\r\n\r\n        return parseDecimal(x, v.toString());\r\n\r\n      } else if (t !== 'string') {\r\n        throw Error(invalidArgument + v);\r\n      }\r\n\r\n      // Minus sign?\r\n      if ((i = v.charCodeAt(0)) === 45) {\r\n        v = v.slice(1);\r\n        x.s = -1;\r\n      } else {\r\n        // Plus sign?\r\n        if (i === 43) v = v.slice(1);\r\n        x.s = 1;\r\n      }\r\n\r\n      return isDecimal.test(v) ? parseDecimal(x, v) : parseOther(x, v);\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    Decimal.EUCLID = 9;\r\n\r\n    Decimal.config = Decimal.set = config;\r\n    Decimal.clone = clone;\r\n    Decimal.isDecimal = isDecimalInstance;\r\n\r\n    Decimal.abs = abs;\r\n    Decimal.acos = acos;\r\n    Decimal.acosh = acosh;        // ES6\r\n    Decimal.add = add;\r\n    Decimal.asin = asin;\r\n    Decimal.asinh = asinh;        // ES6\r\n    Decimal.atan = atan;\r\n    Decimal.atanh = atanh;        // ES6\r\n    Decimal.atan2 = atan2;\r\n    Decimal.cbrt = cbrt;          // ES6\r\n    Decimal.ceil = ceil;\r\n    Decimal.cos = cos;\r\n    Decimal.cosh = cosh;          // ES6\r\n    Decimal.div = div;\r\n    Decimal.exp = exp;\r\n    Decimal.floor = floor;\r\n    Decimal.hypot = hypot;        // ES6\r\n    Decimal.ln = ln;\r\n    Decimal.log = log;\r\n    Decimal.log10 = log10;        // ES6\r\n    Decimal.log2 = log2;          // ES6\r\n    Decimal.max = max;\r\n    Decimal.min = min;\r\n    Decimal.mod = mod;\r\n    Decimal.mul = mul;\r\n    Decimal.pow = pow;\r\n    Decimal.random = random;\r\n    Decimal.round = round;\r\n    Decimal.sign = sign;          // ES6\r\n    Decimal.sin = sin;\r\n    Decimal.sinh = sinh;          // ES6\r\n    Decimal.sqrt = sqrt;\r\n    Decimal.sub = sub;\r\n    Decimal.tan = tan;\r\n    Decimal.tanh = tanh;          // ES6\r\n    Decimal.trunc = trunc;        // ES6\r\n\r\n    if (obj === void 0) obj = {};\r\n    if (obj) {\r\n      if (obj.defaults !== true) {\r\n        ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'maxE', 'minE', 'modulo', 'crypto'];\r\n        for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];\r\n      }\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   * Return a new Decimal whose value is `x` divided by `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function div(x, y) {\r\n    return new this(x).div(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural exponential of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} The power to which to raise the base of the natural log.\r\n   *\r\n   */\r\n  function exp(x) {\r\n    return new this(x).exp();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` round to an integer using `ROUND_FLOOR`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function floor(x) {\r\n    return finalise(x = new this(x), x.e + 1, 3);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of the sum of the squares of the arguments,\r\n   * rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * hypot(a, b, ...) = sqrt(a^2 + b^2 + ...)\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n   */\r\n  function hypot() {\r\n    var i, n,\r\n      t = new this(0);\r\n\r\n    external = false;\r\n\r\n    for (i = 0; i < arguments.length;) {\r\n      n = new this(arguments[i++]);\r\n      if (!n.d) {\r\n        if (n.s) {\r\n          external = true;\r\n          return new this(1 / 0);\r\n        }\r\n        t = n;\r\n      } else if (t.d) {\r\n        t = t.plus(n.times(n));\r\n      }\r\n    }\r\n\r\n    external = true;\r\n\r\n    return t.sqrt();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return true if object is a Decimal instance (where Decimal is any Decimal constructor),\r\n   * otherwise return false.\r\n   *\r\n   */\r\n  function isDecimalInstance(obj) {\r\n    return obj instanceof Decimal || obj && obj.name === '[object Decimal]' || false;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the natural logarithm of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function ln(x) {\r\n    return new this(x).ln();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the log of `x` to the base `y`, or to base 10 if no base\r\n   * is specified, rounded to `precision` significant digits using rounding mode `rounding`.\r\n   *\r\n   * log[y](x)\r\n   *\r\n   * x {number|string|Decimal} The argument of the logarithm.\r\n   * y {number|string|Decimal} The base of the logarithm.\r\n   *\r\n   */\r\n  function log(x, y) {\r\n    return new this(x).log(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the base 2 logarithm of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function log2(x) {\r\n    return new this(x).log(2);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the base 10 logarithm of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function log10(x) {\r\n    return new this(x).log(10);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the maximum of the arguments.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n   */\r\n  function max() {\r\n    return maxOrMin(this, arguments, 'lt');\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the minimum of the arguments.\r\n   *\r\n   * arguments {number|string|Decimal}\r\n   *\r\n   */\r\n  function min() {\r\n    return maxOrMin(this, arguments, 'gt');\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` modulo `y`, rounded to `precision` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function mod(x, y) {\r\n    return new this(x).mod(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` multiplied by `y`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function mul(x, y) {\r\n    return new this(x).mul(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` raised to the power `y`, rounded to precision\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} The base.\r\n   * y {number|string|Decimal} The exponent.\r\n   *\r\n   */\r\n  function pow(x, y) {\r\n    return new this(x).pow(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Returns a new Decimal with a random value equal to or greater than 0 and less than 1, and with\r\n   * `sd`, or `Decimal.precision` if `sd` is omitted, significant digits (or less if trailing zeros\r\n   * are produced).\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 0 to MAX_DIGITS inclusive.\r\n   *\r\n   */\r\n  function random(sd) {\r\n    var d, e, k, n,\r\n      i = 0,\r\n      r = new this(1),\r\n      rd = [];\r\n\r\n    if (sd === void 0) sd = this.precision;\r\n    else checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n    k = Math.ceil(sd / LOG_BASE);\r\n\r\n    if (!this.crypto) {\r\n      for (; i < k;) rd[i++] = Math.random() * 1e7 | 0;\r\n\r\n    // Browsers supporting crypto.getRandomValues.\r\n    } else if (crypto.getRandomValues) {\r\n      d = crypto.getRandomValues(new Uint32Array(k));\r\n\r\n      for (; i < k;) {\r\n        n = d[i];\r\n\r\n        // 0 <= n < 4294967296\r\n        // Probability n >= 4.29e9, is 4967296 / 4294967296 = 0.00116 (1 in 865).\r\n        if (n >= 4.29e9) {\r\n          d[i] = crypto.getRandomValues(new Uint32Array(1))[0];\r\n        } else {\r\n\r\n          // 0 <= n <= 4289999999\r\n          // 0 <= (n % 1e7) <= 9999999\r\n          rd[i++] = n % 1e7;\r\n        }\r\n      }\r\n\r\n    // Node.js supporting crypto.randomBytes.\r\n    } else if (crypto.randomBytes) {\r\n\r\n      // buffer\r\n      d = crypto.randomBytes(k *= 4);\r\n\r\n      for (; i < k;) {\r\n\r\n        // 0 <= n < 2147483648\r\n        n = d[i] + (d[i + 1] << 8) + (d[i + 2] << 16) + ((d[i + 3] & 0x7f) << 24);\r\n\r\n        // Probability n >= 2.14e9, is 7483648 / 2147483648 = 0.0035 (1 in 286).\r\n        if (n >= 2.14e9) {\r\n          crypto.randomBytes(4).copy(d, i);\r\n        } else {\r\n\r\n          // 0 <= n <= 2139999999\r\n          // 0 <= (n % 1e7) <= 9999999\r\n          rd.push(n % 1e7);\r\n          i += 4;\r\n        }\r\n      }\r\n\r\n      i = k / 4;\r\n    } else {\r\n      throw Error(cryptoUnavailable);\r\n    }\r\n\r\n    k = rd[--i];\r\n    sd %= LOG_BASE;\r\n\r\n    // Convert trailing digits to zeros according to sd.\r\n    if (k && sd) {\r\n      n = mathpow(10, LOG_BASE - sd);\r\n      rd[i] = (k / n | 0) * n;\r\n    }\r\n\r\n    // Remove trailing words which are zero.\r\n    for (; rd[i] === 0; i--) rd.pop();\r\n\r\n    // Zero?\r\n    if (i < 0) {\r\n      e = 0;\r\n      rd = [0];\r\n    } else {\r\n      e = -1;\r\n\r\n      // Remove leading words which are zero and adjust exponent accordingly.\r\n      for (; rd[0] === 0; e -= LOG_BASE) rd.shift();\r\n\r\n      // Count the digits of the first word of rd to determine leading zeros.\r\n      for (k = 1, n = rd[0]; n >= 10; n /= 10) k++;\r\n\r\n      // Adjust the exponent for leading zeros of the first word of rd.\r\n      if (k < LOG_BASE) e -= LOG_BASE - k;\r\n    }\r\n\r\n    r.e = e;\r\n    r.d = rd;\r\n\r\n    return r;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` rounded to an integer using rounding mode `rounding`.\r\n   *\r\n   * To emulate `Math.round`, set rounding to 7 (ROUND_HALF_CEIL).\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function round(x) {\r\n    return finalise(x = new this(x), x.e + 1, this.rounding);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1    if x > 0,\r\n   *  -1    if x < 0,\r\n   *   0    if x is 0,\r\n   *  -0    if x is -0,\r\n   *   NaN  otherwise\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function sign(x) {\r\n    x = new this(x);\r\n    return x.d ? (x.d[0] ? x.s : 0 * x.s) : x.s || NaN;\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the sine of `x`, rounded to `precision` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function sin(x) {\r\n    return new this(x).sin();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic sine of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function sinh(x) {\r\n    return new this(x).sinh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the square root of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function sqrt(x) {\r\n    return new this(x).sqrt();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` minus `y`, rounded to `precision` significant digits\r\n   * using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal}\r\n   * y {number|string|Decimal}\r\n   *\r\n   */\r\n  function sub(x, y) {\r\n    return new this(x).sub(y);\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the tangent of `x`, rounded to `precision` significant\r\n   * digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function tan(x) {\r\n    return new this(x).tan();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is the hyperbolic tangent of `x`, rounded to `precision`\r\n   * significant digits using rounding mode `rounding`.\r\n   *\r\n   * x {number|string|Decimal} A value in radians.\r\n   *\r\n   */\r\n  function tanh(x) {\r\n    return new this(x).tanh();\r\n  }\r\n\r\n\r\n  /*\r\n   * Return a new Decimal whose value is `x` truncated to an integer.\r\n   *\r\n   * x {number|string|Decimal}\r\n   *\r\n   */\r\n  function trunc(x) {\r\n    return finalise(x = new this(x), x.e + 1, 1);\r\n  }\r\n\r\n\r\n  // Create and configure initial Decimal constructor.\r\n  Decimal = clone(DEFAULTS);\r\n\r\n  Decimal['default'] = Decimal.Decimal = Decimal;\r\n\r\n  // Create the internal constants from their string values.\r\n  LN10 = new Decimal(LN10);\r\n  PI = new Decimal(PI);\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    if (typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol') {\r\n      P[Symbol.for('nodejs.util.inspect.custom')] = P.toString;\r\n      P[Symbol.toStringTag] = 'Decimal';\r\n    }\r\n\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 ? self : window;\r\n    }\r\n\r\n    noConflict = globalScope.Decimal;\r\n    Decimal.noConflict = function () {\r\n      globalScope.Decimal = noConflict;\r\n      return Decimal;\r\n    };\r\n\r\n    globalScope.Decimal = Decimal;\r\n  }\r\n})(this);\r\n","'use strict';\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp(token, 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\n\nfunction decodeComponents(components, split) {\n\ttry {\n\t\t// Try to decode the entire string first\n\t\treturn decodeURIComponent(components.join(''));\n\t} catch (err) {\n\t\t// Do nothing\n\t}\n\n\tif (components.length === 1) {\n\t\treturn components;\n\t}\n\n\tsplit = split || 1;\n\n\t// Split the array in 2 parts\n\tvar left = components.slice(0, split);\n\tvar right = components.slice(split);\n\n\treturn Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\n\nfunction decode(input) {\n\ttry {\n\t\treturn decodeURIComponent(input);\n\t} catch (err) {\n\t\tvar tokens = input.match(singleMatcher);\n\n\t\tfor (var i = 1; i < tokens.length; i++) {\n\t\t\tinput = decodeComponents(tokens, i).join('');\n\n\t\t\ttokens = input.match(singleMatcher);\n\t\t}\n\n\t\treturn input;\n\t}\n}\n\nfunction customDecodeURIComponent(input) {\n\t// Keep track of all the replacements and prefill the map with the `BOM`\n\tvar replaceMap = {\n\t\t'%FE%FF': '\\uFFFD\\uFFFD',\n\t\t'%FF%FE': '\\uFFFD\\uFFFD'\n\t};\n\n\tvar match = multiMatcher.exec(input);\n\twhile (match) {\n\t\ttry {\n\t\t\t// Decode as big chunks as possible\n\t\t\treplaceMap[match[0]] = decodeURIComponent(match[0]);\n\t\t} catch (err) {\n\t\t\tvar result = decode(match[0]);\n\n\t\t\tif (result !== match[0]) {\n\t\t\t\treplaceMap[match[0]] = result;\n\t\t\t}\n\t\t}\n\n\t\tmatch = multiMatcher.exec(input);\n\t}\n\n\t// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n\treplaceMap['%C2'] = '\\uFFFD';\n\n\tvar entries = Object.keys(replaceMap);\n\n\tfor (var i = 0; i < entries.length; i++) {\n\t\t// Replace all decoded components\n\t\tvar key = entries[i];\n\t\tinput = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n\t}\n\n\treturn input;\n}\n\nmodule.exports = function (encodedURI) {\n\tif (typeof encodedURI !== 'string') {\n\t\tthrow new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n\t}\n\n\ttry {\n\t\tencodedURI = encodedURI.replace(/\\+/g, ' ');\n\n\t\t// Try the built in decoder first\n\t\treturn decodeURIComponent(encodedURI);\n\t} catch (err) {\n\t\t// Fallback to a more advanced decoder\n\t\treturn customDecodeURIComponent(encodedURI);\n\t}\n};\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","'use strict';\nvar strictUriEncode = require('strict-uri-encode');\nvar objectAssign = require('object-assign');\nvar decodeComponent = require('decode-uri-component');\n\nfunction encoderForArrayFormat(opts) {\n\tswitch (opts.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn function (key, value, index) {\n\t\t\t\treturn value === null ? [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'[',\n\t\t\t\t\tindex,\n\t\t\t\t\t']'\n\t\t\t\t].join('') : [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'[',\n\t\t\t\t\tencode(index, opts),\n\t\t\t\t\t']=',\n\t\t\t\t\tencode(value, opts)\n\t\t\t\t].join('');\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn function (key, value) {\n\t\t\t\treturn value === null ? encode(key, opts) : [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'[]=',\n\t\t\t\t\tencode(value, opts)\n\t\t\t\t].join('');\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn function (key, value) {\n\t\t\t\treturn value === null ? encode(key, opts) : [\n\t\t\t\t\tencode(key, opts),\n\t\t\t\t\t'=',\n\t\t\t\t\tencode(value, opts)\n\t\t\t\t].join('');\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(opts) {\n\tvar result;\n\n\tswitch (opts.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn function (key, value, accumulator) {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn function (key, value, accumulator) {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t} else if (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn function (key, value, accumulator) {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction encode(value, opts) {\n\tif (opts.encode) {\n\t\treturn opts.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t} else if (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input)).sort(function (a, b) {\n\t\t\treturn Number(a) - Number(b);\n\t\t}).map(function (key) {\n\t\t\treturn input[key];\n\t\t});\n\t}\n\n\treturn input;\n}\n\nexports.extract = function (str) {\n\treturn str.split('?')[1] || '';\n};\n\nexports.parse = function (str, opts) {\n\topts = objectAssign({arrayFormat: 'none'}, opts);\n\n\tvar formatter = parserForArrayFormat(opts);\n\n\t// Create an object with no prototype\n\t// https://github.com/sindresorhus/query-string/issues/47\n\tvar ret = Object.create(null);\n\n\tif (typeof str !== 'string') {\n\t\treturn ret;\n\t}\n\n\tstr = str.trim().replace(/^(\\?|#|&)/, '');\n\n\tif (!str) {\n\t\treturn ret;\n\t}\n\n\tstr.split('&').forEach(function (param) {\n\t\tvar parts = param.replace(/\\+/g, ' ').split('=');\n\t\t// Firefox (pre 40) decodes `%3D` to `=`\n\t\t// https://github.com/sindresorhus/query-string/pull/37\n\t\tvar key = parts.shift();\n\t\tvar val = parts.length > 0 ? parts.join('=') : undefined;\n\n\t\t// missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tval = val === undefined ? null : decodeComponent(val);\n\n\t\tformatter(decodeComponent(key), val, ret);\n\t});\n\n\treturn Object.keys(ret).sort().reduce(function (result, key) {\n\t\tvar val = ret[key];\n\t\tif (Boolean(val) && typeof val === 'object' && !Array.isArray(val)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(val);\n\t\t} else {\n\t\t\tresult[key] = val;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n};\n\nexports.stringify = function (obj, opts) {\n\tvar defaults = {\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none'\n\t};\n\n\topts = objectAssign(defaults, opts);\n\n\tvar formatter = encoderForArrayFormat(opts);\n\n\treturn obj ? Object.keys(obj).sort().map(function (key) {\n\t\tvar val = obj[key];\n\n\t\tif (val === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (val === null) {\n\t\t\treturn encode(key, opts);\n\t\t}\n\n\t\tif (Array.isArray(val)) {\n\t\t\tvar result = [];\n\n\t\t\tval.slice().forEach(function (val2) {\n\t\t\t\tif (val2 === undefined) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tresult.push(formatter(key, val2, result.length));\n\t\t\t});\n\n\t\t\treturn result.join('&');\n\t\t}\n\n\t\treturn encode(key, opts) + '=' + encode(val, opts);\n\t}).filter(function (x) {\n\t\treturn x.length > 0;\n\t}).join('&') : '';\n};\n","'use strict';\n\nvar compose = require('redux').compose;\n\nexports.__esModule = true;\nexports.composeWithDevTools =\n  process.env.NODE_ENV !== 'production' &&\n  typeof window !== 'undefined' &&\n  window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__\n    ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__\n    : function () {\n        if (arguments.length === 0) return undefined;\n        if (typeof arguments[0] === 'object') return compose;\n        return compose.apply(null, arguments);\n      };\n\nexports.devToolsEnhancer =\n  process.env.NODE_ENV !== 'production' &&\n  typeof window !== 'undefined' &&\n  window.__REDUX_DEVTOOLS_EXTENSION__\n    ? window.__REDUX_DEVTOOLS_EXTENSION__\n    : function () {\n        return function (noop) {\n          return noop;\n        };\n      };\n","'use strict';\n\nexports.__esModule = true;\nexports.createDynamicMiddlewares = exports.resetMiddlewares = exports.removeMiddleware = exports.addMiddleware = undefined;\n\nvar _redux = require('redux');\n\nvar createDynamicMiddlewares = function createDynamicMiddlewares() {\n  var allDynamicMiddlewares = [];\n\n  var enhancer = function enhancer(store) {\n    return function (next) {\n      return function (action) {\n        var chain = allDynamicMiddlewares.map(function (middleware) {\n          return middleware(store);\n        });\n\n        return _redux.compose.apply(undefined, chain)(next)(action);\n      };\n    };\n  };\n\n  var addMiddleware = function addMiddleware() {\n    for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n      middlewares[_key] = arguments[_key];\n    }\n\n    allDynamicMiddlewares = [].concat(allDynamicMiddlewares, middlewares);\n  };\n\n  var removeMiddleware = function removeMiddleware(middleware) {\n    var index = allDynamicMiddlewares.findIndex(function (d) {\n      return d === middleware;\n    });\n\n    if (index === -1) {\n      // eslint-disable-next-line no-console\n      console.error('Middleware does not exist!', middleware);\n\n      return;\n    }\n\n    allDynamicMiddlewares = allDynamicMiddlewares.filter(function (_, mdwIndex) {\n      return mdwIndex !== index;\n    });\n  };\n\n  var resetMiddlewares = function resetMiddlewares() {\n    allDynamicMiddlewares = [];\n  };\n\n  return {\n    enhancer: enhancer,\n    addMiddleware: addMiddleware,\n    removeMiddleware: removeMiddleware,\n    resetMiddlewares: resetMiddlewares\n  };\n};\n\nvar dynamicMiddlewaresInstance = createDynamicMiddlewares();\n\nexports.default = dynamicMiddlewaresInstance.enhancer;\nvar addMiddleware = dynamicMiddlewaresInstance.addMiddleware,\n    removeMiddleware = dynamicMiddlewaresInstance.removeMiddleware,\n    resetMiddlewares = dynamicMiddlewaresInstance.resetMiddlewares;\nexports.addMiddleware = addMiddleware;\nexports.removeMiddleware = removeMiddleware;\nexports.resetMiddlewares = resetMiddlewares;\nexports.createDynamicMiddlewares = createDynamicMiddlewares;","\"use strict\";\r\n//inspired from https://github.com/pofigizm/redux-dynamic-middlewares\r\nexports.__esModule = true;\r\nvar redux_dynamic_middlewares_1 = require(\"redux-dynamic-middlewares\");\r\nexports.getMiddlewareManager = function () {\r\n    var dynamicMiddlewaresInstance = redux_dynamic_middlewares_1.createDynamicMiddlewares();\r\n    var add = function (middlewares) {\r\n        dynamicMiddlewaresInstance.addMiddleware.apply(dynamicMiddlewaresInstance, middlewares);\r\n        return middlewares;\r\n    };\r\n    var remove = function (middlewares) {\r\n        middlewares.forEach(dynamicMiddlewaresInstance.removeMiddleware);\r\n        return middlewares;\r\n    };\r\n    return {\r\n        getItems: function () { return []; },\r\n        enhancer: dynamicMiddlewaresInstance.enhancer,\r\n        add: add,\r\n        remove: remove,\r\n        dispose: function () {\r\n            dynamicMiddlewaresInstance.resetMiddlewares();\r\n        }\r\n    };\r\n};\r\n","\"use strict\";\r\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\nexports.__esModule = true;\r\nvar ReducerManager_1 = require(\"./ReducerManager\");\r\nfunction getModuleManager(middlewareManager, extensions, advancedCombineReducers) {\r\n    var _dispatch = null;\r\n    var _reducerManager;\r\n    var _modules = [];\r\n    var _moduleIds = new Set();\r\n    var _seedReducers = function () {\r\n        _dispatch({ type: \"@@Internal/ModuleManager/SeedReducers\" });\r\n    };\r\n    var _dispatchActions = function (actions) {\r\n        if (!actions) {\r\n            return;\r\n        }\r\n        if (!_dispatch) {\r\n            throw new Error(\"setDispatch should be called on ModuleManager before adding any modules.\");\r\n        }\r\n        actions.forEach(_dispatch);\r\n    };\r\n    var _addMiddlewares = function (middlewares) {\r\n        if (!middlewares) {\r\n            return;\r\n        }\r\n        middlewareManager.add(middlewares);\r\n    };\r\n    var _removeMiddlewares = function (middlewares) {\r\n        if (!middlewares) {\r\n            return;\r\n        }\r\n        middlewareManager.remove(middlewares);\r\n    };\r\n    var _addReducers = function (reducerMap) {\r\n        if (!reducerMap) {\r\n            return;\r\n        }\r\n        if (!_reducerManager) {\r\n            _reducerManager = ReducerManager_1.getRefCountedReducerManager(\r\n            // @ts-ignore\r\n            ReducerManager_1.getReducerManager(reducerMap, advancedCombineReducers));\r\n        }\r\n        else {\r\n            for (var key in reducerMap) {\r\n                _reducerManager.add(key, reducerMap[key]);\r\n            }\r\n        }\r\n    };\r\n    var _removeReducers = function (reducerMap) {\r\n        if (!reducerMap || !_reducerManager) {\r\n            return;\r\n        }\r\n        for (var key in reducerMap) {\r\n            _reducerManager.remove(key);\r\n        }\r\n    };\r\n    // Create reduce function which redirects to _reducers.reduce\r\n    var _reduce = function (s, a) {\r\n        if (_reducerManager) {\r\n            return _reducerManager.reduce(s, a);\r\n        }\r\n        return s || null;\r\n    };\r\n    var moduleManager = {\r\n        getReducer: _reduce,\r\n        setDispatch: function (dispatch) {\r\n            _dispatch = dispatch;\r\n        },\r\n        getItems: function () { return []; },\r\n        add: function (modulesToAdd) {\r\n            if (!modulesToAdd || modulesToAdd.length === 0) {\r\n                return;\r\n            }\r\n            modulesToAdd = modulesToAdd.filter(function (module) { return module; });\r\n            var justAddedModules = [];\r\n            modulesToAdd.forEach(function (module) {\r\n                if (!_moduleIds.has(module.id)) {\r\n                    _moduleIds.add(module.id);\r\n                    _modules.push(module);\r\n                    _addReducers(module.reducerMap);\r\n                    var middlewares = module.middlewares;\r\n                    if (middlewares) {\r\n                        _addMiddlewares(middlewares);\r\n                    }\r\n                    justAddedModules.push(module);\r\n                }\r\n            });\r\n            /* Fire an action so that the newly added reducers can seed their initial state */\r\n            _seedReducers();\r\n            // add the sagas and dispatch actions at the end so all the reducers are registered\r\n            justAddedModules.forEach(function (module) {\r\n                // Let the extensions know we added a module\r\n                extensions.forEach(function (p) {\r\n                    if (p.onModuleAdded) {\r\n                        p.onModuleAdded(module);\r\n                    }\r\n                });\r\n                // Dispatch the initial actions\r\n                var moduleAddedAction = {\r\n                    type: \"@@Internal/ModuleManager/ModuleAdded\",\r\n                    payload: module.id\r\n                };\r\n                _dispatchActions(module.initialActions\r\n                    ? __spreadArrays([moduleAddedAction], module.initialActions) : [moduleAddedAction]);\r\n            });\r\n        },\r\n        remove: function (modulesToRemove) {\r\n            if (!modulesToRemove) {\r\n                return;\r\n            }\r\n            modulesToRemove = modulesToRemove\r\n                .filter(function (module) { return module; })\r\n                .reverse();\r\n            modulesToRemove.forEach(function (module) {\r\n                if (_moduleIds.has(module.id)) {\r\n                    _dispatchActions(module.finalActions);\r\n                    _removeReducers(module.reducerMap);\r\n                    _removeMiddlewares(module.middlewares);\r\n                    // Let the extensions know we removed a module\r\n                    extensions.forEach(function (p) {\r\n                        if (p.onModuleRemoved) {\r\n                            p.onModuleRemoved(module);\r\n                        }\r\n                    });\r\n                    _moduleIds[\"delete\"](module.id);\r\n                    _modules = _modules.filter(function (m) { return m.id !== module.id; });\r\n                    _dispatchActions([\r\n                        {\r\n                            type: \"@@Internal/ModuleManager/ModuleRemoved\",\r\n                            payload: module.id\r\n                        },\r\n                    ]);\r\n                }\r\n            });\r\n        },\r\n        dispose: function () {\r\n            moduleManager.remove(_modules);\r\n        }\r\n    };\r\n    return moduleManager;\r\n}\r\nexports.getModuleManager = getModuleManager;\r\n","\"use strict\";\r\nvar __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\nexports.__esModule = true;\r\nvar redux_1 = require(\"redux\");\r\nvar RefCounter_1 = require(\"../Utils/RefCounter\");\r\n/**\r\n * Adds reference counting to reducer manager and adds/remove keys only when ref count is zero\r\n */\r\nfunction getRefCountedReducerManager(manager) {\r\n    var reducerKeyRefCounter = RefCounter_1.getStringRefCounter();\r\n    for (var key in manager.getReducerMap()) {\r\n        reducerKeyRefCounter.add(key);\r\n    }\r\n    return {\r\n        reduce: manager.reduce,\r\n        getReducerMap: manager.getReducerMap,\r\n        add: function (key, reducer) {\r\n            if (reducerKeyRefCounter.getCount(key) === 0) {\r\n                manager.add(key, reducer);\r\n            }\r\n            reducerKeyRefCounter.add(key);\r\n        },\r\n        remove: function (key) {\r\n            reducerKeyRefCounter.remove(key);\r\n            if (reducerKeyRefCounter.getCount(key) === 0) {\r\n                manager.remove(key);\r\n            }\r\n        }\r\n    };\r\n}\r\nexports.getRefCountedReducerManager = getRefCountedReducerManager;\r\n/**\r\n * Create a combined reducer as in the fashion of Redux's combineReducers() function,\r\n * but allows for the dynamic registration of additional reducers\r\n * @param initialReducers The initial set of reducers\r\n * @returns An object with three functions: the reducer, an addReducer function, and a removeReducer function\r\n */\r\nfunction getReducerManager(initialReducers, reducerCombiner) {\r\n    if (reducerCombiner === void 0) { reducerCombiner = redux_1.combineReducers; }\r\n    var combinedReducer = reducerCombiner(initialReducers);\r\n    var reducers = __assign({}, initialReducers);\r\n    var keysToRemove = [];\r\n    var reduce = function (state, action) {\r\n        if (keysToRemove.length > 0) {\r\n            state = __assign({}, state);\r\n            for (var _i = 0, keysToRemove_1 = keysToRemove; _i < keysToRemove_1.length; _i++) {\r\n                var key = keysToRemove_1[_i];\r\n                delete state[key];\r\n            }\r\n            keysToRemove = [];\r\n        }\r\n        if (state === undefined) {\r\n            state = {};\r\n        }\r\n        return combinedReducer(state, action);\r\n    };\r\n    return {\r\n        getReducerMap: function () { return reducers; },\r\n        reduce: reduce,\r\n        add: function (key, reducer) {\r\n            if (!key || reducers[key]) {\r\n                return;\r\n            }\r\n            reducers[key] = reducer;\r\n            combinedReducer = getCombinedReducer(reducers, reducerCombiner);\r\n        },\r\n        remove: function (key) {\r\n            if (!key || !reducers[key]) {\r\n                return;\r\n            }\r\n            delete reducers[key];\r\n            keysToRemove.push(key);\r\n            combinedReducer = getCombinedReducer(reducers, reducerCombiner);\r\n        }\r\n    };\r\n}\r\nexports.getReducerManager = getReducerManager;\r\nfunction getCombinedReducer(reducerMap, reducerCombiner) {\r\n    if (reducerCombiner === void 0) { reducerCombiner = redux_1.combineReducers; }\r\n    if (!reducerMap || Object.keys(reducerMap).length === 0) {\r\n        return function (state, action) { return state || null; };\r\n    }\r\n    return reducerCombiner(reducerMap);\r\n}\r\n","\"use strict\";\r\nvar __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\nexports.__esModule = true;\r\nvar RefCounter_1 = require(\"../Utils/RefCounter\");\r\n/**\r\n * Enhances the given items with ref counting for add remove purposes\r\n */\r\nfunction getRefCountedManager(manager, equals, retained // Decides if the item is retained even when the ref count reaches 0 \r\n) {\r\n    var refCounter = RefCounter_1.getObjectRefCounter(equals, retained);\r\n    var items = manager.getItems();\r\n    // Set initial ref counting\r\n    items.forEach(function (item) { return refCounter.add(item); });\r\n    var ret = __assign({}, manager);\r\n    // Wrap add method\r\n    ret.add = function (items) {\r\n        if (!items) {\r\n            return;\r\n        }\r\n        var nonNullItems = items.filter(function (i) { return i; });\r\n        var notAddedItems = nonNullItems.filter(function (i) { return refCounter.getCount(i) === 0; });\r\n        manager.add(notAddedItems);\r\n        nonNullItems.forEach(refCounter.add);\r\n    };\r\n    // Wrap remove\r\n    ret.remove = function (items) {\r\n        if (!items) {\r\n            return;\r\n        }\r\n        items.forEach(function (item) {\r\n            if (item) {\r\n                refCounter.remove(item);\r\n                if (refCounter.getCount(item) === 0) {\r\n                    manager.remove([item]);\r\n                }\r\n            }\r\n        });\r\n    };\r\n    ret.dispose = function () {\r\n        manager.dispose();\r\n    };\r\n    return ret;\r\n}\r\nexports.getRefCountedManager = getRefCountedManager;\r\n","\"use strict\";\r\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\nexports.__esModule = true;\r\nvar redux_1 = require(\"redux\");\r\nvar developmentOnly_1 = require(\"redux-devtools-extension/developmentOnly\");\r\nvar MiddlewareManager_1 = require(\"./Managers/MiddlewareManager\");\r\nvar ModuleManager_1 = require(\"./Managers/ModuleManager\");\r\nvar RefCountedManager_1 = require(\"./Managers/RefCountedManager\");\r\nvar Flatten_1 = require(\"./Utils/Flatten\");\r\nfunction createStore(moduleStoreSettings) {\r\n    var initialModules = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        initialModules[_i - 1] = arguments[_i];\r\n    }\r\n    var _a = moduleStoreSettings.initialState, initialState = _a === void 0 ? {} : _a, _b = moduleStoreSettings.extensions, extensions = _b === void 0 ? [] : _b, _c = moduleStoreSettings.enhancers, enhancers = _c === void 0 ? [] : _c, _d = moduleStoreSettings.advancedComposeEnhancers, advancedComposeEnhancers = _d === void 0 ? developmentOnly_1.composeWithDevTools({}) : _d, advancedCombineReducers = moduleStoreSettings.advancedCombineReducers;\r\n    var extensionMiddleware = extensions.reduce(function (mw, p) {\r\n        if (p.middleware) {\r\n            mw.push.apply(mw, p.middleware);\r\n        }\r\n        return mw;\r\n    }, []);\r\n    var middlewareManager = RefCountedManager_1.getRefCountedManager(MiddlewareManager_1.getMiddlewareManager(), function (a, b) { return a === b; });\r\n    var enhancer = advancedComposeEnhancers.apply(void 0, __spreadArrays(enhancers, [redux_1.applyMiddleware.apply(void 0, __spreadArrays(extensionMiddleware, [middlewareManager.enhancer]))]));\r\n    var moduleManager = RefCountedManager_1.getRefCountedManager(ModuleManager_1.getModuleManager(middlewareManager, extensions, advancedCombineReducers), function (a, b) { return a.id === b.id; }, function (a) { return a.retained; });\r\n    // Create store\r\n    var store = redux_1.createStore(moduleManager.getReducer, initialState, enhancer);\r\n    moduleManager.setDispatch(store.dispatch);\r\n    var addModules = function (modulesToBeAdded) {\r\n        var flattenedModules = Flatten_1.flatten(modulesToBeAdded);\r\n        moduleManager.add(flattenedModules);\r\n        return {\r\n            remove: function () {\r\n                moduleManager.remove(flattenedModules);\r\n            }\r\n        };\r\n    };\r\n    var addModule = function (moduleToBeAdded) {\r\n        return addModules([moduleToBeAdded]);\r\n    };\r\n    extensions.forEach(function (p) {\r\n        if (p.onModuleManagerCreated) {\r\n            p.onModuleManagerCreated({\r\n                addModule: addModule,\r\n                addModules: addModules\r\n            });\r\n        }\r\n    });\r\n    store.addModule = addModule;\r\n    store.addModules = addModules;\r\n    store.dispose = function () {\r\n        // get all added modules and remove them\r\n        moduleManager.dispose();\r\n        middlewareManager.dispose();\r\n        extensions.forEach(function (p) {\r\n            if (p.dispose) {\r\n                p.dispose();\r\n            }\r\n        });\r\n    };\r\n    store.addModules(initialModules);\r\n    return store;\r\n}\r\nexports.createStore = createStore;\r\n","\"use strict\";\r\nexports.__esModule = true;\r\n/**\r\n * We will use it where we can not use the default Map as the Map class do not allow custom compare function\r\n * @param equals Optional, a comparer to use\r\n */\r\nfunction getMap(equals) {\r\n    var keys = [];\r\n    var values = {};\r\n    return {\r\n        /**\r\n         * Current set of keys\r\n         */\r\n        keys: keys,\r\n        /**\r\n         * Gets value for given key\r\n         */\r\n        get: function (key) {\r\n            if (!key) {\r\n                return undefined;\r\n            }\r\n            var index = keys.findIndex(function (k) { return k && equals(k, key); });\r\n            if (index === -1) {\r\n                return undefined;\r\n            }\r\n            return values[index];\r\n        },\r\n        /**\r\n         * Adds the given key and value\r\n         */\r\n        add: function (key, value) {\r\n            if (!key) {\r\n                return;\r\n            }\r\n            var index = keys.findIndex(function (k) { return k && equals(k, key); });\r\n            if (index === -1) {\r\n                keys.push(key);\r\n                values[keys.length - 1] = value;\r\n            }\r\n        },\r\n        /**\r\n         * Removes the given key and returns the value object if key was found\r\n         */\r\n        remove: function (key) {\r\n            if (!key) {\r\n                return undefined;\r\n            }\r\n            var index = keys.findIndex(function (k) { return k && equals(k, key); });\r\n            if (index === -1) {\r\n                return undefined;\r\n            }\r\n            delete keys[index];\r\n            var value = values[index];\r\n            delete values[index];\r\n            return value;\r\n        }\r\n    };\r\n}\r\nexports.getMap = getMap;\r\n","\"use strict\";\r\nvar __spreadArrays = (this && this.__spreadArrays) || function () {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\nexports.__esModule = true;\r\nfunction flatten(arr) {\r\n    if (arr) {\r\n        var res = arr.slice();\r\n        var i = 0;\r\n        while (i < res.length) {\r\n            if (Array.isArray(res[i])) {\r\n                res.splice.apply(res, __spreadArrays([i, 1], res[i]));\r\n            }\r\n            else {\r\n                i++;\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    return arr;\r\n}\r\nexports.flatten = flatten;\r\n","\"use strict\";\r\nexports.__esModule = true;\r\n/** Ref counts given object */\r\nfunction getObjectRefCounter(equals, retained) {\r\n    if (!equals) {\r\n        equals = function (a, b) { return a === b; };\r\n    }\r\n    if (!retained) {\r\n        retained = function () { return false; };\r\n    }\r\n    var objects = [];\r\n    var counts = [];\r\n    return {\r\n        /**\r\n         * Gets ref count of given T\r\n         */\r\n        getCount: function (obj) {\r\n            if (obj === undefined || obj === null) {\r\n                return 0;\r\n            }\r\n            var index = objects.findIndex(function (o) { return o && equals(o, obj); });\r\n            if (index === -1) {\r\n                return 0;\r\n            }\r\n            return counts[index];\r\n        },\r\n        /**\r\n         * Add given T or increments ref count\r\n         */\r\n        add: function (obj) {\r\n            if (obj === undefined || obj === null) {\r\n                return;\r\n            }\r\n            var index = objects.findIndex(function (o) { return o && equals(o, obj); });\r\n            var count = 1;\r\n            if (index === -1) {\r\n                index = objects.length;\r\n                objects.push(obj);\r\n            }\r\n            else {\r\n                count = counts[index] + 1;\r\n            }\r\n            // If item is retained then keep it for inifinty\r\n            if (retained(obj)) {\r\n                count = Infinity;\r\n            }\r\n            counts[index] = count;\r\n        },\r\n        /**\r\n         * Decreases ref count for given T, if refcount reaches to zero removes the T and returns true\r\n         */\r\n        remove: function (obj) {\r\n            if (retained(obj)) {\r\n                return false;\r\n            }\r\n            var index = objects.findIndex(function (o) { return o && equals(o, obj); });\r\n            if (index === -1) {\r\n                return false;\r\n            }\r\n            if (counts[index] === 1) {\r\n                delete objects[index];\r\n                delete counts[index];\r\n                return true;\r\n            }\r\n            counts[index] = counts[index] - 1;\r\n            return false;\r\n        }\r\n    };\r\n}\r\nexports.getObjectRefCounter = getObjectRefCounter;\r\n/**\r\n * Ref counts strings\r\n */\r\nfunction getStringRefCounter() {\r\n    var values = {};\r\n    return {\r\n        /**\r\n         * Returns current ref count for the key\r\n         */\r\n        getCount: function (key) {\r\n            if (key === undefined || key === null) {\r\n                return 0;\r\n            }\r\n            return values[key] || 0;\r\n        },\r\n        /**\r\n         * Adds given key for ref counting or increments ref count\r\n         */\r\n        add: function (key) {\r\n            if (key === undefined || key === null) {\r\n                return;\r\n            }\r\n            if (!values[key]) {\r\n                values[key] = 1;\r\n            }\r\n            else {\r\n                values[key]++;\r\n            }\r\n        },\r\n        /**\r\n         * Decreases ref count for the given key, if the ref count reaches 0 removes the key and returns true\r\n         */\r\n        remove: function (key) {\r\n            if (key === undefined || key === null) {\r\n                return false;\r\n            }\r\n            if (!values[key]) {\r\n                return false;\r\n            }\r\n            if (values[key] === 1) {\r\n                delete values[key];\r\n                return true;\r\n            }\r\n            values[key]--;\r\n            return false;\r\n        }\r\n    };\r\n}\r\nexports.getStringRefCounter = getStringRefCounter;\r\n","\"use strict\";\r\nfunction __export(m) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\nexports.__esModule = true;\r\n__export(require(\"./ModuleStore\"));\r\n__export(require(\"./Utils/ComparableMap\"));\r\n__export(require(\"./Utils/RefCounter\"));\r\n__export(require(\"./Managers/MiddlewareManager\"));\r\n__export(require(\"./Managers/RefCountedManager\"));\r\n//Dummy change to keep lerna happy\r\n","\"use strict\";\r\nvar __extends = (this && this.__extends) || (function () {\r\n    var extendStatics = function (d, b) {\r\n        extendStatics = Object.setPrototypeOf ||\r\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n        return extendStatics(d, b);\r\n    };\r\n    return function (d, b) {\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n})();\r\nvar __assign = (this && this.__assign) || function () {\r\n    __assign = Object.assign || function(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\r\n                t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\r\nexports.__esModule = true;\r\nvar React = require(\"react\");\r\n//@ts-ignore // ReactReduxContext is not officially exported\r\nvar react_redux_1 = require(\"react-redux\");\r\n/**\r\n * The DynamicModuleLoader adds a way to register a module on mount\r\n * When this component is initialized, the reducer and saga from the module passed as props will be registered with the system\r\n * On unmount, they will be unregistered\r\n */\r\nvar DynamicModuleLoader = /** @class */ (function (_super) {\r\n    __extends(DynamicModuleLoader, _super);\r\n    function DynamicModuleLoader() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    DynamicModuleLoader.prototype.render = function () {\r\n        var _this = this;\r\n        return (React.createElement(react_redux_1.ReactReduxContext.Consumer, null, function (reactReduxContext) { return (React.createElement(DynamicModuleLoaderImpl, __assign({}, _this.props, { reactReduxContext: reactReduxContext }))); }));\r\n    };\r\n    return DynamicModuleLoader;\r\n}(React.Component));\r\nexports.DynamicModuleLoader = DynamicModuleLoader;\r\nvar DynamicModuleLoaderImpl = /** @class */ (function (_super) {\r\n    __extends(DynamicModuleLoaderImpl, _super);\r\n    function DynamicModuleLoaderImpl(props) {\r\n        var _this = _super.call(this, props) || this;\r\n        /** Flag that indicates we need to create a store/provider because a parent store was not provided */\r\n        _this._providerInitializationNeeded = false;\r\n        /**\r\n         * Unregister sagas and reducers\r\n         */\r\n        _this._cleanup = function () {\r\n            if (_this._addedModules) {\r\n                _this._addedModules.remove();\r\n                _this._addedModules = undefined;\r\n            }\r\n        };\r\n        if (props.reactReduxContext == null) {\r\n            var message = \"Tried to render DynamicModuleLoader, but no ReactReduxContext was provided\";\r\n            console.error(message);\r\n            throw new Error(message);\r\n        }\r\n        _this._store = props.reactReduxContext\r\n            ? props.reactReduxContext.store\r\n            : undefined;\r\n        // We are not in strict mode, let's add the modules ASAP\r\n        if (!_this.props.strictMode) {\r\n            _this._addModules();\r\n            _this.state = { readyToRender: true };\r\n        }\r\n        else {\r\n            // We are in strict mode, so have to wait for CDM to add modules.\r\n            // Thus, we cannot render the children at this time\r\n            _this.state = { readyToRender: false };\r\n        }\r\n        return _this;\r\n    }\r\n    DynamicModuleLoaderImpl.prototype.render = function () {\r\n        if (this.state.readyToRender) {\r\n            if (this._providerInitializationNeeded) {\r\n                return (React.createElement(react_redux_1.Provider, { store: this._store },\r\n                    React.createElement(DynamicModuleLoader, __assign({}, this.props))));\r\n            }\r\n            return (React.createElement(React.Fragment, null,\r\n                this._renderLoader(),\r\n                React.createElement(AddedModulesCleanup, { cleanup: this._cleanup })));\r\n        }\r\n        return null;\r\n    };\r\n    /**\r\n     * Render a Redux provider\r\n     */\r\n    DynamicModuleLoaderImpl.prototype._renderLoader = function () {\r\n        return this.props.children\r\n            ? typeof this.props.children === \"function\"\r\n                ? this.props.children()\r\n                : this.props.children\r\n            : null;\r\n    };\r\n    DynamicModuleLoaderImpl.prototype._addModules = function () {\r\n        var _a = this.props, createStore = _a.createStore, modules = _a.modules;\r\n        if (!this._store) {\r\n            // If we need to create a store, do that here. We will skip adding the modules and render DML again\r\n            if (createStore) {\r\n                this._store = createStore();\r\n                this._providerInitializationNeeded = true;\r\n            }\r\n            else {\r\n                throw new Error(\"Store could not be resolved from React context\");\r\n            }\r\n        }\r\n        else {\r\n            // Add the modules here\r\n            this._addedModules = this._store.addModules(modules);\r\n        }\r\n    };\r\n    DynamicModuleLoaderImpl.prototype.componentDidMount = function () {\r\n        if (this.props.strictMode) {\r\n            this._addModules();\r\n            this.setState({ readyToRender: true });\r\n        }\r\n    };\r\n    return DynamicModuleLoaderImpl;\r\n}(React.Component));\r\n/**\r\n * This component is rendered as the last child of DynamicModuleLoaderImpl\r\n * so react runs willUnmount on connected(react-redux) children before this\r\n * cleanup and allows them to unsubscribe from store before dynamic reducers\r\n * removing (and avoid errors in selectors)\r\n */\r\nvar AddedModulesCleanup = /** @class */ (function (_super) {\r\n    __extends(AddedModulesCleanup, _super);\r\n    function AddedModulesCleanup() {\r\n        return _super !== null && _super.apply(this, arguments) || this;\r\n    }\r\n    AddedModulesCleanup.prototype.render = function () {\r\n        return null;\r\n    };\r\n    AddedModulesCleanup.prototype.componentWillUnmount = function () {\r\n        this.props.cleanup();\r\n    };\r\n    return AddedModulesCleanup;\r\n}(React.Component));\r\n","\"use strict\";\r\nfunction __export(m) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\nexports.__esModule = true;\r\n__export(require(\"redux-dynamic-modules-core\"));\r\n__export(require(\"./DynamicModuleLoader\"));\r\n","'use strict';\nmodule.exports = function (str) {\n\treturn encodeURIComponent(str).replace(/[!'()*]/g, function (c) {\n\t\treturn '%' + c.charCodeAt(0).toString(16).toUpperCase();\n\t});\n};\n"],"names":["MomentUtils","_a","_b","locale","instance","moment","this","yearFormat","yearMonthFormat","dateTime12hFormat","dateTime24hFormat","time12hFormat","time24hFormat","dateFormat","prototype","parse","value","format","date","isValid","isNull","getDiff","comparing","diff","isAfter","isBefore","isAfterDay","isBeforeDay","isBeforeYear","isAfterYear","startOfDay","clone","startOf","endOfDay","endOf","formatString","formatNumber","numberToFormat","getHours","get","addDays","count","subtract","Math","abs","add","setHours","hours","getMinutes","setMinutes","minutes","getSeconds","setSeconds","seconds","getMonth","isSameDay","isSame","isSameMonth","isSameYear","isSameHour","setMonth","month","getMeridiemText","ampm","startOfMonth","endOfMonth","getNextMonth","getPreviousMonth","getMonthArray","monthArray","length","prevMonth","push","getYear","setYear","year","set","mergeDateAndTime","time","getWeekdays","weekdaysShort","isEqual","getWeekArray","start","end","current","nestedWeeks","weekNumber","floor","getYearRange","startDate","endDate","years","getCalendarHeaderText","getYearText","getDatePickerHeaderText","getDateTimePickerHeaderText","getMonthText","getDayText","getHourText","getMinuteText","getSecondText","oppositeDirection","left","right","top","bottom","isHorizontal","anchor","indexOf","getAnchor","theme","direction","defaultTransitionDuration","enter","exit","Drawer","props","ref","_props$anchor","anchorProp","BackdropProps","children","classes","className","_props$elevation","elevation","_props$ModalProps","ModalProps","BackdropPropsProp","onClose","_props$open","open","_props$PaperProps","PaperProps","SlideProps","_props$TransitionComp","TransitionComponent","_props$transitionDura","transitionDuration","_props$variant","variant","other","mounted","drawer","square","paper","concat","root","docked","slidingDrawer","in","timeout","appear","BackdropComponent","modal","flex","overflowY","display","flexDirection","height","zIndex","WebkitOverflowScrolling","position","outline","paperAnchorLeft","paperAnchorRight","paperAnchorTop","maxHeight","paperAnchorBottom","paperAnchorDockedLeft","borderRight","palette","divider","paperAnchorDockedTop","borderBottom","paperAnchorDockedRight","borderLeft","paperAnchorDockedBottom","borderTop","name","flip","setTranslateValue","node","transform","rect","getBoundingClientRect","fakeTransform","computedStyle","window","getComputedStyle","getPropertyValue","offsetX","offsetY","transformValues","split","parseInt","innerWidth","width","innerHeight","getTranslateValue","style","webkitTransform","defaultTimeout","_props$direction","inProp","onEnter","onEntered","onEntering","onExit","onExited","onExiting","_props$timeout","childrenRef","handleOwnRef","handleRefIntermediary","handleRef","normalizedTransitionCallback","callback","isAppearing","undefined","handleEnter","handleEntering","transitionProps","mode","webkitTransition","transitions","create","easing","easeOut","transition","handleEntered","handleExiting","handleExit","sharp","handleExited","updatePosition","handleResize","addEventListener","clear","removeEventListener","nodeRef","state","childProps","visibility","_interopRequireDefault","exports","_react","_default","default","createElement","d","path","Component","SvgIcon","muiName","globalScope","Decimal","inexact","quadrant","EXP_LIMIT","MAX_DIGITS","NUMERALS","LN10","PI","DEFAULTS","precision","rounding","modulo","toExpNeg","toExpPos","minE","maxE","crypto","external","decimalError","invalidArgument","precisionLimitExceeded","cryptoUnavailable","mathfloor","mathpow","pow","isBinary","isHex","isOctal","isDecimal","BASE","LN10_PRECISION","PI_PRECISION","P","digitsToString","i","k","ws","indexOfLastWord","str","w","getZeroString","checkInt32","min","max","Error","checkRoundingDigits","rm","repeating","di","r","rd","ceil","convertBase","baseIn","baseOut","j","arrL","arr","strL","charAt","reverse","absoluteValue","x","constructor","s","finalise","e","comparedTo","cmp","y","xdL","ydL","xd","yd","xs","ys","NaN","cosine","cos","pr","Ctor","sd","len","tinyPow","toString","taylorSeries","times","cos2x","minus","plus","toLessThanHalfPi","neg","cubeRoot","cbrt","m","n","rep","t","t3","t3plusx","isFinite","isZero","toExponential","slice","divide","eq","decimalPlaces","dp","dividedBy","div","dividedToIntegerBy","divToInt","equals","greaterThan","gt","greaterThanOrEqualTo","gte","hyperbolicCosine","cosh","one","cosh2_x","d8","hyperbolicSine","sinh","sqrt","sinh2_x","d5","d16","d20","hyperbolicTangent","tanh","inverseCosine","acos","halfPi","isNeg","getPi","asin","inverseHyperbolicCosine","acosh","lte","ln","inverseHyperbolicSine","asinh","inverseHyperbolicTangent","atanh","wpr","xsd","inverseSine","atan","inverseTangent","px","x2","isInteger","isInt","isNaN","isNegative","isPositive","isPos","lessThan","lt","lessThanOrEqualTo","logarithm","log","base","isBase10","denominator","inf","num","arg","naturalLogarithm","getLn10","sub","xe","xLTy","pop","shift","getBase10Exponent","mod","q","naturalExponential","exp","negated","carry","unshift","z","getPrecision","round","sine","sin","sin2_x","squareRoot","tangent","tan","mul","rL","toBinary","toStringBinary","toDecimalPlaces","toDP","finiteToString","toFixed","toFraction","maxD","d0","d1","d2","n0","n1","toHexadecimal","toHex","toNearest","toNumber","toOctal","toPower","yn","intPow","toPrecision","toSignificantDigits","toSD","truncated","trunc","valueOf","toJSON","multiplyInteger","temp","compare","a","b","aL","bL","logBase","more","prod","prodL","qd","rem","remL","rem0","xi","xL","yd0","yL","yz","sign","isTruncated","digits","roundUp","xdi","out","isExp","nonFiniteToString","zs","truncate","isOdd","maxOrMin","args","ltgt","guard","sum","c","c0","numerator","x1","String","parseDecimal","replace","search","substring","charCodeAt","parseOther","divisor","isFloat","p","test","toLowerCase","isHyperbolic","u","pi","atan2","config","obj","v","useDefaults","defaults","ps","getRandomValues","randomBytes","hypot","arguments","isDecimalInstance","log2","log10","random","Uint32Array","copy","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","hasOwnProperty","token","singleMatcher","RegExp","multiMatcher","decodeComponents","components","decodeURIComponent","join","err","Array","call","decode","input","tokens","match","module","encodedURI","TypeError","replaceMap","exec","result","entries","Object","keys","key","customDecodeURIComponent","getOwnPropertySymbols","propIsEnumerable","propertyIsEnumerable","toObject","val","assign","test1","getOwnPropertyNames","test2","fromCharCode","map","test3","forEach","letter","shouldUseNative","target","source","from","symbols","to","strictUriEncode","objectAssign","decodeComponent","encode","opts","strict","encodeURIComponent","keysSorter","isArray","sort","Number","extract","formatter","arrayFormat","accumulator","parserForArrayFormat","ret","trim","param","parts","reduce","Boolean","stringify","index","encoderForArrayFormat","val2","filter","compose","__esModule","composeWithDevTools","apply","devToolsEnhancer","noop","createDynamicMiddlewares","resetMiddlewares","removeMiddleware","addMiddleware","_redux","allDynamicMiddlewares","enhancer","store","next","action","chain","middleware","_len","middlewares","_key","findIndex","_","mdwIndex","console","error","dynamicMiddlewaresInstance","redux_dynamic_middlewares_1","getMiddlewareManager","getItems","remove","dispose","__spreadArrays","il","jl","ReducerManager_1","getModuleManager","middlewareManager","extensions","advancedCombineReducers","_reducerManager","_dispatch","_modules","_moduleIds","Set","_dispatchActions","actions","moduleManager","getReducer","setDispatch","dispatch","modulesToAdd","justAddedModules","has","id","reducerMap","getRefCountedReducerManager","getReducerManager","_addReducers","_addMiddlewares","type","onModuleAdded","moduleAddedAction","payload","initialActions","modulesToRemove","finalActions","_removeReducers","onModuleRemoved","__assign","redux_1","RefCounter_1","getCombinedReducer","reducerCombiner","combineReducers","manager","reducerKeyRefCounter","getStringRefCounter","getReducerMap","reducer","getCount","initialReducers","combinedReducer","reducers","keysToRemove","_i","keysToRemove_1","getRefCountedManager","retained","refCounter","getObjectRefCounter","item","items","nonNullItems","notAddedItems","developmentOnly_1","MiddlewareManager_1","ModuleManager_1","RefCountedManager_1","Flatten_1","createStore","moduleStoreSettings","initialModules","initialState","_c","enhancers","_d","advancedComposeEnhancers","extensionMiddleware","mw","applyMiddleware","addModules","modulesToBeAdded","flattenedModules","flatten","addModule","moduleToBeAdded","onModuleManagerCreated","getMap","values","res","splice","objects","counts","o","Infinity","__export","extendStatics","__extends","setPrototypeOf","__proto__","__","React","react_redux_1","DynamicModuleLoader","_super","render","_this","ReactReduxContext","Consumer","reactReduxContext","DynamicModuleLoaderImpl","_providerInitializationNeeded","_cleanup","_addedModules","message","_store","strictMode","readyToRender","_addModules","Provider","Fragment","_renderLoader","AddedModulesCleanup","cleanup","modules","componentDidMount","setState","componentWillUnmount","toUpperCase"],"sourceRoot":""}