--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wp/wp-includes/js/dist/router.js Fri Sep 05 18:40:08 2025 +0200
@@ -0,0 +1,979 @@
+/******/ (() => { // 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 || {};
+ 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 _getIndexAndLocation4 = getIndexAndLocation(),
+ nextIndex = _getIndexAndLocation4[0],
+ nextLocation = _getIndexAndLocation4[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); // popstate does not fire on hashchange in IE 11 and old (trident) Edge
+ // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event
+
+ window.addEventListener(HashChangeEventType, function () {
+ var _getIndexAndLocation5 = getIndexAndLocation(),
+ nextLocation = _getIndexAndLocation5[1]; // Ignore extraneous hashchange events.
+
+
+ if (createPath(nextLocation) !== createPath(location)) {
+ handlePop();
+ }
+ });
+ var action = Action.Pop;
+
+ var _getIndexAndLocation6 = getIndexAndLocation(),
+ index = _getIndexAndLocation6[0],
+ location = _getIndexAndLocation6[1];
+
+ var listeners = createEvents();
+ var blockers = createEvents();
+
+ if (index == null) {
+ index = 0;
+ globalHistory.replaceState(_extends({}, globalHistory.state, {
+ idx: index
+ }), '');
+ }
+
+ function getBaseHref() {
+ var base = document.querySelector('base');
+ var href = '';
+
+ if (base && base.getAttribute('href')) {
+ var url = window.location.href;
+ var hashIndex = url.indexOf('#');
+ href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+ }
+
+ return href;
+ }
+
+ function createHref(to) {
+ return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));
+ }
+
+ function getNextLocation(to, state) {
+ if (state === void 0) {
+ state = null;
+ }
+
+ return readOnly(_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 _getIndexAndLocation7 = getIndexAndLocation();
+
+ index = _getIndexAndLocation7[0];
+ location = _getIndexAndLocation7[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);
+ }
+
+ false ? 0 : void 0;
+
+ if (allowTx(nextAction, nextLocation, retry)) {
+ var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1),
+ historyState = _getHistoryStateAndUr3[0],
+ url = _getHistoryStateAndUr3[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);
+ }
+
+ false ? 0 : void 0;
+
+ if (allowTx(nextAction, nextLocation, retry)) {
+ var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index),
+ historyState = _getHistoryStateAndUr4[0],
+ url = _getHistoryStateAndUr4[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;
+}
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory
+ */
+
+function createMemoryHistory(options) {
+ if (options === void 0) {
+ options = {};
+ }
+
+ var _options3 = options,
+ _options3$initialEntr = _options3.initialEntries,
+ initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,
+ initialIndex = _options3.initialIndex;
+ var entries = initialEntries.map(function (entry) {
+ var location = readOnly(_extends({
+ pathname: '/',
+ search: '',
+ hash: '',
+ state: null,
+ key: createKey()
+ }, typeof entry === 'string' ? parsePath(entry) : entry));
+ false ? 0 : void 0;
+ return location;
+ });
+ var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);
+ var action = Action.Pop;
+ var location = entries[index];
+ var listeners = createEvents();
+ var blockers = createEvents();
+
+ function createHref(to) {
+ return typeof to === 'string' ? to : createPath(to);
+ }
+
+ function getNextLocation(to, state) {
+ if (state === void 0) {
+ state = null;
+ }
+
+ return readOnly(_extends({
+ pathname: location.pathname,
+ search: '',
+ hash: ''
+ }, typeof to === 'string' ? parsePath(to) : to, {
+ state: state,
+ key: createKey()
+ }));
+ }
+
+ function allowTx(action, location, retry) {
+ return !blockers.length || (blockers.call({
+ action: action,
+ location: location,
+ retry: retry
+ }), false);
+ }
+
+ function applyTx(nextAction, nextLocation) {
+ action = nextAction;
+ location = nextLocation;
+ listeners.call({
+ action: action,
+ location: location
+ });
+ }
+
+ function push(to, state) {
+ var nextAction = Action.Push;
+ var nextLocation = getNextLocation(to, state);
+
+ function retry() {
+ push(to, state);
+ }
+
+ false ? 0 : void 0;
+
+ if (allowTx(nextAction, nextLocation, retry)) {
+ index += 1;
+ entries.splice(index, entries.length, nextLocation);
+ applyTx(nextAction, nextLocation);
+ }
+ }
+
+ function replace(to, state) {
+ var nextAction = Action.Replace;
+ var nextLocation = getNextLocation(to, state);
+
+ function retry() {
+ replace(to, state);
+ }
+
+ false ? 0 : void 0;
+
+ if (allowTx(nextAction, nextLocation, retry)) {
+ entries[index] = nextLocation;
+ applyTx(nextAction, nextLocation);
+ }
+ }
+
+ function go(delta) {
+ var nextIndex = clamp(index + delta, 0, entries.length - 1);
+ var nextAction = Action.Pop;
+ var nextLocation = entries[nextIndex];
+
+ function retry() {
+ go(delta);
+ }
+
+ if (allowTx(nextAction, nextLocation, retry)) {
+ index = nextIndex;
+ applyTx(nextAction, nextLocation);
+ }
+ }
+
+ var history = {
+ get index() {
+ return index;
+ },
+
+ 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) {
+ return blockers.push(blocker);
+ }
+ };
+ return history;
+} ////////////////////////////////////////////////////////////////////////////////
+// UTILS
+////////////////////////////////////////////////////////////////////////////////
+
+function clamp(n, lowerBound, upperBound) {
+ return Math.min(Math.max(n, lowerBound), upperBound);
+}
+
+function promptBeforeUnload(event) {
+ // Cancel the event.
+ event.preventDefault(); // Chrome (and legacy IE) requires returnValue to be set.
+
+ event.returnValue = '';
+}
+
+function createEvents() {
+ var handlers = [];
+ return {
+ get length() {
+ return handlers.length;
+ },
+
+ push: function push(fn) {
+ handlers.push(fn);
+ return function () {
+ handlers = handlers.filter(function (handler) {
+ return handler !== fn;
+ });
+ };
+ },
+ call: function call(arg) {
+ handlers.forEach(function (fn) {
+ return fn && fn(arg);
+ });
+ }
+ };
+}
+
+function createKey() {
+ return Math.random().toString(36).substr(2, 8);
+}
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath
+ */
+
+
+function createPath(_ref) {
+ var _ref$pathname = _ref.pathname,
+ pathname = _ref$pathname === void 0 ? '/' : _ref$pathname,
+ _ref$search = _ref.search,
+ search = _ref$search === void 0 ? '' : _ref$search,
+ _ref$hash = _ref.hash,
+ hash = _ref$hash === void 0 ? '' : _ref$hash;
+ if (search && search !== '?') pathname += search.charAt(0) === '?' ? search : '?' + search;
+ if (hash && hash !== '#') pathname += hash.charAt(0) === '#' ? hash : '#' + hash;
+ return pathname;
+}
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath
+ */
+
+function parsePath(path) {
+ var parsedPath = {};
+
+ if (path) {
+ var hashIndex = path.indexOf('#');
+
+ if (hashIndex >= 0) {
+ parsedPath.hash = path.substr(hashIndex);
+ path = path.substr(0, hashIndex);
+ }
+
+ var searchIndex = path.indexOf('?');
+
+ if (searchIndex >= 0) {
+ parsedPath.search = path.substr(searchIndex);
+ path = path.substr(0, searchIndex);
+ }
+
+ if (path) {
+ parsedPath.pathname = path;
+ }
+ }
+
+ return parsedPath;
+}
+
+
+
+;// CONCATENATED MODULE: external ["wp","url"]
+const external_wp_url_namespaceObject = window["wp"]["url"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/router/build-module/history.js
+/**
+ * External dependencies
+ */
+
+
+/**
+ * WordPress dependencies
+ */
+
+const history_history = createBrowserHistory();
+const originalHistoryPush = history_history.push;
+const originalHistoryReplace = history_history.replace;
+
+// Preserve the `wp_theme_preview` query parameter when navigating
+// around the Site Editor.
+// TODO: move this hack out of the router into Site Editor code.
+function preserveThemePreview(params) {
+ if (params.hasOwnProperty('wp_theme_preview')) {
+ return params;
+ }
+ const currentSearch = new URLSearchParams(history_history.location.search);
+ const currentThemePreview = currentSearch.get('wp_theme_preview');
+ if (currentThemePreview === null) {
+ return params;
+ }
+ return {
+ ...params,
+ wp_theme_preview: currentThemePreview
+ };
+}
+function push(params, state) {
+ const search = (0,external_wp_url_namespaceObject.buildQueryString)(preserveThemePreview(params));
+ return originalHistoryPush.call(history_history, {
+ search
+ }, state);
+}
+function replace(params, state) {
+ const search = (0,external_wp_url_namespaceObject.buildQueryString)(preserveThemePreview(params));
+ return originalHistoryReplace.call(history_history, {
+ search
+ }, state);
+}
+const locationMemo = new WeakMap();
+function getLocationWithParams() {
+ const location = history_history.location;
+ let locationWithParams = locationMemo.get(location);
+ if (!locationWithParams) {
+ locationWithParams = {
+ ...location,
+ params: Object.fromEntries(new URLSearchParams(location.search))
+ };
+ locationMemo.set(location, locationWithParams);
+ }
+ return locationWithParams;
+}
+history_history.push = push;
+history_history.replace = replace;
+history_history.getLocationWithParams = getLocationWithParams;
+/* harmony default export */ const build_module_history = (history_history);
+
+;// CONCATENATED MODULE: external "ReactJSXRuntime"
+const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/router/build-module/router.js
+/**
+ * WordPress dependencies
+ */
+
+
+/**
+ * Internal dependencies
+ */
+
+
+const RoutesContext = (0,external_wp_element_namespaceObject.createContext)();
+const HistoryContext = (0,external_wp_element_namespaceObject.createContext)();
+function useLocation() {
+ return (0,external_wp_element_namespaceObject.useContext)(RoutesContext);
+}
+function useHistory() {
+ return (0,external_wp_element_namespaceObject.useContext)(HistoryContext);
+}
+function RouterProvider({
+ children
+}) {
+ const location = (0,external_wp_element_namespaceObject.useSyncExternalStore)(build_module_history.listen, build_module_history.getLocationWithParams, build_module_history.getLocationWithParams);
+ return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(HistoryContext.Provider, {
+ value: build_module_history,
+ children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(RoutesContext.Provider, {
+ value: location,
+ children: children
+ })
+ });
+}
+
+;// CONCATENATED MODULE: external ["wp","privateApis"]
+const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
+;// CONCATENATED MODULE: ./node_modules/@wordpress/router/build-module/lock-unlock.js
+/**
+ * WordPress dependencies
+ */
+
+const {
+ lock,
+ unlock
+} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.', '@wordpress/router');
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/router/build-module/private-apis.js
+/**
+ * Internal dependencies
+ */
+
+
+const privateApis = {};
+lock(privateApis, {
+ useHistory: useHistory,
+ useLocation: useLocation,
+ RouterProvider: RouterProvider
+});
+
+;// CONCATENATED MODULE: ./node_modules/@wordpress/router/build-module/index.js
+
+
+(window.wp = window.wp || {}).router = __webpack_exports__;
+/******/ })()
+;
\ No newline at end of file