var proto = Object.getPrototypeOf(arg);
if (proto == null) return true;
return ((_proto$constructor = proto.constructor) === null || _proto$constructor === void 0 ? void 0 : _proto$constructor.toString()) === Object.toString();
// CONCATENATED MODULE: ./node_modules/reakit/node_modules/reakit-utils/es/splitProps.js
* Splits an object (`props`) into a tuple where the first item is an object
* with the passed `keys`, and the second item is an object with these keys
* @deprecated will be removed in version 2
* import { splitProps } from "reakit-utils";
* splitProps({ a: "a", b: "b" }, ["a"]); // [{ a: "a" }, { b: "b" }]
function __deprecatedSplitProps(props, keys) {
var propsKeys = Object.keys(props);
for (var _i = 0, _propsKeys = propsKeys; _i < _propsKeys.length; _i++) {
var key = _propsKeys[_i];
if (keys.indexOf(key) >= 0) {
picked[key] = props[key];
omitted[key] = props[key];
return [picked, omitted];
* Splits an object (`props`) into a tuple where the first item
* is the `state` property, and the second item is the rest of the properties.
* It is also backward compatible with version 1. If `keys` are passed then
* splits an object (`props`) into a tuple where the first item is an object
* with the passed `keys`, and the second item is an object with these keys
* import { splitProps } from "reakit-utils";
* splitProps({ a: "a", b: "b" }, ["a"]); // [{ a: "a" }, { b: "b" }]
* import { splitProps } from "reakit-utils";
* splitProps({ state: { a: "a" }, b: "b" }); // [{ a: "a" }, { b: "b" }]
function splitProps(props, keys) {
if (!isPlainObject(props.state)) {
return __deprecatedSplitProps(props, keys);
var _deprecatedSplitProp = __deprecatedSplitProps(props, [].concat(keys, ["state"])),
picked = _deprecatedSplitProp[0],
omitted = _deprecatedSplitProp[1];
var state = picked.state,
restPicked = Object(_rollupPluginBabelHelpers_1f0bf8c2["a" /* _ */])(picked, ["state"]);
return [Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])({}, state), restPicked), omitted];
// EXTERNAL MODULE: ./node_modules/reakit/node_modules/reakit-utils/es/shallowEqual.js
var shallowEqual = __webpack_require__("PU+x");
// CONCATENATED MODULE: ./node_modules/reakit/node_modules/reakit-utils/es/normalizePropsAreEqual.js
* This higher order functions take `propsAreEqual` function and
* returns a new function which normalizes the props.
* Normalizing in our case is making sure the `propsAreEqual` works with
* both version 1 (object spreading) and version 2 (state object) state passing.
* To achieve this, the returned function in case of a state object
* will spread the state object in both `prev` and `next props.
* Other case it just returns the function as is which makes sure
* that we are still backward compatible
function normalizePropsAreEqual(propsAreEqual) {
if (propsAreEqual.name === "normalizePropsAreEqualInner") {
return function normalizePropsAreEqualInner(prev, next) {
if (!isPlainObject(prev.state) || !isPlainObject(next.state)) {
return propsAreEqual(prev, next);
return propsAreEqual(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])({}, prev.state), prev), Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])(Object(_rollupPluginBabelHelpers_1f0bf8c2["b" /* a */])({}, next.state), next));
// CONCATENATED MODULE: ./node_modules/reakit/node_modules/reakit-system/es/createComponent.js
function forwardRef(component) {
return /*#__PURE__*/Object(external_React_["forwardRef"])(component);
function memo(component, propsAreEqual) {
return /*#__PURE__*/Object(external_React_["memo"])(component, propsAreEqual);
* Creates a React component.
* import { createComponent } from "reakit-system";
* const A = createComponent({ as: "a" });
function createComponent(_ref) {
_ref$propsAreEqual = _ref.propsAreEqual,
propsAreEqual = _ref$propsAreEqual === void 0 ? useHook === null || useHook === void 0 ? void 0 : useHook.unstable_propsAreEqual : _ref$propsAreEqual,
keys = _ref$keys === void 0 ? (useHook === null || useHook === void 0 ? void 0 : useHook.__keys) || [] : _ref$keys,
_ref$useCreateElement = _ref.useCreateElement,
useCreateElement$1 = _ref$useCreateElement === void 0 ? useCreateElement["a" /* useCreateElement */] : _ref$useCreateElement;
var Comp = function Comp(_ref2, ref) {
as = _ref2$as === void 0 ? type : _ref2$as,
props = Object(_rollupPluginBabelHelpers_0c84a174["b" /* a */])(_ref2, ["as"]);
var _splitProps = splitProps(props, keys),
_options = _splitProps[0],
htmlProps = _splitProps[1];
var _useHook = useHook(_options, Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])({
wrapElement = _useHook.wrapElement,
elementProps = Object(_rollupPluginBabelHelpers_0c84a174["b" /* a */])(_useHook, ["wrapElement"]); // @ts-ignore
var asKeys = ((_as$render = as.render) === null || _as$render === void 0 ? void 0 : _as$render.__keys) || as.__keys;
var asOptions = asKeys && splitProps(props, asKeys)[0];
var allProps = asOptions ? Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])(Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])({}, elementProps), asOptions) : elementProps;
var _element = useCreateElement$1(as, allProps);
return wrapElement(_element);
return useCreateElement$1(as, Object(_rollupPluginBabelHelpers_0c84a174["a" /* _ */])({
Comp = memo(Comp, propsAreEqual && normalizePropsAreEqual(propsAreEqual));
Comp.unstable_propsAreEqual = normalizePropsAreEqual(propsAreEqual || shallowEqual["a" /* shallowEqual */]);
/***/ (function(module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", {
exports['default'] = isTransitionEndSupported;
function isTransitionEndSupported() {
return !!(typeof window !== 'undefined' && 'TransitionEvent' in window);
/***/ (function(module, __webpack_exports__, __webpack_require__) {
__webpack_require__.d(__webpack_exports__, "b", function() { return /* binding */ slot_fill_Slot; });
__webpack_require__.d(__webpack_exports__, "a", function() { return /* binding */ slot_fill_Fill; });
__webpack_require__.d(__webpack_exports__, "c", function() { return /* binding */ createSlotFill; });
// UNUSED EXPORTS: useSlot, Provider
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
var esm_extends = __webpack_require__("wx14");
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules
var objectWithoutProperties = __webpack_require__("Ff2n");
// EXTERNAL MODULE: external ["wp","element"]
var external_wp_element_ = __webpack_require__("GRId");
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
var classCallCheck = __webpack_require__("1OyB");
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
var createClass = __webpack_require__("vuIU");
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
var assertThisInitialized = __webpack_require__("JX7q");
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js
var getPrototypeOf = __webpack_require__("foSv");
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/superPropBase.js
function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = Object(getPrototypeOf["a" /* default */])(object);
if (object === null) break;
// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/get.js
function get_get(target, property, receiver) {
if (typeof Reflect !== "undefined" && Reflect.get) {
get_get = function _get(target, property, receiver) {
var base = _superPropBase(target, property);
var desc = Object.getOwnPropertyDescriptor(base, property);
return desc.get.call(receiver);
return get_get(target, property, receiver || target);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
var inherits = __webpack_require__("Ji7U");
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js
var possibleConstructorReturn = __webpack_require__("md7G");
// EXTERNAL MODULE: external "lodash"
var external_lodash_ = __webpack_require__("YLtl");
// EXTERNAL MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/context.js + 1 modules
var context = __webpack_require__("bSjX");
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/slot.js
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = Object(getPrototypeOf["a" /* default */])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = Object(getPrototypeOf["a" /* default */])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return Object(possibleConstructorReturn["a" /* default */])(this, result); }; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
var slot_SlotComponent = /*#__PURE__*/function (_Component) {
Object(inherits["a" /* default */])(SlotComponent, _Component);
var _super = _createSuper(SlotComponent);
function SlotComponent() {
Object(classCallCheck["a" /* default */])(this, SlotComponent);
_this = _super.apply(this, arguments);
_this.isUnmounted = false;
_this.bindNode = _this.bindNode.bind(Object(assertThisInitialized["a" /* default */])(_this));
Object(createClass["a" /* default */])(SlotComponent, [{
key: "componentDidMount",
value: function componentDidMount() {
var registerSlot = this.props.registerSlot;
registerSlot(this.props.name, this);
key: "componentWillUnmount",
value: function componentWillUnmount() {
var unregisterSlot = this.props.unregisterSlot;
unregisterSlot(this.props.name, this);
key: "componentDidUpdate",
value: function componentDidUpdate(prevProps) {
var _this$props = this.props,
unregisterSlot = _this$props.unregisterSlot,
registerSlot = _this$props.registerSlot;
if (prevProps.name !== name) {
unregisterSlot(prevProps.name);
registerSlot(name, this);
value: function bindNode(node) {
value: function forceUpdate() {
get_get(Object(getPrototypeOf["a" /* default */])(SlotComponent.prototype), "forceUpdate", this).call(this);
value: function render() {
var _this$props2 = this.props,
children = _this$props2.children,
name = _this$props2.name,
_this$props2$fillProp = _this$props2.fillProps,
fillProps = _this$props2$fillProp === void 0 ? {} : _this$props2$fillProp,
getFills = _this$props2.getFills;
var fills = Object(external_lodash_["map"])(getFills(name, this), function (fill) {
var fillKey = fill.occurrence;
var fillChildren = Object(external_lodash_["isFunction"])(fill.children) ? fill.children(fillProps) : fill.children;
return external_wp_element_["Children"].map(fillChildren, function (child, childIndex) {
if (!child || Object(external_lodash_["isString"])(child)) {
var childKey = "".concat(fillKey, "---").concat(child.key || childIndex);
return Object(external_wp_element_["cloneElement"])(child, {
}).filter( // In some cases fills are rendered only when some conditions apply.
// This ensures that we only use non-empty fills when rendering, i.e.,
// it allows us to render wrappers only when the fills are actually present.
Object(external_lodash_["negate"])(external_wp_element_["isEmptyElement"]));
return Object(external_wp_element_["createElement"])(external_wp_element_["Fragment"], null, Object(external_lodash_["isFunction"])(children) ? children(fills) : fills);
}(external_wp_element_["Component"]);
var slot_Slot = function Slot(props) {
return Object(external_wp_element_["createElement"])(context["a" /* Consumer */], null, function (_ref) {
var registerSlot = _ref.registerSlot,
unregisterSlot = _ref.unregisterSlot,
getFills = _ref.getFills;
return Object(external_wp_element_["createElement"])(slot_SlotComponent, Object(esm_extends["a" /* default */])({}, props, {
registerSlot: registerSlot,
unregisterSlot: unregisterSlot,
/* harmony default export */ var slot_fill_slot = (slot_Slot);
// CONCATENATED MODULE: ./node_modules/@wordpress/components/build-module/slot-fill/fill.js
function fill_FillComponent(_ref) {
children = _ref.children,
registerFill = _ref.registerFill,
unregisterFill = _ref.unregisterFill;
var slot = Object(context["c" /* useSlot */])(name);
var ref = Object(external_wp_element_["useRef"])({
if (!ref.current.occurrence) {
ref.current.occurrence = ++occurrences;
Object(external_wp_element_["useLayoutEffect"])(function () {
registerFill(name, ref.current);
return unregisterFill(name, ref.current);
Object(external_wp_element_["useLayoutEffect"])(function () {
ref.current.children = children;
Object(external_wp_element_["useLayoutEffect"])(function () {
if (name === ref.current.name) {
unregisterFill(ref.current.name, ref.current);
registerFill(name, ref.current);
if (!slot || !slot.node) {