/* WEBPACK VAR INJECTION */

/* eslint react/destructuring-assignment: 1 */

/* eslint react/no-array-index-key: 0 */

/* eslint-disable camelcase */

/* eslint-disable jsx-a11y/click-events-have-key-events */

/* eslint-disable jsx-a11y/no-static-element-interactions */

/* eslint-disable no-bitwise */

/* eslint-disable react/forbid-foreign-prop-types */

/* eslint-enable jsx-a11y/click-events-have-key-events */

/* eslint-enable jsx-a11y/no-static-element-interactions */

/* harmony default export */

/* harmony export (binding) */

/* harmony import */

/* istanbul ignore else  */

/* istanbul ignore next */

/*#__PURE__*/

/**
   * Cache for storing the results of computations:
   * `WeakMap<Theme, WeakMap<typeof WithStyles, { ltr: {}, rtl: {} }>>`
   * Falling back to `Map` whenever `WeakMap` is not supported
   */

/**
 * A higher order function that returns a higher order class component that injects
 * CSS-in-JS props derived from the react-with-styles theme, interface, and
 * direction provided through the WithStylesContext provider.
 *
 * The function should be used as follows:
 * `withStyles((theme) => styles, options)(Component)`
 *
 * Options can be used to rename the injected props, memoize the component, and flush
 * the styles to the styles tag (or whatever the interface implements as flush) before
 * rendering.
 *
 * @export
 * @param {Function|null|undefined} [stylesFn=EMPTY_STYLES_FN]
 * @param {Object} [{
 *     stylesPropName = 'styles',
 *     themePropName = 'theme',
 *     cssPropName = 'css',
 *     flushBefore = false,
 *     pureComponent = false,
 *   }={}]
 * @returns a higher order component that wraps the provided component and injects
 * the react-with-styles css, styles, and theme props.
 */

/**
 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the raw `toStringTag`.
 */

/**
 * Calculate and return a CSS transform style to position a detached element
 * next to a reference element. The open and anchor direction indicate wether
 * it should be positioned above/below and/or to the left/right of the
 * reference element.
 *
 * Assuming r(0,0), r(1,1), d(0,0), d(1,1) for the bottom-left and top-right
 * corners of the reference and detached elements, respectively:
 *  - openDirection = DOWN, anchorDirection = LEFT => d(0,1) == r(0,1)
 *  - openDirection = UP, anchorDirection = LEFT => d(0,0) == r(0,0)
 *  - openDirection = DOWN, anchorDirection = RIGHT => d(1,1) == r(1,1)
 *  - openDirection = UP, anchorDirection = RIGHT => d(1,0) == r(1,0)
 *
 * By using a CSS transform, we allow to further position it using
 * top/bottom CSS properties for the anchor gutter.
 *
 * @param {string} openDirection The vertical positioning of the popup
 * @param {string} anchorDirection The horizontal position of the popup
 * @param {HTMLElement} referenceEl The reference element
 */

/**
 * Checks if `value` is classified as a `Symbol` primitive or object.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
 * @example
 *
 * _.isSymbol(Symbol.iterator);
 * // => true
 *
 * _.isSymbol('abc');
 * // => false
 */

/**
 * Checks if `value` is object-like. A value is object-like if it's not `null`
 * and has a `typeof` result of "object".
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
 * @example
 *
 * _.isObjectLike({});
 * // => true
 *
 * _.isObjectLike([1, 2, 3]);
 * // => true
 *
 * _.isObjectLike(_.noop);
 * // => false
 *
 * _.isObjectLike(null);
 * // => false
 */

/**
 * Checks if `value` is the
 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Lang
 * @param {*} value The value to check.
 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
 * @example
 *
 * _.isObject({});
 * // => true
 *
 * _.isObject([1, 2, 3]);
 * // => true
 *
 * _.isObject(_.noop);
 * // => true
 *
 * _.isObject(null);
 * // => false
 */

/**
 * Converts `value` to a number.
 *
 * @static
 * @memberOf _
 * @since 4.0.0
 * @category Lang
 * @param {*} value The value to process.
 * @returns {number} Returns the number.
 * @example
 *
 * _.toNumber(3.2);
 * // => 3.2
 *
 * _.toNumber(Number.MIN_VALUE);
 * // => 5e-324
 *
 * _.toNumber(Infinity);
 * // => Infinity
 *
 * _.toNumber('3.2');
 * // => 3.2
 */

/**
 * Converts `value` to a string using `Object.prototype.toString`.
 *
 * @private
 * @param {*} value The value to convert.
 * @returns {string} Returns the converted string.
 */

