})(DayPickerKeyboardShortcuts);
/***/ (function(module, exports, __webpack_require__) {
var GetIntrinsic = __webpack_require__("AM7I");
var $TypeError = GetIntrinsic('%TypeError%');
var $SyntaxError = GetIntrinsic('%SyntaxError%');
var has = __webpack_require__("oNNP");
// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type
'Property Descriptor': function isPropertyDescriptor(Type, Desc) {
if (Type(Desc) !== 'Object') {
'[[Configurable]]': true,
for (var key in Desc) { // eslint-disable-line
if (has(Desc, key) && !allowed[key]) {
var isData = has(Desc, '[[Value]]');
var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');
if (isData && IsAccessor) {
throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');
module.exports = function assertRecord(Type, recordType, argumentName, value) {
var predicate = predicates[recordType];
if (typeof predicate !== 'function') {
throw new $SyntaxError('unknown record type: ' + recordType);
if (!predicate(Type, value)) {
throw new $TypeError(argumentName + ' must be a ' + recordType);
/***/ (function(module, exports, __webpack_require__) {
* Copyright (c) 2013-present, Facebook, Inc.
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
var ReactPropTypesSecret = __webpack_require__("WbBG");
function emptyFunction() {}
function emptyFunctionWithReset() {}
emptyFunctionWithReset.resetWarningCache = emptyFunction;
module.exports = function() {
function shim(props, propName, componentName, location, propFullName, secret) {
if (secret === ReactPropTypesSecret) {
// It is still safe when called from React.
'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
'Use PropTypes.checkPropTypes() to call them. ' +
'Read more at http://fb.me/use-check-prop-types'
err.name = 'Invariant Violation';
// Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
checkPropTypes: emptyFunctionWithReset,
resetWarningCache: emptyFunction
ReactPropTypes.PropTypes = ReactPropTypes;
/***/ (function(module, exports, __webpack_require__) {
* Copyright (c) 2013-present, Facebook, Inc.
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
if (false) { var throwOnDirectAccess, ReactIs; } else {
// By explicitly using `prop-types` you are opting into new production behavior.
// http://fb.me/prop-types-in-prod
module.exports = __webpack_require__("16Al")();
/***/ (function(module, exports) {
(function() { module.exports = window["wp"]["dom"]; }());
/***/ (function(module, exports, __webpack_require__) {
var toStr = Object.prototype.toString;
module.exports = function isArguments(value) {
var str = toStr.call(value);
var isArgs = str === '[object Arguments]';
isArgs = str !== '[object Array]' &&
typeof value === 'object' &&
typeof value.length === 'number' &&
toStr.call(value.callee) === '[object Function]';
/***/ (function(module, __webpack_exports__, __webpack_require__) {
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
/***/ (function(module, __webpack_exports__, __webpack_require__) {
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addEventListener", function() { return addEventListener; });
var CAN_USE_DOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
// Adapted from Modernizr
// https://github.com/Modernizr/Modernizr/blob/acb3f0d9/feature-detects/dom/passiveeventlisteners.js#L26-L37
function testPassiveEventListeners() {
if (!window.addEventListener || !window.removeEventListener || !Object.defineProperty) {
var supportsPassiveOption = false;
var opts = Object.defineProperty({}, 'passive', {
// eslint-disable-next-line getter-return
supportsPassiveOption = true;
var noop = function noop() {};
window.addEventListener('testPassiveEventSupport', noop, opts);
window.removeEventListener('testPassiveEventSupport', noop, opts);
return supportsPassiveOption;
function canUsePassiveEventListeners() {
if (memoized === undefined) {
memoized = testPassiveEventListeners();
function normalizeEventOptions(eventOptions) {
if (!canUsePassiveEventListeners()) {
// If the browser does not support the passive option, then it is expecting
// a boolean for the options argument to specify whether it should use
// capture or not. In more modern browsers, this is passed via the `capture`
// option, so let's just hoist that value up.
return !!eventOptions.capture;
/* eslint-disable no-bitwise */
* Generate a unique key for any set of event options
function eventOptionsKey(normalizedEventOptions) {
if (!normalizedEventOptions) {
// If the browser does not support passive event listeners, the normalized
// event options will be a boolean.
if (normalizedEventOptions === true) {
// At this point, the browser supports passive event listeners, so we expect
// the event options to be an object with possible properties of capture,
// We want to consistently return the same value, regardless of the order of
// these properties, so let's use binary maths to assign each property to a
// bit, and then add those together (with an offset to account for the
// booleans at the beginning of this function).
var capture = normalizedEventOptions.capture << 0;
var passive = normalizedEventOptions.passive << 1;
var once = normalizedEventOptions.once << 2;
return capture + passive + once;
function ensureCanMutateNextEventHandlers(eventHandlers) {
if (eventHandlers.handlers === eventHandlers.nextHandlers) {
// eslint-disable-next-line no-param-reassign
eventHandlers.nextHandlers = eventHandlers.handlers.slice();
function TargetEventHandlers(target) {
TargetEventHandlers.prototype.getEventHandlers = function () {
function getEventHandlers(eventName, options) {
var key = String(eventName) + ' ' + String(eventOptionsKey(options));
this.events[key].nextHandlers = this.events[key].handlers;
TargetEventHandlers.prototype.handleEvent = function () {
function handleEvent(eventName, options, event) {
var eventHandlers = this.getEventHandlers(eventName, options);
eventHandlers.handlers = eventHandlers.nextHandlers;
eventHandlers.handlers.forEach(function (handler) {
// We need to check for presence here because a handler function may
// cause later handlers to get removed. This can happen if you for
// instance have a waypoint that unmounts another waypoint as part of an
// onEnter/onLeave handler.
TargetEventHandlers.prototype.add = function () {
function add(eventName, listener, options) {
// options has already been normalized at this point.
var eventHandlers = this.getEventHandlers(eventName, options);
ensureCanMutateNextEventHandlers(eventHandlers);
if (eventHandlers.nextHandlers.length === 0) {
eventHandlers.handleEvent = this.handleEvent.bind(this, eventName, options);
this.target.addEventListener(eventName, eventHandlers.handleEvent, options);
eventHandlers.nextHandlers.push(listener);
var unsubscribe = function () {
ensureCanMutateNextEventHandlers(eventHandlers);
var index = eventHandlers.nextHandlers.indexOf(listener);
eventHandlers.nextHandlers.splice(index, 1);
if (eventHandlers.nextHandlers.length === 0) {
// All event handlers have been removed, so we want to remove the event
// listener from the target node.
// There can be a race condition where the target may no longer exist
// when this function is called, e.g. when a React component is
// unmounting. Guarding against this prevents the following error:
// Cannot read property 'removeEventListener' of undefined
_this.target.removeEventListener(eventName, eventHandlers.handleEvent, options);
eventHandlers.handleEvent = undefined;
var EVENT_HANDLERS_KEY = '__consolidated_events_handlers__';
// eslint-disable-next-line import/prefer-default-export
function addEventListener(target, eventName, listener, options) {
if (!target[EVENT_HANDLERS_KEY]) {
// eslint-disable-next-line no-param-reassign
target[EVENT_HANDLERS_KEY] = new TargetEventHandlers(target);
var normalizedEventOptions = normalizeEventOptions(options);
return target[EVENT_HANDLERS_KEY].add(eventName, listener, normalizedEventOptions);
/***/ (function(module, __webpack_exports__, __webpack_require__) {
/* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("GRId");
/* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("Tqx9");
/* harmony import */ var _wordpress_primitives__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__);
var chevronRight = Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
xmlns: "http://www.w3.org/2000/svg",
}, Object(_wordpress_element__WEBPACK_IMPORTED_MODULE_0__["createElement"])(_wordpress_primitives__WEBPACK_IMPORTED_MODULE_1__["Path"], {
d: "M10.6 6L9.4 7l4.6 5-4.6 5 1.2 1 5.4-6z"
/* harmony default export */ __webpack_exports__["a"] = (chevronRight);
/***/ (function(module, __webpack_exports__, __webpack_require__) {
__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ createHook; });
// EXTERNAL MODULE: external "React"
var external_React_ = __webpack_require__("cDcd");
// EXTERNAL MODULE: ./node_modules/reakit/node_modules/reakit-system/es/SystemContext.js
var SystemContext = __webpack_require__("r4Od");
// CONCATENATED MODULE: ./node_modules/reakit/node_modules/reakit-system/es/useToken.js
* React custom hook that returns the value of any token defined in the
* SystemContext. It's mainly used internally in [`useOptions`](#useoptions)
* and [`useProps`](#useprops).
* import { SystemProvider, useToken } from "reakit-system";
* function Component(props) {
* const token = useToken("token", "default value");
* return <div {...props}>{token}</div>;
* <SystemProvider unstable_system={system}>
function useToken(token, defaultValue) {
Object(external_React_["useDebugValue"])(token);
var context = Object(external_React_["useContext"])(SystemContext["a" /* SystemContext */]);
return context[token] != null ? context[token] : defaultValue;
// CONCATENATED MODULE: ./node_modules/reakit/node_modules/reakit-system/es/useProps.js
* React custom hook that returns the props returned by a given
* `use${name}Props` in the SystemContext.