1/******/ (() => { // webpackBootstrap
  2/******/ 	"use strict";
  3/******/ 	// The require scope
  4/******/ 	var __webpack_require__ = {};
  5/******/ 	
  6/************************************************************************/
  7/******/ 	/* webpack/runtime/define property getters */
  8/******/ 	(() => {
  9/******/ 		// define getter functions for harmony exports
 10/******/ 		__webpack_require__.d = (exports, definition) => {
 11/******/ 			for(var key in definition) {
 12/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
 13/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
 14/******/ 				}
 15/******/ 			}
 16/******/ 		};
 17/******/ 	})();
 18/******/ 	
 19/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
 20/******/ 	(() => {
 21/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 22/******/ 	})();
 23/******/ 	
 24/******/ 	/* webpack/runtime/make namespace object */
 25/******/ 	(() => {
 26/******/ 		// define __esModule on exports
 27/******/ 		__webpack_require__.r = (exports) => {
 28/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
 29/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 30/******/ 			}
 31/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
 32/******/ 		};
 33/******/ 	})();
 34/******/ 	
 35/************************************************************************/
 36var __webpack_exports__ = {};
 37// ESM COMPAT FLAG
 38__webpack_require__.r(__webpack_exports__);
 39
 40// EXPORTS
 41__webpack_require__.d(__webpack_exports__, {
 42  privateApis: () => (/* reexport */ privateApis)
 43});
 44
 45;// external "ReactJSXRuntime"
 46const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
 47;// ./node_modules/route-recognizer/dist/route-recognizer.es.js
 48var createObject = Object.create;
 49function createMap() {
 50    var map = createObject(null);
 51    map["__"] = undefined;
 52    delete map["__"];
 53    return map;
 54}
 55
 56var Target = function Target(path, matcher, delegate) {
 57    this.path = path;
 58    this.matcher = matcher;
 59    this.delegate = delegate;
 60};
 61Target.prototype.to = function to (target, callback) {
 62    var delegate = this.delegate;
 63    if (delegate && delegate.willAddRoute) {
 64        target = delegate.willAddRoute(this.matcher.target, target);
 65    }
 66    this.matcher.add(this.path, target);
 67    if (callback) {
 68        if (callback.length === 0) {
 69            throw new Error("You must have an argument in the function passed to `to`");
 70        }
 71        this.matcher.addChild(this.path, target, callback, this.delegate);
 72    }
 73};
 74var Matcher = function Matcher(target) {
 75    this.routes = createMap();
 76    this.children = createMap();
 77    this.target = target;
 78};
 79Matcher.prototype.add = function add (path, target) {
 80    this.routes[path] = target;
 81};
 82Matcher.prototype.addChild = function addChild (path, target, callback, delegate) {
 83    var matcher = new Matcher(target);
 84    this.children[path] = matcher;
 85    var match = generateMatch(path, matcher, delegate);
 86    if (delegate && delegate.contextEntered) {
 87        delegate.contextEntered(target, match);
 88    }
 89    callback(match);
 90};
 91function generateMatch(startingPath, matcher, delegate) {
 92    function match(path, callback) {
 93        var fullPath = startingPath + path;
 94        if (callback) {
 95            callback(generateMatch(fullPath, matcher, delegate));
 96        }
 97        else {
 98            return new Target(fullPath, matcher, delegate);
 99        }
100    }
101    
102    return match;
103}
104function addRoute(routeArray, path, handler) {
105    var len = 0;
106    for (var i = 0; i < routeArray.length; i++) {
107        len += routeArray[i].path.length;
108    }
109    path = path.substr(len);
110    var route = { path: path, handler: handler };
111    routeArray.push(route);
112}
113function eachRoute(baseRoute, matcher, callback, binding) {
114    var routes = matcher.routes;
115    var paths = Object.keys(routes);
116    for (var i = 0; i < paths.length; i++) {
117        var path = paths[i];
118        var routeArray = baseRoute.slice();
119        addRoute(routeArray, path, routes[path]);
120        var nested = matcher.children[path];
121        if (nested) {
122            eachRoute(routeArray, nested, callback, binding);
123        }
124        else {
125            callback.call(binding, routeArray);
126        }
127    }
128}
129var map = function (callback, addRouteCallback) {
130    var matcher = new Matcher();
131    callback(generateMatch("", matcher, this.delegate));
132    eachRoute([], matcher, function (routes) {
133        if (addRouteCallback) {
134            addRouteCallback(this, routes);
135        }
136        else {
137            this.add(routes);
138        }
139    }, this);
140};
141
142// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded
143// values that are not reserved (i.e., unicode characters, emoji, etc). The reserved
144// chars are "/" and "%".
145// Safe to call multiple times on the same path.
146// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded
147function normalizePath(path) {
148    return path.split("/")
149        .map(normalizeSegment)
150        .join("/");
151}
152// We want to ensure the characters "%" and "/" remain in percent-encoded
153// form when normalizing paths, so replace them with their encoded form after
154// decoding the rest of the path
155var SEGMENT_RESERVED_CHARS = /%|\//g;
156function normalizeSegment(segment) {
157    if (segment.length < 3 || segment.indexOf("%") === -1)
158        { return segment; }
159    return decodeURIComponent(segment).replace(SEGMENT_RESERVED_CHARS, encodeURIComponent);
160}
161// We do not want to encode these characters when generating dynamic path segments
162// See https://tools.ietf.org/html/rfc3986#section-3.3
163// sub-delims: "!", "$", "&", "'", "(", ")", "*", "+", ",", ";", "="
164// others allowed by RFC 3986: ":", "@"
165//
166// First encode the entire path segment, then decode any of the encoded special chars.
167//
168// The chars "!", "'", "(", ")", "*" do not get changed by `encodeURIComponent`,
169// so the possible encoded chars are:
170// ['%24', '%26', '%2B', '%2C', '%3B', '%3D', '%3A', '%40'].
171var PATH_SEGMENT_ENCODINGS = /%(?:2(?:4|6|B|C)|3(?:B|D|A)|40)/g;
172function encodePathSegment(str) {
173    return encodeURIComponent(str).replace(PATH_SEGMENT_ENCODINGS, decodeURIComponent);
174}
175
176var escapeRegex = /(\/|\.|\*|\+|\?|\||\(|\)|\[|\]|\{|\}|\\)/g;
177var isArray = Array.isArray;
178var route_recognizer_es_hasOwnProperty = Object.prototype.hasOwnProperty;
179function getParam(params, key) {
180    if (typeof params !== "object" || params === null) {
181        throw new Error("You must pass an object as the second argument to `generate`.");
182    }
183    if (!route_recognizer_es_hasOwnProperty.call(params, key)) {
184        throw new Error("You must provide param `" + key + "` to `generate`.");
185    }
186    var value = params[key];
187    var str = typeof value === "string" ? value : "" + value;
188    if (str.length === 0) {
189        throw new Error("You must provide a param `" + key + "`.");
190    }
191    return str;
192}
193var eachChar = [];
194eachChar[0 /* Static */] = function (segment, currentState) {
195    var state = currentState;
196    var value = segment.value;
197    for (var i = 0; i < value.length; i++) {
198        var ch = value.charCodeAt(i);
199        state = state.put(ch, false, false);
200    }
201    return state;
202};
203eachChar[1 /* Dynamic */] = function (_, currentState) {
204    return currentState.put(47 /* SLASH */, true, true);
205};
206eachChar[2 /* Star */] = function (_, currentState) {
207    return currentState.put(-1 /* ANY */, false, true);
208};
209eachChar[4 /* Epsilon */] = function (_, currentState) {
210    return currentState;
211};
212var regex = [];
213regex[0 /* Static */] = function (segment) {
214    return segment.value.replace(escapeRegex, "\\$1");
215};
216regex[1 /* Dynamic */] = function () {
217    return "([^/]+)";
218};
219regex[2 /* Star */] = function () {
220    return "(.+)";
221};
222regex[4 /* Epsilon */] = function () {
223    return "";
224};
225var generate = [];
226generate[0 /* Static */] = function (segment) {
227    return segment.value;
228};
229generate[1 /* Dynamic */] = function (segment, params) {
230    var value = getParam(params, segment.value);
231    if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {
232        return encodePathSegment(value);
233    }
234    else {
235        return value;
236    }
237};
238generate[2 /* Star */] = function (segment, params) {
239    return getParam(params, segment.value);
240};
241generate[4 /* Epsilon */] = function () {
242    return "";
243};
244var EmptyObject = Object.freeze({});
245var EmptyArray = Object.freeze([]);
246// The `names` will be populated with the paramter name for each dynamic/star
247// segment. `shouldDecodes` will be populated with a boolean for each dyanamic/star
248// segment, indicating whether it should be decoded during recognition.
249function parse(segments, route, types) {
250    // normalize route as not starting with a "/". Recognition will
251    // also normalize.
252    if (route.length > 0 && route.charCodeAt(0) === 47 /* SLASH */) {
253        route = route.substr(1);
254    }
255    var parts = route.split("/");
256    var names = undefined;
257    var shouldDecodes = undefined;
258    for (var i = 0; i < parts.length; i++) {
259        var part = parts[i];
260        var flags = 0;
261        var type = 0;
262        if (part === "") {
263            type = 4 /* Epsilon */;
264        }
265        else if (part.charCodeAt(0) === 58 /* COLON */) {
266            type = 1 /* Dynamic */;
267        }
268        else if (part.charCodeAt(0) === 42 /* STAR */) {
269            type = 2 /* Star */;
270        }
271        else {
272            type = 0 /* Static */;
273        }
274        flags = 2 << type;
275        if (flags & 12 /* Named */) {
276            part = part.slice(1);
277            names = names || [];
278            names.push(part);
279            shouldDecodes = shouldDecodes || [];
280            shouldDecodes.push((flags & 4 /* Decoded */) !== 0);
281        }
282        if (flags & 14 /* Counted */) {
283            types[type]++;
284        }
285        segments.push({
286            type: type,
287            value: normalizeSegment(part)
288        });
289    }
290    return {
291        names: names || EmptyArray,
292        shouldDecodes: shouldDecodes || EmptyArray,
293    };
294}
295function isEqualCharSpec(spec, char, negate) {
296    return spec.char === char && spec.negate === negate;
297}
298// A State has a character specification and (`charSpec`) and a list of possible
299// subsequent states (`nextStates`).
300//
301// If a State is an accepting state, it will also have several additional
302// properties:
303//
304// * `regex`: A regular expression that is used to extract parameters from paths
305//   that reached this accepting state.
306// * `handlers`: Information on how to convert the list of captures into calls
307//   to registered handlers with the specified parameters
308// * `types`: How many static, dynamic or star segments in this route. Used to
309//   decide which route to use if multiple registered routes match a path.
310//
311// Currently, State is implemented naively by looping over `nextStates` and
312// comparing a character specification against a character. A more efficient
313// implementation would use a hash of keys pointing at one or more next states.
314var State = function State(states, id, char, negate, repeat) {
315    this.states = states;
316    this.id = id;
317    this.char = char;
318    this.negate = negate;
319    this.nextStates = repeat ? id : null;
320    this.pattern = "";
321    this._regex = undefined;
322    this.handlers = undefined;
323    this.types = undefined;
324};
325State.prototype.regex = function regex$1 () {
326    if (!this._regex) {
327        this._regex = new RegExp(this.pattern);
328    }
329    return this._regex;
330};
331State.prototype.get = function get (char, negate) {
332        var this$1 = this;
333
334    var nextStates = this.nextStates;
335    if (nextStates === null)
336        { return; }
337    if (isArray(nextStates)) {
338        for (var i = 0; i < nextStates.length; i++) {
339            var child = this$1.states[nextStates[i]];
340            if (isEqualCharSpec(child, char, negate)) {
341                return child;
342            }
343        }
344    }
345    else {
346        var child$1 = this.states[nextStates];
347        if (isEqualCharSpec(child$1, char, negate)) {
348            return child$1;
349        }
350    }
351};
352State.prototype.put = function put (char, negate, repeat) {
353    var state;
354    // If the character specification already exists in a child of the current
355    // state, just return that state.
356    if (state = this.get(char, negate)) {
357        return state;
358    }
359    // Make a new state for the character spec
360    var states = this.states;
361    state = new State(states, states.length, char, negate, repeat);
362    states[states.length] = state;
363    // Insert the new state as a child of the current state
364    if (this.nextStates == null) {
365        this.nextStates = state.id;
366    }
367    else if (isArray(this.nextStates)) {
368        this.nextStates.push(state.id);
369    }
370    else {
371        this.nextStates = [this.nextStates, state.id];
372    }
373    // Return the new state
374    return state;
375};
376// Find a list of child states matching the next character
377State.prototype.match = function match (ch) {
378        var this$1 = this;
379
380    var nextStates = this.nextStates;
381    if (!nextStates)
382        { return []; }
383    var returned = [];
384    if (isArray(nextStates)) {
385        for (var i = 0; i < nextStates.length; i++) {
386            var child = this$1.states[nextStates[i]];
387            if (isMatch(child, ch)) {
388                returned.push(child);
389            }
390        }
391    }
392    else {
393        var child$1 = this.states[nextStates];
394        if (isMatch(child$1, ch)) {
395            returned.push(child$1);
396        }
397    }
398    return returned;
399};
400function isMatch(spec, char) {
401    return spec.negate ? spec.char !== char && spec.char !== -1 /* ANY */ : spec.char === char || spec.char === -1 /* ANY */;
402}
403// This is a somewhat naive strategy, but should work in a lot of cases
404// A better strategy would properly resolve /posts/:id/new and /posts/edit/:id.
405//
406// This strategy generally prefers more static and less dynamic matching.
407// Specifically, it
408//
409//  * prefers fewer stars to more, then
410//  * prefers using stars for less of the match to more, then
411//  * prefers fewer dynamic segments to more, then
412//  * prefers more static segments to more
413function sortSolutions(states) {
414    return states.sort(function (a, b) {
415        var ref = a.types || [0, 0, 0];
416        var astatics = ref[0];
417        var adynamics = ref[1];
418        var astars = ref[2];
419        var ref$1 = b.types || [0, 0, 0];
420        var bstatics = ref$1[0];
421        var bdynamics = ref$1[1];
422        var bstars = ref$1[2];
423        if (astars !== bstars) {
424            return astars - bstars;
425        }
426        if (astars) {
427            if (astatics !== bstatics) {
428                return bstatics - astatics;
429            }
430            if (adynamics !== bdynamics) {
431                return bdynamics - adynamics;
432            }
433        }
434        if (adynamics !== bdynamics) {
435            return adynamics - bdynamics;
436        }
437        if (astatics !== bstatics) {
438            return bstatics - astatics;
439        }
440        return 0;
441    });
442}
443function recognizeChar(states, ch) {
444    var nextStates = [];
445    for (var i = 0, l = states.length; i < l; i++) {
446        var state = states[i];
447        nextStates = nextStates.concat(state.match(ch));
448    }
449    return nextStates;
450}
451var RecognizeResults = function RecognizeResults(queryParams) {
452    this.length = 0;
453    this.queryParams = queryParams || {};
454};
455
456RecognizeResults.prototype.splice = Array.prototype.splice;
457RecognizeResults.prototype.slice = Array.prototype.slice;
458RecognizeResults.prototype.push = Array.prototype.push;
459function findHandler(state, originalPath, queryParams) {
460    var handlers = state.handlers;
461    var regex = state.regex();
462    if (!regex || !handlers)
463        { throw new Error("state not initialized"); }
464    var captures = originalPath.match(regex);
465    var currentCapture = 1;
466    var result = new RecognizeResults(queryParams);
467    result.length = handlers.length;
468    for (var i = 0; i < handlers.length; i++) {
469        var handler = handlers[i];
470        var names = handler.names;
471        var shouldDecodes = handler.shouldDecodes;
472        var params = EmptyObject;
473        var isDynamic = false;
474        if (names !== EmptyArray && shouldDecodes !== EmptyArray) {
475            for (var j = 0; j < names.length; j++) {
476                isDynamic = true;
477                var name = names[j];
478                var capture = captures && captures[currentCapture++];
479                if (params === EmptyObject) {
480                    params = {};
481                }
482                if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS && shouldDecodes[j]) {
483                    params[name] = capture && decodeURIComponent(capture);
484                }
485                else {
486                    params[name] = capture;
487                }
488            }
489        }
490        result[i] = {
491            handler: handler.handler,
492            params: params,
493            isDynamic: isDynamic
494        };
495    }
496    return result;
497}
498function decodeQueryParamPart(part) {
499    // http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1
500    part = part.replace(/\+/gm, "%20");
501    var result;
502    try {
503        result = decodeURIComponent(part);
504    }
505    catch (error) {
506        result = "";
507    }
508    return result;
509}
510var RouteRecognizer = function RouteRecognizer() {
511    this.names = createMap();
512    var states = [];
513    var state = new State(states, 0, -1 /* ANY */, true, false);
514    states[0] = state;
515    this.states = states;
516    this.rootState = state;
517};
518RouteRecognizer.prototype.add = function add (routes, options) {
519    var currentState = this.rootState;
520    var pattern = "^";
521    var types = [0, 0, 0];
522    var handlers = new Array(routes.length);
523    var allSegments = [];
524    var isEmpty = true;
525    var j = 0;
526    for (var i = 0; i < routes.length; i++) {
527        var route = routes[i];
528        var ref = parse(allSegments, route.path, types);
529            var names = ref.names;
530            var shouldDecodes = ref.shouldDecodes;
531        // preserve j so it points to the start of newly added segments
532        for (; j < allSegments.length; j++) {
533            var segment = allSegments[j];
534            if (segment.type === 4 /* Epsilon */) {
535                continue;
536            }
537            isEmpty = false;
538            // Add a "/" for the new segment
539            currentState = currentState.put(47 /* SLASH */, false, false);
540            pattern += "/";
541            // Add a representation of the segment to the NFA and regex
542            currentState = eachChar[segment.type](segment, currentState);
543            pattern += regex[segment.type](segment);
544        }
545        handlers[i] = {
546            handler: route.handler,
547            names: names,
548            shouldDecodes: shouldDecodes
549        };
550    }
551    if (isEmpty) {
552        currentState = currentState.put(47 /* SLASH */, false, false);
553        pattern += "/";
554    }
555    currentState.handlers = handlers;
556    currentState.pattern = pattern + "$";
557    currentState.types = types;
558    var name;
559    if (typeof options === "object" && options !== null && options.as) {
560        name = options.as;
561    }
562    if (name) {
563        // if (this.names[name]) {
564        //   throw new Error("You may not add a duplicate route named `" + name + "`.");
565        // }
566        this.names[name] = {
567            segments: allSegments,
568            handlers: handlers
569        };
570    }
571};
572RouteRecognizer.prototype.handlersFor = function handlersFor (name) {
573    var route = this.names[name];
574    if (!route) {
575        throw new Error("There is no route named " + name);
576    }
577    var result = new Array(route.handlers.length);
578    for (var i = 0; i < route.handlers.length; i++) {
579        var handler = route.handlers[i];
580        result[i] = handler;
581    }
582    return result;
583};
584RouteRecognizer.prototype.hasRoute = function hasRoute (name) {
585    return !!this.names[name];
586};
587RouteRecognizer.prototype.generate = function generate$1 (name, params) {
588    var route = this.names[name];
589    var output = "";
590    if (!route) {
591        throw new Error("There is no route named " + name);
592    }
593    var segments = route.segments;
594    for (var i = 0; i < segments.length; i++) {
595        var segment = segments[i];
596        if (segment.type === 4 /* Epsilon */) {
597            continue;
598        }
599        output += "/";
600        output += generate[segment.type](segment, params);
601    }
602    if (output.charAt(0) !== "/") {
603        output = "/" + output;
604    }
605    if (params && params.queryParams) {
606        output += this.generateQueryString(params.queryParams);
607    }
608    return output;
609};
610RouteRecognizer.prototype.generateQueryString = function generateQueryString (params) {
611    var pairs = [];
612    var keys = Object.keys(params);
613    keys.sort();
614    for (var i = 0; i < keys.length; i++) {
615        var key = keys[i];
616        var value = params[key];
617        if (value == null) {
618            continue;
619        }
620        var pair = encodeURIComponent(key);
621        if (isArray(value)) {
622            for (var j = 0; j < value.length; j++) {
623                var arrayPair = key + "[]" + "=" + encodeURIComponent(value[j]);
624                pairs.push(arrayPair);
625            }
626        }
627        else {
628            pair += "=" + encodeURIComponent(value);
629            pairs.push(pair);
630        }
631    }
632    if (pairs.length === 0) {
633        return "";
634    }
635    return "?" + pairs.join("&");
636};
637RouteRecognizer.prototype.parseQueryString = function parseQueryString (queryString) {
638    var pairs = queryString.split("&");
639    var queryParams = {};
640    for (var i = 0; i < pairs.length; i++) {
641        var pair = pairs[i].split("="), key = decodeQueryParamPart(pair[0]), keyLength = key.length, isArray = false, value = (void 0);
642        if (pair.length === 1) {
643            value = "true";
644        }
645        else {
646            // Handle arrays
647            if (keyLength > 2 && key.slice(keyLength - 2) === "[]") {
648                isArray = true;
649                key = key.slice(0, keyLength - 2);
650                if (!queryParams[key]) {
651                    queryParams[key] = [];
652                }
653            }
654            value = pair[1] ? decodeQueryParamPart(pair[1]) : "";
655        }
656        if (isArray) {
657            queryParams[key].push(value);
658        }
659        else {
660            queryParams[key] = value;
661        }
662    }
663    return queryParams;
664};
665RouteRecognizer.prototype.recognize = function recognize (path) {
666    var results;
667    var states = [this.rootState];
668    var queryParams = {};
669    var isSlashDropped = false;
670    var hashStart = path.indexOf("#");
671    if (hashStart !== -1) {
672        path = path.substr(0, hashStart);
673    }
674    var queryStart = path.indexOf("?");
675    if (queryStart !== -1) {
676        var queryString = path.substr(queryStart + 1, path.length);
677        path = path.substr(0, queryStart);
678        queryParams = this.parseQueryString(queryString);
679    }
680    if (path.charAt(0) !== "/") {
681        path = "/" + path;
682    }
683    var originalPath = path;
684    if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {
685        path = normalizePath(path);
686    }
687    else {
688        path = decodeURI(path);
689        originalPath = decodeURI(originalPath);
690    }
691    var pathLen = path.length;
692    if (pathLen > 1 && path.charAt(pathLen - 1) === "/") {
693        path = path.substr(0, pathLen - 1);
694        originalPath = originalPath.substr(0, originalPath.length - 1);
695        isSlashDropped = true;
696    }
697    for (var i = 0; i < path.length; i++) {
698        states = recognizeChar(states, path.charCodeAt(i));
699        if (!states.length) {
700            break;
701        }
702    }
703    var solutions = [];
704    for (var i$1 = 0; i$1 < states.length; i$1++) {
705        if (states[i$1].handlers) {
706            solutions.push(states[i$1]);
707        }
708    }
709    states = sortSolutions(solutions);
710    var state = solutions[0];
711    if (state && state.handlers) {
712        // if a trailing slash was dropped and a star segment is the last segment
713        // specified, put the trailing slash back
714        if (isSlashDropped && state.pattern && state.pattern.slice(-5) === "(.+)$") {
715            originalPath = originalPath + "/";
716        }
717        results = findHandler(state, originalPath, queryParams);
718    }
719    return results;
720};
721RouteRecognizer.VERSION = "0.3.4";
722// Set to false to opt-out of encoding and decoding path segments.
723// See https://github.com/tildeio/route-recognizer/pull/55
724RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS = true;
725RouteRecognizer.Normalizer = {
726    normalizeSegment: normalizeSegment, normalizePath: normalizePath, encodePathSegment: encodePathSegment
727};
728RouteRecognizer.prototype.map = map;
729
730/* harmony default export */ const route_recognizer_es = (RouteRecognizer);
731
732
733;// ./node_modules/@babel/runtime/helpers/esm/extends.js
734function extends_extends() {
735  return extends_extends = Object.assign ? Object.assign.bind() : function (n) {
736    for (var e = 1; e < arguments.length; e++) {
737      var t = arguments[e];
738      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
739    }
740    return n;
741  }, extends_extends.apply(null, arguments);
742}
743
744;// ./node_modules/history/index.js
745
746
747/**
748 * Actions represent the type of change to a location value.
749 *
750 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action
751 */
752var Action;
753
754(function (Action) {
755  /**
756   * A POP indicates a change to an arbitrary index in the history stack, such
757   * as a back or forward navigation. It does not describe the direction of the
758   * navigation, only that the current index changed.
759   *
760   * Note: This is the default action for newly created history objects.
761   */
762  Action["Pop"] = "POP";
763  /**
764   * A PUSH indicates a new entry being added to the history stack, such as when
765   * a link is clicked and a new page loads. When this happens, all subsequent
766   * entries in the stack are lost.
767   */
768
769  Action["Push"] = "PUSH";
770  /**
771   * A REPLACE indicates the entry at the current index in the history stack
772   * being replaced by a new one.
773   */
774
775  Action["Replace"] = "REPLACE";
776})(Action || (Action = {}));
777
778var readOnly =  false ? 0 : function (obj) {
779  return obj;
780};
781
782function warning(cond, message) {
783  if (!cond) {
784    // eslint-disable-next-line no-console
785    if (typeof console !== 'undefined') console.warn(message);
786
787    try {
788      // Welcome to debugging history!
789      //
790      // This error is thrown as a convenience so you can more easily
791      // find the source for a warning that appears in the console by
792      // enabling "pause on exceptions" in your JavaScript debugger.
793      throw new Error(message); // eslint-disable-next-line no-empty
794    } catch (e) {}
795  }
796}
797
798var BeforeUnloadEventType = 'beforeunload';
799var HashChangeEventType = 'hashchange';
800var PopStateEventType = 'popstate';
801/**
802 * Browser history stores the location in regular URLs. This is the standard for
803 * most web apps, but it requires some configuration on the server to ensure you
804 * serve the same app at multiple URLs.
805 *
806 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
807 */
808
809function createBrowserHistory(options) {
810  if (options === void 0) {
811    options = {};
812  }
813
814  var _options = options,
815      _options$window = _options.window,
816      window = _options$window === void 0 ? document.defaultView : _options$window;
817  var globalHistory = window.history;
818
819  function getIndexAndLocation() {
820    var _window$location = window.location,
821        pathname = _window$location.pathname,
822        search = _window$location.search,
823        hash = _window$location.hash;
824    var state = globalHistory.state || {};
825    return [state.idx, readOnly({
826      pathname: pathname,
827      search: search,
828      hash: hash,
829      state: state.usr || null,
830      key: state.key || 'default'
831    })];
832  }
833
834  var blockedPopTx = null;
835
836  function handlePop() {
837    if (blockedPopTx) {
838      blockers.call(blockedPopTx);
839      blockedPopTx = null;
840    } else {
841      var nextAction = Action.Pop;
842
843      var _getIndexAndLocation = getIndexAndLocation(),
844          nextIndex = _getIndexAndLocation[0],
845          nextLocation = _getIndexAndLocation[1];
846
847      if (blockers.length) {
848        if (nextIndex != null) {
849          var delta = index - nextIndex;
850
851          if (delta) {
852            // Revert the POP
853            blockedPopTx = {
854              action: nextAction,
855              location: nextLocation,
856              retry: function retry() {
857                go(delta * -1);
858              }
859            };
860            go(delta);
861          }
862        } else {
863          // Trying to POP to a location with no index. We did not create
864          // this location, so we can't effectively block the navigation.
865           false ? 0 : void 0;
866        }
867      } else {
868        applyTx(nextAction);
869      }
870    }
871  }
872
873  window.addEventListener(PopStateEventType, handlePop);
874  var action = Action.Pop;
875
876  var _getIndexAndLocation2 = getIndexAndLocation(),
877      index = _getIndexAndLocation2[0],
878      location = _getIndexAndLocation2[1];
879
880  var listeners = createEvents();
881  var blockers = createEvents();
882
883  if (index == null) {
884    index = 0;
885    globalHistory.replaceState(extends_extends({}, globalHistory.state, {
886      idx: index
887    }), '');
888  }
889
890  function createHref(to) {
891    return typeof to === 'string' ? to : createPath(to);
892  } // state defaults to `null` because `window.history.state` does
893
894
895  function getNextLocation(to, state) {
896    if (state === void 0) {
897      state = null;
898    }
899
900    return readOnly(extends_extends({
901      pathname: location.pathname,
902      hash: '',
903      search: ''
904    }, typeof to === 'string' ? parsePath(to) : to, {
905      state: state,
906      key: createKey()
907    }));
908  }
909
910  function getHistoryStateAndUrl(nextLocation, index) {
911    return [{
912      usr: nextLocation.state,
913      key: nextLocation.key,
914      idx: index
915    }, createHref(nextLocation)];
916  }
917
918  function allowTx(action, location, retry) {
919    return !blockers.length || (blockers.call({
920      action: action,
921      location: location,
922      retry: retry
923    }), false);
924  }
925
926  function applyTx(nextAction) {
927    action = nextAction;
928
929    var _getIndexAndLocation3 = getIndexAndLocation();
930
931    index = _getIndexAndLocation3[0];
932    location = _getIndexAndLocation3[1];
933    listeners.call({
934      action: action,
935      location: location
936    });
937  }
938
939  function push(to, state) {
940    var nextAction = Action.Push;
941    var nextLocation = getNextLocation(to, state);
942
943    function retry() {
944      push(to, state);
945    }
946
947    if (allowTx(nextAction, nextLocation, retry)) {
948      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1),
949          historyState = _getHistoryStateAndUr[0],
950          url = _getHistoryStateAndUr[1]; // TODO: Support forced reloading
951      // try...catch because iOS limits us to 100 pushState calls :/
952
953
954      try {
955        globalHistory.pushState(historyState, '', url);
956      } catch (error) {
957        // They are going to lose state here, but there is no real
958        // way to warn them about it since the page will refresh...
959        window.location.assign(url);
960      }
961
962      applyTx(nextAction);
963    }
964  }
965
966  function replace(to, state) {
967    var nextAction = Action.Replace;
968    var nextLocation = getNextLocation(to, state);
969
970    function retry() {
971      replace(to, state);
972    }
973
974    if (allowTx(nextAction, nextLocation, retry)) {
975      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),
976          historyState = _getHistoryStateAndUr2[0],
977          url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading
978
979
980      globalHistory.replaceState(historyState, '', url);
981      applyTx(nextAction);
982    }
983  }
984
985  function go(delta) {
986    globalHistory.go(delta);
987  }
988
989  var history = {
990    get action() {
991      return action;
992    },
993
994    get location() {
995      return location;
996    },
997
998    createHref: createHref,
999    push: push,
1000    replace: replace,
1001    go: go,
1002    back: function back() {
1003      go(-1);
1004    },
1005    forward: function forward() {
1006      go(1);
1007    },
1008    listen: function listen(listener) {
1009      return listeners.push(listener);
1010    },
1011    block: function block(blocker) {
1012      var unblock = blockers.push(blocker);
1013
1014      if (blockers.length === 1) {
1015        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
1016      }
1017
1018      return function () {
1019        unblock(); // Remove the beforeunload listener so the document may
1020        // still be salvageable in the pagehide event.
1021        // See https://html.spec.whatwg.org/#unloading-documents
1022
1023        if (!blockers.length) {
1024          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
1025        }
1026      };
1027    }
1028  };
1029  return history;
1030}
1031/**
1032 * Hash history stores the location in window.location.hash. This makes it ideal
1033 * for situations where you don't want to send the location to the server for
1034 * some reason, either because you do cannot configure it or the URL space is
1035 * reserved for something else.
1036 *
1037 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
1038 */
1039
1040function createHashHistory(options) {
1041  if (options === void 0) {
1042    options = {};
1043  }
1044
1045  var _options2 = options,
1046      _options2$window = _options2.window,
1047      window = _options2$window === void 0 ? document.defaultView : _options2$window;
1048  var globalHistory = window.history;
1049
1050  function getIndexAndLocation() {
1051    var _parsePath = parsePath(window.location.hash.substr(1)),
1052        _parsePath$pathname = _parsePath.pathname,
1053        pathname = _parsePath$pathname === void 0 ? '/' : _parsePath$pathname,
1054        _parsePath$search = _parsePath.search,
1055        search = _parsePath$search === void 0 ? '' : _parsePath$search,
1056        _parsePath$hash = _parsePath.hash,
1057        hash = _parsePath$hash === void 0 ? '' : _parsePath$hash;
1058
1059    var state = globalHistory.state || {};
1060    return [state.idx, readOnly({
1061      pathname: pathname,
1062      search: search,
1063      hash: hash,
1064      state: state.usr || null,
1065      key: state.key || 'default'
1066    })];
1067  }
1068
1069  var blockedPopTx = null;
1070
1071  function handlePop() {
1072    if (blockedPopTx) {
1073      blockers.call(blockedPopTx);
1074      blockedPopTx = null;
1075    } else {
1076      var nextAction = Action.Pop;
1077
1078      var _getIndexAndLocation4 = getIndexAndLocation(),
1079          nextIndex = _getIndexAndLocation4[0],
1080          nextLocation = _getIndexAndLocation4[1];
1081
1082      if (blockers.length) {
1083        if (nextIndex != null) {
1084          var delta = index - nextIndex;
1085
1086          if (delta) {
1087            // Revert the POP
1088            blockedPopTx = {
1089              action: nextAction,
1090              location: nextLocation,
1091              retry: function retry() {
1092                go(delta * -1);
1093              }
1094            };
1095            go(delta);
1096          }
1097        } else {
1098          // Trying to POP to a location with no index. We did not create
1099          // this location, so we can't effectively block the navigation.
1100           false ? 0 : void 0;
1101        }
1102      } else {
1103        applyTx(nextAction);
1104      }
1105    }
1106  }
1107
1108  window.addEventListener(PopStateEventType, handlePop); // popstate does not fire on hashchange in IE 11 and old (trident) Edge
1109  // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event
1110
1111  window.addEventListener(HashChangeEventType, function () {
1112    var _getIndexAndLocation5 = getIndexAndLocation(),
1113        nextLocation = _getIndexAndLocation5[1]; // Ignore extraneous hashchange events.
1114
1115
1116    if (createPath(nextLocation) !== createPath(location)) {
1117      handlePop();
1118    }
1119  });
1120  var action = Action.Pop;
1121
1122  var _getIndexAndLocation6 = getIndexAndLocation(),
1123      index = _getIndexAndLocation6[0],
1124      location = _getIndexAndLocation6[1];
1125
1126  var listeners = createEvents();
1127  var blockers = createEvents();
1128
1129  if (index == null) {
1130    index = 0;
1131    globalHistory.replaceState(_extends({}, globalHistory.state, {
1132      idx: index
1133    }), '');
1134  }
1135
1136  function getBaseHref() {
1137    var base = document.querySelector('base');
1138    var href = '';
1139
1140    if (base && base.getAttribute('href')) {
1141      var url = window.location.href;
1142      var hashIndex = url.indexOf('#');
1143      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
1144    }
1145
1146    return href;
1147  }
1148
1149  function createHref(to) {
1150    return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));
1151  }
1152
1153  function getNextLocation(to, state) {
1154    if (state === void 0) {
1155      state = null;
1156    }
1157
1158    return readOnly(_extends({
1159      pathname: location.pathname,
1160      hash: '',
1161      search: ''
1162    }, typeof to === 'string' ? parsePath(to) : to, {
1163      state: state,
1164      key: createKey()
1165    }));
1166  }
1167
1168  function getHistoryStateAndUrl(nextLocation, index) {
1169    return [{
1170      usr: nextLocation.state,
1171      key: nextLocation.key,
1172      idx: index
1173    }, createHref(nextLocation)];
1174  }
1175
1176  function allowTx(action, location, retry) {
1177    return !blockers.length || (blockers.call({
1178      action: action,
1179      location: location,
1180      retry: retry
1181    }), false);
1182  }
1183
1184  function applyTx(nextAction) {
1185    action = nextAction;
1186
1187    var _getIndexAndLocation7 = getIndexAndLocation();
1188
1189    index = _getIndexAndLocation7[0];
1190    location = _getIndexAndLocation7[1];
1191    listeners.call({
1192      action: action,
1193      location: location
1194    });
1195  }
1196
1197  function push(to, state) {
1198    var nextAction = Action.Push;
1199    var nextLocation = getNextLocation(to, state);
1200
1201    function retry() {
1202      push(to, state);
1203    }
1204
1205     false ? 0 : void 0;
1206
1207    if (allowTx(nextAction, nextLocation, retry)) {
1208      var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1),
1209          historyState = _getHistoryStateAndUr3[0],
1210          url = _getHistoryStateAndUr3[1]; // TODO: Support forced reloading
1211      // try...catch because iOS limits us to 100 pushState calls :/
1212
1213
1214      try {
1215        globalHistory.pushState(historyState, '', url);
1216      } catch (error) {
1217        // They are going to lose state here, but there is no real
1218        // way to warn them about it since the page will refresh...
1219        window.location.assign(url);
1220      }
1221
1222      applyTx(nextAction);
1223    }
1224  }
1225
1226  function replace(to, state) {
1227    var nextAction = Action.Replace;
1228    var nextLocation = getNextLocation(to, state);
1229
1230    function retry() {
1231      replace(to, state);
1232    }
1233
1234     false ? 0 : void 0;
1235
1236    if (allowTx(nextAction, nextLocation, retry)) {
1237      var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index),
1238          historyState = _getHistoryStateAndUr4[0],
1239          url = _getHistoryStateAndUr4[1]; // TODO: Support forced reloading
1240
1241
1242      globalHistory.replaceState(historyState, '', url);
1243      applyTx(nextAction);
1244    }
1245  }
1246
1247  function go(delta) {
1248    globalHistory.go(delta);
1249  }
1250
1251  var history = {
1252    get action() {
1253      return action;
1254    },
1255
1256    get location() {
1257      return location;
1258    },
1259
1260    createHref: createHref,
1261    push: push,
1262    replace: replace,
1263    go: go,
1264    back: function back() {
1265      go(-1);
1266    },
1267    forward: function forward() {
1268      go(1);
1269    },
1270    listen: function listen(listener) {
1271      return listeners.push(listener);
1272    },
1273    block: function block(blocker) {
1274      var unblock = blockers.push(blocker);
1275
1276      if (blockers.length === 1) {
1277        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
1278      }
1279
1280      return function () {
1281        unblock(); // Remove the beforeunload listener so the document may
1282        // still be salvageable in the pagehide event.
1283        // See https://html.spec.whatwg.org/#unloading-documents
1284
1285        if (!blockers.length) {
1286          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
1287        }
1288      };
1289    }
1290  };
1291  return history;
1292}
1293/**
1294 * Memory history stores the current location in memory. It is designed for use
1295 * in stateful non-browser environments like tests and React Native.
1296 *
1297 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory
1298 */
1299
1300function createMemoryHistory(options) {
1301  if (options === void 0) {
1302    options = {};
1303  }
1304
1305  var _options3 = options,
1306      _options3$initialEntr = _options3.initialEntries,
1307      initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,
1308      initialIndex = _options3.initialIndex;
1309  var entries = initialEntries.map(function (entry) {
1310    var location = readOnly(_extends({
1311      pathname: '/',
1312      search: '',
1313      hash: '',
1314      state: null,
1315      key: createKey()
1316    }, typeof entry === 'string' ? parsePath(entry) : entry));
1317     false ? 0 : void 0;
1318    return location;
1319  });
1320  var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);
1321  var action = Action.Pop;
1322  var location = entries[index];
1323  var listeners = createEvents();
1324  var blockers = createEvents();
1325
1326  function createHref(to) {
1327    return typeof to === 'string' ? to : createPath(to);
1328  }
1329
1330  function getNextLocation(to, state) {
1331    if (state === void 0) {
1332      state = null;
1333    }
1334
1335    return readOnly(_extends({
1336      pathname: location.pathname,
1337      search: '',
1338      hash: ''
1339    }, typeof to === 'string' ? parsePath(to) : to, {
1340      state: state,
1341      key: createKey()
1342    }));
1343  }
1344
1345  function allowTx(action, location, retry) {
1346    return !blockers.length || (blockers.call({
1347      action: action,
1348      location: location,
1349      retry: retry
1350    }), false);
1351  }
1352
1353  function applyTx(nextAction, nextLocation) {
1354    action = nextAction;
1355    location = nextLocation;
1356    listeners.call({
1357      action: action,
1358      location: location
1359    });
1360  }
1361
1362  function push(to, state) {
1363    var nextAction = Action.Push;
1364    var nextLocation = getNextLocation(to, state);
1365
1366    function retry() {
1367      push(to, state);
1368    }
1369
1370     false ? 0 : void 0;
1371
1372    if (allowTx(nextAction, nextLocation, retry)) {
1373      index += 1;
1374      entries.splice(index, entries.length, nextLocation);
1375      applyTx(nextAction, nextLocation);
1376    }
1377  }
1378
1379  function replace(to, state) {
1380    var nextAction = Action.Replace;
1381    var nextLocation = getNextLocation(to, state);
1382
1383    function retry() {
1384      replace(to, state);
1385    }
1386
1387     false ? 0 : void 0;
1388
1389    if (allowTx(nextAction, nextLocation, retry)) {
1390      entries[index] = nextLocation;
1391      applyTx(nextAction, nextLocation);
1392    }
1393  }
1394
1395  function go(delta) {
1396    var nextIndex = clamp(index + delta, 0, entries.length - 1);
1397    var nextAction = Action.Pop;
1398    var nextLocation = entries[nextIndex];
1399
1400    function retry() {
1401      go(delta);
1402    }
1403
1404    if (allowTx(nextAction, nextLocation, retry)) {
1405      index = nextIndex;
1406      applyTx(nextAction, nextLocation);
1407    }
1408  }
1409
1410  var history = {
1411    get index() {
1412      return index;
1413    },
1414
1415    get action() {
1416      return action;
1417    },
1418
1419    get location() {
1420      return location;
1421    },
1422
1423    createHref: createHref,
1424    push: push,
1425    replace: replace,
1426    go: go,
1427    back: function back() {
1428      go(-1);
1429    },
1430    forward: function forward() {
1431      go(1);
1432    },
1433    listen: function listen(listener) {
1434      return listeners.push(listener);
1435    },
1436    block: function block(blocker) {
1437      return blockers.push(blocker);
1438    }
1439  };
1440  return history;
1441} ////////////////////////////////////////////////////////////////////////////////
1442// UTILS
1443////////////////////////////////////////////////////////////////////////////////
1444
1445function clamp(n, lowerBound, upperBound) {
1446  return Math.min(Math.max(n, lowerBound), upperBound);
1447}
1448
1449function promptBeforeUnload(event) {
1450  // Cancel the event.
1451  event.preventDefault(); // Chrome (and legacy IE) requires returnValue to be set.
1452
1453  event.returnValue = '';
1454}
1455
1456function createEvents() {
1457  var handlers = [];
1458  return {
1459    get length() {
1460      return handlers.length;
1461    },
1462
1463    push: function push(fn) {
1464      handlers.push(fn);
1465      return function () {
1466        handlers = handlers.filter(function (handler) {
1467          return handler !== fn;
1468        });
1469      };
1470    },
1471    call: function call(arg) {
1472      handlers.forEach(function (fn) {
1473        return fn && fn(arg);
1474      });
1475    }
1476  };
1477}
1478
1479function createKey() {
1480  return Math.random().toString(36).substr(2, 8);
1481}
1482/**
1483 * Creates a string URL path from the given pathname, search, and hash components.
1484 *
1485 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath
1486 */
1487
1488
1489function createPath(_ref) {
1490  var _ref$pathname = _ref.pathname,
1491      pathname = _ref$pathname === void 0 ? '/' : _ref$pathname,
1492      _ref$search = _ref.search,
1493      search = _ref$search === void 0 ? '' : _ref$search,
1494      _ref$hash = _ref.hash,
1495      hash = _ref$hash === void 0 ? '' : _ref$hash;
1496  if (search && search !== '?') pathname += search.charAt(0) === '?' ? search : '?' + search;
1497  if (hash && hash !== '#') pathname += hash.charAt(0) === '#' ? hash : '#' + hash;
1498  return pathname;
1499}
1500/**
1501 * Parses a string URL path into its separate pathname, search, and hash components.
1502 *
1503 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath
1504 */
1505
1506function parsePath(path) {
1507  var parsedPath = {};
1508
1509  if (path) {
1510    var hashIndex = path.indexOf('#');
1511
1512    if (hashIndex >= 0) {
1513      parsedPath.hash = path.substr(hashIndex);
1514      path = path.substr(0, hashIndex);
1515    }
1516
1517    var searchIndex = path.indexOf('?');
1518
1519    if (searchIndex >= 0) {
1520      parsedPath.search = path.substr(searchIndex);
1521      path = path.substr(0, searchIndex);
1522    }
1523
1524    if (path) {
1525      parsedPath.pathname = path;
1526    }
1527  }
1528
1529  return parsedPath;
1530}
1531
1532
1533
1534;// external ["wp","element"]
1535const external_wp_element_namespaceObject = window["wp"]["element"];
1536;// external ["wp","url"]
1537const external_wp_url_namespaceObject = window["wp"]["url"];
1538;// external ["wp","compose"]
1539const external_wp_compose_namespaceObject = window["wp"]["compose"];
1540;// ./node_modules/@wordpress/router/build-module/router.js
1541
1542
1543
1544
1545
1546
1547const router_history = createBrowserHistory();
1548const RoutesContext = (0,external_wp_element_namespaceObject.createContext)(null);
1549RoutesContext.displayName = "RoutesContext";
1550const ConfigContext = (0,external_wp_element_namespaceObject.createContext)({ pathArg: "p" });
1551ConfigContext.displayName = "ConfigContext";
1552const locationMemo = /* @__PURE__ */ new WeakMap();
1553function getLocationWithQuery() {
1554  const location = router_history.location;
1555  let locationWithQuery = locationMemo.get(location);
1556  if (!locationWithQuery) {
1557    locationWithQuery = {
1558      ...location,
1559      query: Object.fromEntries(new URLSearchParams(location.search))
1560    };
1561    locationMemo.set(location, locationWithQuery);
1562  }
1563  return locationWithQuery;
1564}
1565function useLocation() {
1566  const context = (0,external_wp_element_namespaceObject.useContext)(RoutesContext);
1567  if (!context) {
1568    throw new Error("useLocation must be used within a RouterProvider");
1569  }
1570  return context;
1571}
1572function useHistory() {
1573  const { pathArg, beforeNavigate } = (0,external_wp_element_namespaceObject.useContext)(ConfigContext);
1574  const navigate = (0,external_wp_compose_namespaceObject.useEvent)(
1575    async (rawPath, options = {}) => {
1576      const query = (0,external_wp_url_namespaceObject.getQueryArgs)(rawPath);
1577      const path = (0,external_wp_url_namespaceObject.getPath)("http://domain.com/" + rawPath) ?? "";
1578      const performPush = () => {
1579        const result = beforeNavigate ? beforeNavigate({ path, query }) : { path, query };
1580        return router_history.push(
1581          {
1582            search: (0,external_wp_url_namespaceObject.buildQueryString)({
1583              [pathArg]: result.path,
1584              ...result.query
1585            })
1586          },
1587          options.state
1588        );
1589      };
1590      const isMediumOrBigger = window.matchMedia("(min-width: 782px)").matches;
1591      if (!isMediumOrBigger || !document.startViewTransition || !options.transition) {
1592        performPush();
1593        return;
1594      }
1595      await new Promise((resolve) => {
1596        const classname = options.transition ?? "";
1597        document.documentElement.classList.add(classname);
1598        const transition = document.startViewTransition(
1599          () => performPush()
1600        );
1601        transition.finished.finally(() => {
1602          document.documentElement.classList.remove(classname);
1603          resolve();
1604        });
1605      });
1606    }
1607  );
1608  return (0,external_wp_element_namespaceObject.useMemo)(
1609    () => ({
1610      navigate,
1611      back: router_history.back,
1612      invalidate: () => {
1613        router_history.replace({
1614          search: router_history.location.search
1615        });
1616      }
1617    }),
1618    [navigate]
1619  );
1620}
1621function useMatch(location, matcher, pathArg, matchResolverArgs) {
1622  const { query: rawQuery = {} } = location;
1623  const [resolvedMatch, setMatch] = (0,external_wp_element_namespaceObject.useState)();
1624  (0,external_wp_element_namespaceObject.useEffect)(() => {
1625    const { [pathArg]: path = "/", ...query } = rawQuery;
1626    const ret = matcher.recognize(path)?.[0];
1627    async function resolveMatch(result) {
1628      const matchedRoute = result.handler;
1629      const resolveFunctions = async (record = {}) => {
1630        const entries = await Promise.all(
1631          Object.entries(record).map(async ([key, value]) => {
1632            if (typeof value === "function") {
1633              return [
1634                key,
1635                await value({
1636                  query,
1637                  params: result.params,
1638                  ...matchResolverArgs
1639                })
1640              ];
1641            }
1642            return [key, value];
1643          })
1644        );
1645        return Object.fromEntries(entries);
1646      };
1647      const [resolvedAreas, resolvedWidths] = await Promise.all([
1648        resolveFunctions(matchedRoute.areas),
1649        resolveFunctions(matchedRoute.widths)
1650      ]);
1651      setMatch({
1652        name: matchedRoute.name,
1653        areas: resolvedAreas,
1654        widths: resolvedWidths,
1655        params: result.params,
1656        query,
1657        path: (0,external_wp_url_namespaceObject.addQueryArgs)(path, query)
1658      });
1659    }
1660    if (!ret) {
1661      setMatch({
1662        name: "404",
1663        path: (0,external_wp_url_namespaceObject.addQueryArgs)(path, query),
1664        areas: {},
1665        widths: {},
1666        query,
1667        params: {}
1668      });
1669    } else {
1670      resolveMatch(ret);
1671    }
1672    return () => setMatch(void 0);
1673  }, [matcher, rawQuery, pathArg, matchResolverArgs]);
1674  return resolvedMatch;
1675}
1676function RouterProvider({
1677  routes,
1678  pathArg,
1679  beforeNavigate,
1680  children,
1681  matchResolverArgs
1682}) {
1683  const location = (0,external_wp_element_namespaceObject.useSyncExternalStore)(
1684    router_history.listen,
1685    getLocationWithQuery,
1686    getLocationWithQuery
1687  );
1688  const matcher = (0,external_wp_element_namespaceObject.useMemo)(() => {
1689    const ret = new route_recognizer_es();
1690    (routes ?? []).forEach((route) => {
1691      ret.add([{ path: route.path, handler: route }], {
1692        as: route.name
1693      });
1694    });
1695    return ret;
1696  }, [routes]);
1697  const match = useMatch(location, matcher, pathArg, matchResolverArgs);
1698  const previousMatch = (0,external_wp_compose_namespaceObject.usePrevious)(match);
1699  const config = (0,external_wp_element_namespaceObject.useMemo)(
1700    () => ({ beforeNavigate, pathArg }),
1701    [beforeNavigate, pathArg]
1702  );
1703  const renderedMatch = match || previousMatch;
1704  if (!renderedMatch) {
1705    return null;
1706  }
1707  return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ConfigContext.Provider, { value: config, children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RoutesContext.Provider, { value: renderedMatch, children }) });
1708}
1709
1710
1711;// ./node_modules/@wordpress/router/build-module/link.js
1712
1713
1714
1715
1716function useLink(to, options = {}) {
1717  const history = useHistory();
1718  const { pathArg, beforeNavigate } = (0,external_wp_element_namespaceObject.useContext)(ConfigContext);
1719  function onClick(event) {
1720    event?.preventDefault();
1721    history.navigate(to, options);
1722  }
1723  const query = (0,external_wp_url_namespaceObject.getQueryArgs)(to);
1724  const path = (0,external_wp_url_namespaceObject.getPath)("http://domain.com/" + to) ?? "";
1725  const link = (0,external_wp_element_namespaceObject.useMemo)(() => {
1726    return beforeNavigate ? beforeNavigate({ path, query }) : { path, query };
1727  }, [path, query, beforeNavigate]);
1728  const [before] = window.location.href.split("?");
1729  return {
1730    href: `${before}?${(0,external_wp_url_namespaceObject.buildQueryString)({
1731      [pathArg]: link.path,
1732      ...link.query
1733    })}`,
1734    onClick
1735  };
1736}
1737function Link({
1738  to,
1739  options,
1740  children,
1741  ...props
1742}) {
1743  const { href, onClick } = useLink(to, options);
1744  return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("a", { href, onClick, ...props, children });
1745}
1746
1747
1748;// external ["wp","privateApis"]
1749const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
1750;// ./node_modules/@wordpress/router/build-module/lock-unlock.js
1751
1752const { lock, unlock } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
1753  "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
1754  "@wordpress/router"
1755);
1756
1757
1758;// ./node_modules/@wordpress/router/build-module/private-apis.js
1759
1760
1761
1762const privateApis = {};
1763lock(privateApis, {
1764  useHistory: useHistory,
1765  useLocation: useLocation,
1766  RouterProvider: RouterProvider,
1767  useLink: useLink,
1768  Link: Link
1769});
1770
1771
1772;// ./node_modules/@wordpress/router/build-module/index.js
1773
1774
1775
1776(window.wp = window.wp || {}).router = __webpack_exports__;
1777/******/ })()
1778;