/**
 * Creates a debounced function that delays invoking `func` until after `wait`
 * milliseconds have elapsed since the last time the debounced function was
 * invoked. The debounced function comes with a `cancel` method to cancel
 * delayed `func` invocations and a `flush` method to immediately invoke them.
 * Provide `options` to indicate whether `func` should be invoked on the
 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
 * with the last arguments provided to the debounced function. Subsequent
 * calls to the debounced function return the result of the last `func`
 * invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on the trailing edge of the timeout only if the debounced function
 * is invoked more than once during the `wait` timeout.
 *
 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
 * for details over the differences between `_.debounce` and `_.throttle`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to debounce.
 * @param {number} [wait=0] The number of milliseconds to delay.
 * @param {Object} [options={}] The options object.
 * @param {boolean} [options.leading=false]
 *  Specify invoking on the leading edge of the timeout.
 * @param {number} [options.maxWait]
 *  The maximum time `func` is allowed to be delayed before it's invoked.
 * @param {boolean} [options.trailing=true]
 *  Specify invoking on the trailing edge of the timeout.
 * @returns {Function} Returns the new debounced function.
 * @example
 *
 * // Avoid costly calculations while the window size is in flux.
 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 *
 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
 * jQuery(element).on('click', _.debounce(sendMail, 300, {
 *   'leading': true,
 *   'trailing': false
 * }));
 *
 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
 * var source = new EventSource('/stream');
 * jQuery(source).on('message', debounced);
 *
 * // Cancel the trailing debounced invocation.
 * jQuery(window).on('popstate', debounced.cancel);
 */

/**
 * Creates a throttled function that only invokes `func` at most once per
 * every `wait` milliseconds. The throttled function comes with a `cancel`
 * method to cancel delayed `func` invocations and a `flush` method to
 * immediately invoke them. Provide `options` to indicate whether `func`
 * should be invoked on the leading and/or trailing edge of the `wait`
 * timeout. The `func` is invoked with the last arguments provided to the
 * throttled function. Subsequent calls to the throttled function return the
 * result of the last `func` invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on the trailing edge of the timeout only if the throttled function
 * is invoked more than once during the `wait` timeout.
 *
 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
 * for details over the differences between `_.throttle` and `_.debounce`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to throttle.
 * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
 * @param {Object} [options={}] The options object.
 * @param {boolean} [options.leading=true]
 *  Specify invoking on the leading edge of the timeout.
 * @param {boolean} [options.trailing=true]
 *  Specify invoking on the trailing edge of the timeout.
 * @returns {Function} Returns the new throttled function.
 * @example
 *
 * // Avoid excessively updating the position while scrolling.
 * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
 *
 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
 * jQuery(element).on('click', throttled);
 *
 * // Cancel the trailing throttled invocation.
 * jQuery(window).on('popstate', throttled.cancel);
 */

/**
 * Deprecated: Do not use directly. Please wrap your component in `withStyles` and use the `css`
 * prop injected via props instead.
 */

/**
 * Disabling the scroll on a node involves finding all the scrollable ancestors
 * and set their 'overflow-y' CSS property to 'hidden'. When all ancestors have
 * 'overflow-y: hidden' (up to the document element) there is no scroll
 * container, thus all the scroll outside of the node is disabled. In order to
 * enable scroll again, we store the previous value of the 'overflow-y' for
 * every ancestor in a closure and reset it back.
 *
 * @param {HTMLElement} node Any DOM element.
 */

/**
 * Generate a unique key for any set of event options
 */

/**
 * Gets the timestamp of the number of milliseconds that have elapsed since
 * the Unix epoch (1 January 1970 00:00:00 UTC).
 *
 * @static
 * @memberOf _
 * @since 2.4.0
 * @category Date
 * @returns {number} Returns the timestamp.
 * @example
 *
 * _.defer(function(stamp) {
 *   console.log(_.now() - stamp);
 * }, _.now());
 * // => Logs the number of milliseconds it took for the deferred invocation.
 */

/**
 * Recursively finds the scroll parent of a node. The scroll parrent of a node
 * is the closest node that is scrollable. A node is scrollable if:
 *  - it is allowed to scroll via CSS ('overflow-y' not visible or hidden);
 *  - and its children/content are "bigger" than the node's box height.
 *
 * The root of the document always scrolls by default.
 *
 * @param {HTMLElement} node Any DOM element.
 * @return {HTMLElement} The scroll parent element.
 */

