/******/ (() => { // webpackBootstrap

/******/ 	"use strict";

/******/ 	// The require scope

/******/ 	var __webpack_require__ = {};

/******/ 	

/************************************************************************/

/******/ 	/* webpack/runtime/define property getters */

/******/ 	(() => {

/******/ 		// define getter functions for harmony exports

/******/ 		__webpack_require__.d = (exports, definition) => {

/******/ 			for(var key in definition) {

/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {

/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });

/******/ 				}

/******/ 			}

/******/ 		};

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/hasOwnProperty shorthand */

/******/ 	(() => {

/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))

/******/ 	})();

/******/ 	

/******/ 	/* webpack/runtime/make namespace object */

/******/ 	(() => {

/******/ 		// define __esModule on exports

/******/ 		__webpack_require__.r = (exports) => {

/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

/******/ 			}

/******/ 			Object.defineProperty(exports, '__esModule', { value: true });

/******/ 		};

/******/ 	})();

/******/ 	

/************************************************************************/

var __webpack_exports__ = {};

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

__webpack_require__.d(__webpack_exports__, {

  privateApis: () => (/* reexport */ privateApis)

});

;// CONCATENATED MODULE: external ["wp","element"]

const external_wp_element_namespaceObject = window["wp"]["element"];

;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js

function extends_extends() {

  extends_extends = Object.assign ? Object.assign.bind() : function (target) {

    for (var i = 1; i < arguments.length; i++) {

      var source = arguments[i];

      for (var key in source) {

        if (Object.prototype.hasOwnProperty.call(source, key)) {

          target[key] = source[key];

        }

      }

    }

    return target;

  };

  return extends_extends.apply(this, arguments);

}

;// CONCATENATED MODULE: ./node_modules/history/index.js

/**

 * Actions represent the type of change to a location value.

 *

 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action

 */

var Action;

(function (Action) {

  /**

   * A POP indicates a change to an arbitrary index in the history stack, such

   * as a back or forward navigation. It does not describe the direction of the

   * navigation, only that the current index changed.

   *

   * Note: This is the default action for newly created history objects.

   */

  Action["Pop"] = "POP";

  /**

   * A PUSH indicates a new entry being added to the history stack, such as when

   * a link is clicked and a new page loads. When this happens, all subsequent

   * entries in the stack are lost.

   */

  Action["Push"] = "PUSH";

  /**

   * A REPLACE indicates the entry at the current index in the history stack

   * being replaced by a new one.

   */

  Action["Replace"] = "REPLACE";

})(Action || (Action = {}));

var readOnly =  false ? 0 : function (obj) {

  return obj;

};

function warning(cond, message) {

  if (!cond) {

    // eslint-disable-next-line no-console

    if (typeof console !== 'undefined') console.warn(message);

    try {

      // Welcome to debugging history!

      //

      // This error is thrown as a convenience so you can more easily

      // find the source for a warning that appears in the console by

      // enabling "pause on exceptions" in your JavaScript debugger.

      throw new Error(message); // eslint-disable-next-line no-empty

    } catch (e) {}

  }

}

var BeforeUnloadEventType = 'beforeunload';

var HashChangeEventType = 'hashchange';

var PopStateEventType = 'popstate';

/**

 * Browser history stores the location in regular URLs. This is the standard for

 * most web apps, but it requires some configuration on the server to ensure you

 * serve the same app at multiple URLs.

 *

 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory

 */

function createBrowserHistory(options) {

  if (options === void 0) {

    options = {};

  }

  var _options = options,

      _options$window = _options.window,

      window = _options$window === void 0 ? document.defaultView : _options$window;

  var globalHistory = window.history;

  function getIndexAndLocation() {

    var _window$location = window.location,

        pathname = _window$location.pathname,

        search = _window$location.search,

        hash = _window$location.hash;

    var state = globalHistory.state || {};

    return [state.idx, readOnly({

      pathname: pathname,

      search: search,

      hash: hash,

      state: state.usr || null,

      key: state.key || 'default'

    })];

  }

  var blockedPopTx = null;

  function handlePop() {

    if (blockedPopTx) {

      blockers.call(blockedPopTx);

      blockedPopTx = null;

    } else {

      var nextAction = Action.Pop;

      var _getIndexAndLocation = getIndexAndLocation(),

          nextIndex = _getIndexAndLocation[0],

          nextLocation = _getIndexAndLocation[1];

      if (blockers.length) {

        if (nextIndex != null) {

          var delta = index - nextIndex;

          if (delta) {

            // Revert the POP

            blockedPopTx = {

              action: nextAction,

              location: nextLocation,

              retry: function retry() {

                go(delta * -1);

              }

            };

            go(delta);

          }

        } else {

          // Trying to POP to a location with no index. We did not create

          // this location, so we can't effectively block the navigation.

           false ? 0 : void 0;

        }

      } else {

        applyTx(nextAction);

      }

    }

  }

  window.addEventListener(PopStateEventType, handlePop);

  var action = Action.Pop;

  var _getIndexAndLocation2 = getIndexAndLocation(),

      index = _getIndexAndLocation2[0],

      location = _getIndexAndLocation2[1];

  var listeners = createEvents();

  var blockers = createEvents();

  if (index == null) {

    index = 0;

    globalHistory.replaceState(extends_extends({}, globalHistory.state, {

      idx: index

    }), '');

  }

  function createHref(to) {

    return typeof to === 'string' ? to : createPath(to);

  } // state defaults to `null` because `window.history.state` does

  function getNextLocation(to, state) {

    if (state === void 0) {

      state = null;

    }

    return readOnly(extends_extends({

      pathname: location.pathname,

      hash: '',

      search: ''

    }, typeof to === 'string' ? parsePath(to) : to, {

      state: state,

      key: createKey()

    }));

  }

  function getHistoryStateAndUrl(nextLocation, index) {

    return [{

      usr: nextLocation.state,

      key: nextLocation.key,

      idx: index

    }, createHref(nextLocation)];

  }

  function allowTx(action, location, retry) {

    return !blockers.length || (blockers.call({

      action: action,

      location: location,

      retry: retry

    }), false);

  }

  function applyTx(nextAction) {

    action = nextAction;

    var _getIndexAndLocation3 = getIndexAndLocation();

    index = _getIndexAndLocation3[0];

    location = _getIndexAndLocation3[1];

    listeners.call({

      action: action,

      location: location

    });

  }

  function push(to, state) {

    var nextAction = Action.Push;

    var nextLocation = getNextLocation(to, state);

    function retry() {

      push(to, state);

    }

    if (allowTx(nextAction, nextLocation, retry)) {

      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1),

          historyState = _getHistoryStateAndUr[0],

          url = _getHistoryStateAndUr[1]; // TODO: Support forced reloading

      // try...catch because iOS limits us to 100 pushState calls :/

      try {

        globalHistory.pushState(historyState, '', url);

      } catch (error) {

        // They are going to lose state here, but there is no real

        // way to warn them about it since the page will refresh...

        window.location.assign(url);

      }

      applyTx(nextAction);

    }

  }

  function replace(to, state) {

    var nextAction = Action.Replace;

    var nextLocation = getNextLocation(to, state);

    function retry() {

      replace(to, state);

    }

    if (allowTx(nextAction, nextLocation, retry)) {

      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),

          historyState = _getHistoryStateAndUr2[0],

          url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading

      globalHistory.replaceState(historyState, '', url);

      applyTx(nextAction);

    }

  }

  function go(delta) {

    globalHistory.go(delta);

  }

  var history = {

    get action() {

      return action;

    },

    get location() {

      return location;

    },

    createHref: createHref,

    push: push,

    replace: replace,

    go: go,

    back: function back() {

      go(-1);

    },

    forward: function forward() {

      go(1);

    },

    listen: function listen(listener) {

      return listeners.push(listener);

    },

    block: function block(blocker) {

      var unblock = blockers.push(blocker);

      if (blockers.length === 1) {

        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);

      }

      return function () {

        unblock(); // Remove the beforeunload listener so the document may

        // still be salvageable in the pagehide event.

        // See https://html.spec.whatwg.org/#unloading-documents

        if (!blockers.length) {

          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);

        }

      };

    }

  };

  return history;

}

/**

 * Hash history stores the location in window.location.hash. This makes it ideal

 * for situations where you don't want to send the location to the server for

 * some reason, either because you do cannot configure it or the URL space is

 * reserved for something else.

 *

 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory

 */

function createHashHistory(options) {

  if (options === void 0) {

    options = {};

  }

  var _options2 = options,

      _options2$window = _options2.window,

      window = _options2$window === void 0 ? document.defaultView : _options2$window;

  var globalHistory = window.history;

  function getIndexAndLocation() {

    var _parsePath = parsePath(window.location.hash.substr(1)),

        _parsePath$pathname = _parsePath.pathname,

        pathname = _parsePath$pathname === void 0 ? '/' : _parsePath$pathname,

        _parsePath$search = _parsePath.search,

        search = _parsePath$search === void 0 ? '' : _parsePath$search,

        _parsePath$hash = _parsePath.hash,

        hash = _parsePath$hash === void 0 ? '' : _parsePath$hash;

    var state = globalHistory.state || {};