/**
 * Recursively traverses the tree upwards from the given node, capturing all
 * ancestor nodes that scroll along with their current 'overflow-y' CSS
 * property.
 *
 * @param {HTMLElement} node Any DOM element.
 * @param {Map<HTMLElement,string>} [acc] Accumulator map.
 * @return {Map<HTMLElement,string>} Map of ancestors with their 'overflow-y' value.
 */

/**
 * The base implementation of `getTag` without fallbacks for buggy environments.
 *
 * @private
 * @param {*} value The value to query.
 * @returns {string} Returns the `toStringTag`.
 */

/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */

/** Built-in value references. */

/** Cache for storing the result of stylesFn(theme) for all themes. */

/** Derive the create function from the interface and direction */

/** Derive the resolve function from the interface and direction */

/** Detect free variable `global` from Node.js. */

/** Detect free variable `self`. */

/** Error message constants. */

/** Used as references for various `Number` constants. */

/** Used for built-in method references. */

/** `Object#toString` result references. */

/***/

/**/

//

//   Cannot read property 'removeEventListener' of undefined

// !enableOutsideDays

// - https://github.com/facebook/react/issues/6410

// -- not the instance -- so we only apply the theme to the stylesFn

// Adapted from Modernizr

// All event handlers have been removed, so we want to remove the event

// Appends a noflip comment to a style rule in order to prevent it from being automatically

// Apply margin

// Because the close button is the only focusable element inside of the panel, this

// Bound parameter to allow user to add dynamic validation

// Bound parameter to indicate with the propType is required

// Calculating the dimensions trigger a DOM repaint which

// Capture the scroll position so when previous months are rendered above the current month

// Clear queue here to prevent

// Cloning is a little expensive, so we want to do it as little as possible.

// Compare least significant, most likely to change units first

// Copy the wrapped component's prop types and default props on WithStyles

// DayPicker props

// Disable scroll for every ancestor of this DateRangePicker up to the

// Either this is the first call, activity has stopped and we're at the

// Fallback to the singleton implementation

// Flush if specified

// For IE9, immediately call onMonthTransitionEnd instead of

// For reference, this issue is further described here:

// Generated by CoffeeScript 1.12.2

// Get and store the result in the stylesFnResultsCache for the component

// Get the inner size

// Get the styles interface, theme, and direction from context

// Handle invocations in a tight loop.

// IE 8 has a broken gOPD

// If orientation is VERTICAL_SCROLLABLE and currentMonth has changed adjust scrollTop so the

// If the browser does not support passive event listeners, the normalized

// If the interface and theme haven't changed for this direction,

// If the theme or the interface changed, then there are some values

// If the user doesn't set a desired height,

// If there was a month transition, do not update the focused date until the transition has

// In Safari, onKeyDown does not consistently fire ahead of onChange. As a result, we need to

// In cases where **relatedTarget** is not null, it points to the right

// Invoke the leading edge.

// It's possible the portal props have been changed in response to window resizes

// Moment's isSame clones moment inputs and is a tad slow

// NOTE: We are using a manual event listener here, because React doesn't

// Only invoke if we have `lastArgs` which means `func` has been

// Reset any `maxWait` timer.

// Restart the timer.

// So let's ensure we reset this back to the base state each time

// Some versions of FF have rAF but not cAF

// Start the timer for the trailing edge.

// TODO: should be noflip wrapped and handled by an isRTL prop

// TODO: use null

// Template strings compiled in strict mode uses concat, which is slow. Since

// Test for A's keys different from B.

// The date picker just changed from being closed to being open.

// The date picker just changed from being open to being closed.

// The function that wraps the provided component in a wrapper

// The setTimeout will wait until the transition ends.

// The wrapper component that injects the withStyles props

// There can be a race condition where the target may no longer exist

// These values are in context so we're listening for their updates.

// These values are to center the datepicker (approximately) on the page

// This file is a fallback for a consumer who is not yet on React 16

// This higher-order component consumes a string from React context that is

// Translation value is a hack to force an invisible transition that

// Update the cache with all the new values

// We can use this to conditionally switch layout/direction for right-to-left layouts.

// We handle both situations here by using the ` || ` operator to fallback

// We need to check for presence here because a handler function may

// We only want to re-render if the theme, stylesInterface, or direction change.

// When the datepicker is full screen, we never want to focus the end date first

// Wrap in a new function to prevent

// `cancel` potentially being assigned

// `useCapture` is set to true by default so that a `stopPropagation` in the

// accessibility

// accessibility props

// adapted from https://github.com/facebook/react/blob/144328fe81719e916b946e22660479e31561bb0b/packages/shared/shallowEqual.js#L36-L68

// amounts to a very basic focus trap. The user can exit the panel by "pressing" the

// as createPortal was introduced in React 16

// automatically move focus into the dialog by moving

// because there's no indication that that is the case once the datepicker is open and it

// breaks the CSS transition.

// cache the result of stylesFn(theme)

// calculated in the past if the objects they're derived from have not

// calendar presentation and interaction related props

// calendar presentation props

// callbacks from appending listeners

// cause later handlers to get removed. This can happen if you for

// changed.

// children will not prevent all outside click handlers from firing - maja

// close button or hitting escape

// completed. Otherwise, attempting to focus on a DOM node may interrupt the CSS animation. If

// completely block the rest of the keys that have functionality outside of this panel

// component that injects the withStyles props

// context, and memoizes them on the instance per direction.

// day presentation and interaction related props

// day props

// days belonging to the next month

// days belonging to the previous month

// debounced at least once.

// default behavior of scrolling the content of the Keyboard Shortcuts Panel

// didTransitionMonth is true, the focusedDate gets updated in #updateStateAfterMonthTransition

// do nothing

// do nothing - this allows the up and down arrows continue their

// document level. This ensures the input and the picker never move. Other

// element here. However, in cases where it is null (such as clicking on a

// english locale

// eslint-disable-line jsx-a11y/interactive-supports-focus

// eslint-disable-line react/forbid-prop-types

// eslint-disable-next-line getter-return

// eslint-disable-next-line import/no-unresolved

// eslint-disable-next-line import/prefer-default-export

// eslint-disable-next-line no-param-reassign

// eslint-disable-next-line prefer-template

// eslint-disable-next-line react/destructuring-assignment

// event options will be a boolean.

// export for convenience, in order for components to spread these onto their propTypes

// flipped in RTL contexts. This should be used only in situations where the style must remain

// https://gist.github.com/jimfb/d99e0678e9da715ccf6454961ef04d1b

// https://github.com/Modernizr/Modernizr/blob/acb3f0d9/feature-detects/dom/passiveeventlisteners.js#L26-L37

// i18n

// if the user is navigating around using a mouse

// initialize phrases

// input related props

// instance have a waypoint that unmounts another waypoint as part of an

// internationalization

// internationalization props

// is not handled by isRTL

// is set to 0, also immediately invoke the onMonthTransitionEnd callback

// it as the trailing edge, or we've hit the `maxWait` limit.

// listener from the target node.

// might confuse the user

// modifying the input value

// month props

// navigation props

// navigation related props

// needed in order to know whether we have left focus or not.

// new months rendered above the current month don't push the current month out of view.

// no styles applied to the vertical-scrollable orientation

// onEnter/onLeave handler.

// once per theme for this component.

// options has already been normalized at this point.

// passing in context-specific props

// properly rerenders the CalendarMonthGrid

// provide FocusOut, while blur and keydown don't provide the information

// provided by the DirectionProvider component.

// required props for a functional interactive DateRangePicker

// set a default direction so that a component wrapped with this HOC can be

// set the appropriate CalendarDay phrase based on focusedInput

// set utc offset to get correct dates in future (when timezone changes)

// sibling elements or the picker itself can scroll.

// special case the `?` key so that it always triggers the appropriate callback, instead of

// specific day) or it is **document.body** (IE11), the appropriate value is **event.target**.

// stays in view.

// subscribe to future direction changes

// the ? shortcut came from the input and we should return input there once it is close

// this code is in a hot path and we want it to be as fast as possible, we

// this.getProps() derives the props from the theme, stylesInterface, and direction in

// to *event.target** when **relatedTarget** is not provided.

// to the current frame's queue

// to the native rAF function

// to the only interactive element, the hide button

// trailing edge, the system time has gone backwards and we're treating

// unflipped regardless of direction context. See: https://github.com/kentcdodds/rtl-css-js#usage

// unmounting. Guarding against this prevents the following error:

// used even without a DirectionProvider ancestor in its react tree.

// waiting for the animation to complete. Similarly, if transitionDuration

// want to use old-fashioned +.

// we can adjust scroll after the component has updated and the previous current month

// we default back to this kind of made-up value that generally looks good

// we don't want to focus on the relevant calendar day after a month transition

// we need to recalculate. We avoid recalculating the ones we already

// we return the cached props immediately.

// we want to return focus to this button after closing the keyboard shortcuts panel

// when this function is called, e.g. when a React component is

// which is needed when only a single month is shown for instance.

//# sourceMappingURL=data:application/json;charset=utf-8;base64, 

//# sourceMappingURL=getComponentName.js.map

//# sourceMappingURL=index.js.map

//# sourceMappingURL=performance-now.js.map
