File: /www/wwwroot/www.waciwang.com/wp-content/plugins/gutenberg/build/modules/route/index.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// vendor-external:react/jsx-runtime
var require_jsx_runtime = __commonJS({
"vendor-external:react/jsx-runtime"(exports, module) {
module.exports = window.ReactJSXRuntime;
}
});
// vendor-external:react
var require_react = __commonJS({
"vendor-external:react"(exports, module) {
module.exports = window.React;
}
});
// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
var require_use_sync_external_store_shim_development = __commonJS({
"node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
"use strict";
(function() {
function is(x, y) {
return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
}
function useSyncExternalStore$2(subscribe2, getSnapshot) {
didWarnOld18Alpha || void 0 === React12.startTransition || (didWarnOld18Alpha = true, console.error(
"You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
));
var value = getSnapshot();
if (!didWarnUncachedGetSnapshot) {
var cachedValue = getSnapshot();
objectIs(value, cachedValue) || (console.error(
"The result of getSnapshot should be cached to avoid an infinite loop"
), didWarnUncachedGetSnapshot = true);
}
cachedValue = useState4({
inst: { value, getSnapshot }
});
var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
useLayoutEffect3(
function() {
inst.value = value;
inst.getSnapshot = getSnapshot;
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
},
[subscribe2, value, getSnapshot]
);
useEffect5(
function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
return subscribe2(function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
});
},
[subscribe2]
);
useDebugValue(value);
return value;
}
function checkIfSnapshotChanged(inst) {
var latestGetSnapshot = inst.getSnapshot;
inst = inst.value;
try {
var nextValue = latestGetSnapshot();
return !objectIs(inst, nextValue);
} catch (error) {
return true;
}
}
function useSyncExternalStore$1(subscribe2, getSnapshot) {
return getSnapshot();
}
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
var React12 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState4 = React12.useState, useEffect5 = React12.useEffect, useLayoutEffect3 = React12.useLayoutEffect, useDebugValue = React12.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
exports.useSyncExternalStore = void 0 !== React12.useSyncExternalStore ? React12.useSyncExternalStore : shim;
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
})();
}
});
// node_modules/use-sync-external-store/shim/index.js
var require_shim = __commonJS({
"node_modules/use-sync-external-store/shim/index.js"(exports, module) {
"use strict";
if (false) {
module.exports = null;
} else {
module.exports = require_use_sync_external_store_shim_development();
}
}
});
// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
var require_with_selector_development = __commonJS({
"node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js"(exports) {
"use strict";
(function() {
function is(x, y) {
return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
}
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
var React12 = require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef7 = React12.useRef, useEffect5 = React12.useEffect, useMemo3 = React12.useMemo, useDebugValue = React12.useDebugValue;
exports.useSyncExternalStoreWithSelector = function(subscribe2, getSnapshot, getServerSnapshot, selector, isEqual) {
var instRef = useRef7(null);
if (null === instRef.current) {
var inst = { hasValue: false, value: null };
instRef.current = inst;
} else inst = instRef.current;
instRef = useMemo3(
function() {
function memoizedSelector(nextSnapshot) {
if (!hasMemo) {
hasMemo = true;
memoizedSnapshot = nextSnapshot;
nextSnapshot = selector(nextSnapshot);
if (void 0 !== isEqual && inst.hasValue) {
var currentSelection = inst.value;
if (isEqual(currentSelection, nextSnapshot))
return memoizedSelection = currentSelection;
}
return memoizedSelection = nextSnapshot;
}
currentSelection = memoizedSelection;
if (objectIs(memoizedSnapshot, nextSnapshot))
return currentSelection;
var nextSelection = selector(nextSnapshot);
if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
return memoizedSnapshot = nextSnapshot, currentSelection;
memoizedSnapshot = nextSnapshot;
return memoizedSelection = nextSelection;
}
var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
return [
function() {
return memoizedSelector(getSnapshot());
},
null === maybeGetServerSnapshot ? void 0 : function() {
return memoizedSelector(maybeGetServerSnapshot());
}
];
},
[getSnapshot, getServerSnapshot, selector, isEqual]
);
var value = useSyncExternalStore(subscribe2, instRef[0], instRef[1]);
useEffect5(
function() {
inst.hasValue = true;
inst.value = value;
},
[value]
);
useDebugValue(value);
return value;
};
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
})();
}
});
// node_modules/use-sync-external-store/shim/with-selector.js
var require_with_selector = __commonJS({
"node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) {
"use strict";
if (false) {
module.exports = null;
} else {
module.exports = require_with_selector_development();
}
}
});
// vendor-external:react-dom
var require_react_dom = __commonJS({
"vendor-external:react-dom"(exports, module) {
module.exports = window.ReactDOM;
}
});
// package-external:@wordpress/private-apis
var require_private_apis = __commonJS({
"package-external:@wordpress/private-apis"(exports, module) {
module.exports = window.wp.privateApis;
}
});
// node_modules/@tanstack/store/dist/esm/scheduler.js
var __storeToDerived = /* @__PURE__ */ new WeakMap();
var __derivedToStore = /* @__PURE__ */ new WeakMap();
var __depsThatHaveWrittenThisTick = {
current: []
};
var __isFlushing = false;
var __batchDepth = 0;
var __pendingUpdates = /* @__PURE__ */ new Set();
var __initialBatchValues = /* @__PURE__ */ new Map();
function __flush_internals(relatedVals) {
for (const derived of relatedVals) {
if (__depsThatHaveWrittenThisTick.current.includes(derived)) {
continue;
}
__depsThatHaveWrittenThisTick.current.push(derived);
derived.recompute();
const stores = __derivedToStore.get(derived);
if (stores) {
for (const store of stores) {
const relatedLinkedDerivedVals = __storeToDerived.get(store);
if (!(relatedLinkedDerivedVals == null ? void 0 : relatedLinkedDerivedVals.length)) continue;
__flush_internals(relatedLinkedDerivedVals);
}
}
}
}
function __notifyListeners(store) {
const value = {
prevVal: store.prevState,
currentVal: store.state
};
for (const listener of store.listeners) {
listener(value);
}
}
function __notifyDerivedListeners(derived) {
const value = {
prevVal: derived.prevState,
currentVal: derived.state
};
for (const listener of derived.listeners) {
listener(value);
}
}
function __flush(store) {
if (__batchDepth > 0 && !__initialBatchValues.has(store)) {
__initialBatchValues.set(store, store.prevState);
}
__pendingUpdates.add(store);
if (__batchDepth > 0) return;
if (__isFlushing) return;
try {
__isFlushing = true;
while (__pendingUpdates.size > 0) {
const stores = Array.from(__pendingUpdates);
__pendingUpdates.clear();
for (const store2 of stores) {
const prevState = __initialBatchValues.get(store2) ?? store2.prevState;
store2.prevState = prevState;
__notifyListeners(store2);
}
for (const store2 of stores) {
const derivedVals = __storeToDerived.get(store2);
if (!derivedVals) continue;
__depsThatHaveWrittenThisTick.current.push(store2);
__flush_internals(derivedVals);
}
for (const store2 of stores) {
const derivedVals = __storeToDerived.get(store2);
if (!derivedVals) continue;
for (const derived of derivedVals) {
__notifyDerivedListeners(derived);
}
}
}
} finally {
__isFlushing = false;
__depsThatHaveWrittenThisTick.current = [];
__initialBatchValues.clear();
}
}
function batch(fn) {
__batchDepth++;
try {
fn();
} finally {
__batchDepth--;
if (__batchDepth === 0) {
const pendingUpdateToFlush = __pendingUpdates.values().next().value;
if (pendingUpdateToFlush) {
__flush(pendingUpdateToFlush);
}
}
}
}
// node_modules/@tanstack/store/dist/esm/types.js
function isUpdaterFunction(updater) {
return typeof updater === "function";
}
// node_modules/@tanstack/store/dist/esm/store.js
var Store = class {
constructor(initialState, options) {
this.listeners = /* @__PURE__ */ new Set();
this.subscribe = (listener) => {
var _a, _b;
this.listeners.add(listener);
const unsub = (_b = (_a = this.options) == null ? void 0 : _a.onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
return () => {
this.listeners.delete(listener);
unsub == null ? void 0 : unsub();
};
};
this.prevState = initialState;
this.state = initialState;
this.options = options;
}
setState(updater) {
var _a, _b, _c;
this.prevState = this.state;
if ((_a = this.options) == null ? void 0 : _a.updateFn) {
this.state = this.options.updateFn(this.prevState)(updater);
} else {
if (isUpdaterFunction(updater)) {
this.state = updater(this.prevState);
} else {
this.state = updater;
}
}
(_c = (_b = this.options) == null ? void 0 : _b.onUpdate) == null ? void 0 : _c.call(_b);
__flush(this);
}
};
// node_modules/@tanstack/history/dist/esm/index.js
var stateIndexKey = "__TSR_index";
var popStateEvent = "popstate";
var beforeUnloadEvent = "beforeunload";
function createHistory(opts) {
let location = opts.getLocation();
const subscribers = /* @__PURE__ */ new Set();
const notify = (action) => {
location = opts.getLocation();
subscribers.forEach((subscriber) => subscriber({ location, action }));
};
const handleIndexChange = (action) => {
if (opts.notifyOnIndexChange ?? true) notify(action);
else location = opts.getLocation();
};
const tryNavigation = async ({
task,
navigateOpts,
...actionInfo
}) => {
const ignoreBlocker = navigateOpts?.ignoreBlocker ?? false;
if (ignoreBlocker) {
task();
return;
}
const blockers = opts.getBlockers?.() ?? [];
const isPushOrReplace = actionInfo.type === "PUSH" || actionInfo.type === "REPLACE";
if (typeof document !== "undefined" && blockers.length && isPushOrReplace) {
for (const blocker of blockers) {
const nextLocation = parseHref(actionInfo.path, actionInfo.state);
const isBlocked = await blocker.blockerFn({
currentLocation: location,
nextLocation,
action: actionInfo.type
});
if (isBlocked) {
opts.onBlocked?.();
return;
}
}
}
task();
};
return {
get location() {
return location;
},
get length() {
return opts.getLength();
},
subscribers,
subscribe: (cb) => {
subscribers.add(cb);
return () => {
subscribers.delete(cb);
};
},
push: (path, state, navigateOpts) => {
const currentIndex = location.state[stateIndexKey];
state = assignKeyAndIndex(currentIndex + 1, state);
tryNavigation({
task: () => {
opts.pushState(path, state);
notify({ type: "PUSH" });
},
navigateOpts,
type: "PUSH",
path,
state
});
},
replace: (path, state, navigateOpts) => {
const currentIndex = location.state[stateIndexKey];
state = assignKeyAndIndex(currentIndex, state);
tryNavigation({
task: () => {
opts.replaceState(path, state);
notify({ type: "REPLACE" });
},
navigateOpts,
type: "REPLACE",
path,
state
});
},
go: (index, navigateOpts) => {
tryNavigation({
task: () => {
opts.go(index);
handleIndexChange({ type: "GO", index });
},
navigateOpts,
type: "GO"
});
},
back: (navigateOpts) => {
tryNavigation({
task: () => {
opts.back(navigateOpts?.ignoreBlocker ?? false);
handleIndexChange({ type: "BACK" });
},
navigateOpts,
type: "BACK"
});
},
forward: (navigateOpts) => {
tryNavigation({
task: () => {
opts.forward(navigateOpts?.ignoreBlocker ?? false);
handleIndexChange({ type: "FORWARD" });
},
navigateOpts,
type: "FORWARD"
});
},
canGoBack: () => location.state[stateIndexKey] !== 0,
createHref: (str) => opts.createHref(str),
block: (blocker) => {
if (!opts.setBlockers) return () => {
};
const blockers = opts.getBlockers?.() ?? [];
opts.setBlockers([...blockers, blocker]);
return () => {
const blockers2 = opts.getBlockers?.() ?? [];
opts.setBlockers?.(blockers2.filter((b) => b !== blocker));
};
},
flush: () => opts.flush?.(),
destroy: () => opts.destroy?.(),
notify
};
}
function assignKeyAndIndex(index, state) {
if (!state) {
state = {};
}
const key = createRandomKey();
return {
...state,
key,
// TODO: Remove in v2 - use __TSR_key instead
__TSR_key: key,
[stateIndexKey]: index
};
}
function createBrowserHistory(opts) {
const win = opts?.window ?? (typeof document !== "undefined" ? window : void 0);
const originalPushState = win.history.pushState;
const originalReplaceState = win.history.replaceState;
let blockers = [];
const _getBlockers = () => blockers;
const _setBlockers = (newBlockers) => blockers = newBlockers;
const createHref = opts?.createHref ?? ((path) => path);
const parseLocation = opts?.parseLocation ?? (() => parseHref(
`${win.location.pathname}${win.location.search}${win.location.hash}`,
win.history.state
));
if (!win.history.state?.__TSR_key && !win.history.state?.key) {
const addedKey = createRandomKey();
win.history.replaceState(
{
[stateIndexKey]: 0,
key: addedKey,
// TODO: Remove in v2 - use __TSR_key instead
__TSR_key: addedKey
},
""
);
}
let currentLocation = parseLocation();
let rollbackLocation;
let nextPopIsGo = false;
let ignoreNextPop = false;
let skipBlockerNextPop = false;
let ignoreNextBeforeUnload = false;
const getLocation = () => currentLocation;
let next;
let scheduled;
const flush = () => {
if (!next) {
return;
}
history._ignoreSubscribers = true;
(next.isPush ? win.history.pushState : win.history.replaceState)(
next.state,
"",
next.href
);
history._ignoreSubscribers = false;
next = void 0;
scheduled = void 0;
rollbackLocation = void 0;
};
const queueHistoryAction = (type, destHref, state) => {
const href = createHref(destHref);
if (!scheduled) {
rollbackLocation = currentLocation;
}
currentLocation = parseHref(destHref, state);
next = {
href,
state,
isPush: next?.isPush || type === "push"
};
if (!scheduled) {
scheduled = Promise.resolve().then(() => flush());
}
};
const onPushPop = (type) => {
currentLocation = parseLocation();
history.notify({ type });
};
const onPushPopEvent = async () => {
if (ignoreNextPop) {
ignoreNextPop = false;
return;
}
const nextLocation = parseLocation();
const delta = nextLocation.state[stateIndexKey] - currentLocation.state[stateIndexKey];
const isForward = delta === 1;
const isBack = delta === -1;
const isGo = !isForward && !isBack || nextPopIsGo;
nextPopIsGo = false;
const action = isGo ? "GO" : isBack ? "BACK" : "FORWARD";
const notify = isGo ? {
type: "GO",
index: delta
} : {
type: isBack ? "BACK" : "FORWARD"
};
if (skipBlockerNextPop) {
skipBlockerNextPop = false;
} else {
const blockers2 = _getBlockers();
if (typeof document !== "undefined" && blockers2.length) {
for (const blocker of blockers2) {
const isBlocked = await blocker.blockerFn({
currentLocation,
nextLocation,
action
});
if (isBlocked) {
ignoreNextPop = true;
win.history.go(1);
history.notify(notify);
return;
}
}
}
}
currentLocation = parseLocation();
history.notify(notify);
};
const onBeforeUnload = (e) => {
if (ignoreNextBeforeUnload) {
ignoreNextBeforeUnload = false;
return;
}
let shouldBlock = false;
const blockers2 = _getBlockers();
if (typeof document !== "undefined" && blockers2.length) {
for (const blocker of blockers2) {
const shouldHaveBeforeUnload = blocker.enableBeforeUnload ?? true;
if (shouldHaveBeforeUnload === true) {
shouldBlock = true;
break;
}
if (typeof shouldHaveBeforeUnload === "function" && shouldHaveBeforeUnload() === true) {
shouldBlock = true;
break;
}
}
}
if (shouldBlock) {
e.preventDefault();
return e.returnValue = "";
}
return;
};
const history = createHistory({
getLocation,
getLength: () => win.history.length,
pushState: (href, state) => queueHistoryAction("push", href, state),
replaceState: (href, state) => queueHistoryAction("replace", href, state),
back: (ignoreBlocker) => {
if (ignoreBlocker) skipBlockerNextPop = true;
ignoreNextBeforeUnload = true;
return win.history.back();
},
forward: (ignoreBlocker) => {
if (ignoreBlocker) skipBlockerNextPop = true;
ignoreNextBeforeUnload = true;
win.history.forward();
},
go: (n) => {
nextPopIsGo = true;
win.history.go(n);
},
createHref: (href) => createHref(href),
flush,
destroy: () => {
win.history.pushState = originalPushState;
win.history.replaceState = originalReplaceState;
win.removeEventListener(beforeUnloadEvent, onBeforeUnload, {
capture: true
});
win.removeEventListener(popStateEvent, onPushPopEvent);
},
onBlocked: () => {
if (rollbackLocation && currentLocation !== rollbackLocation) {
currentLocation = rollbackLocation;
}
},
getBlockers: _getBlockers,
setBlockers: _setBlockers,
notifyOnIndexChange: false
});
win.addEventListener(beforeUnloadEvent, onBeforeUnload, { capture: true });
win.addEventListener(popStateEvent, onPushPopEvent);
win.history.pushState = function(...args) {
const res = originalPushState.apply(win.history, args);
if (!history._ignoreSubscribers) onPushPop("PUSH");
return res;
};
win.history.replaceState = function(...args) {
const res = originalReplaceState.apply(win.history, args);
if (!history._ignoreSubscribers) onPushPop("REPLACE");
return res;
};
return history;
}
function parseHref(href, state) {
const hashIndex = href.indexOf("#");
const searchIndex = href.indexOf("?");
const addedKey = createRandomKey();
return {
href,
pathname: href.substring(
0,
hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : href.length
),
hash: hashIndex > -1 ? href.substring(hashIndex) : "",
search: searchIndex > -1 ? href.slice(searchIndex, hashIndex === -1 ? void 0 : hashIndex) : "",
state: state || { [stateIndexKey]: 0, key: addedKey, __TSR_key: addedKey }
};
}
function createRandomKey() {
return (Math.random() + 1).toString(36).substring(7);
}
// node_modules/@tanstack/router-core/dist/esm/utils.js
function last(arr) {
return arr[arr.length - 1];
}
function isFunction(d) {
return typeof d === "function";
}
function functionalUpdate(updater, previous) {
if (isFunction(updater)) {
return updater(previous);
}
return updater;
}
var hasOwn = Object.prototype.hasOwnProperty;
function replaceEqualDeep(prev, _next) {
if (prev === _next) {
return prev;
}
const next = _next;
const array = isPlainArray(prev) && isPlainArray(next);
if (!array && !(isPlainObject(prev) && isPlainObject(next))) return next;
const prevItems = array ? prev : getEnumerableOwnKeys(prev);
if (!prevItems) return next;
const nextItems = array ? next : getEnumerableOwnKeys(next);
if (!nextItems) return next;
const prevSize = prevItems.length;
const nextSize = nextItems.length;
const copy = array ? new Array(nextSize) : {};
let equalItems = 0;
for (let i = 0; i < nextSize; i++) {
const key = array ? i : nextItems[i];
const p = prev[key];
const n = next[key];
if (p === n) {
copy[key] = p;
if (array ? i < prevSize : hasOwn.call(prev, key)) equalItems++;
continue;
}
if (p === null || n === null || typeof p !== "object" || typeof n !== "object") {
copy[key] = n;
continue;
}
const v = replaceEqualDeep(p, n);
copy[key] = v;
if (v === p) equalItems++;
}
return prevSize === nextSize && equalItems === prevSize ? prev : copy;
}
function getEnumerableOwnKeys(o) {
const keys = [];
const names = Object.getOwnPropertyNames(o);
for (const name of names) {
if (!Object.prototype.propertyIsEnumerable.call(o, name)) return false;
keys.push(name);
}
const symbols = Object.getOwnPropertySymbols(o);
for (const symbol of symbols) {
if (!Object.prototype.propertyIsEnumerable.call(o, symbol)) return false;
keys.push(symbol);
}
return keys;
}
function isPlainObject(o) {
if (!hasObjectPrototype(o)) {
return false;
}
const ctor = o.constructor;
if (typeof ctor === "undefined") {
return true;
}
const prot = ctor.prototype;
if (!hasObjectPrototype(prot)) {
return false;
}
if (!prot.hasOwnProperty("isPrototypeOf")) {
return false;
}
return true;
}
function hasObjectPrototype(o) {
return Object.prototype.toString.call(o) === "[object Object]";
}
function isPlainArray(value) {
return Array.isArray(value) && value.length === Object.keys(value).length;
}
function deepEqual(a, b, opts) {
if (a === b) {
return true;
}
if (typeof a !== typeof b) {
return false;
}
if (Array.isArray(a) && Array.isArray(b)) {
if (a.length !== b.length) return false;
for (let i = 0, l = a.length; i < l; i++) {
if (!deepEqual(a[i], b[i], opts)) return false;
}
return true;
}
if (isPlainObject(a) && isPlainObject(b)) {
const ignoreUndefined = opts?.ignoreUndefined ?? true;
if (opts?.partial) {
for (const k in b) {
if (!ignoreUndefined || b[k] !== void 0) {
if (!deepEqual(a[k], b[k], opts)) return false;
}
}
return true;
}
let aCount = 0;
if (!ignoreUndefined) {
aCount = Object.keys(a).length;
} else {
for (const k in a) {
if (a[k] !== void 0) aCount++;
}
}
let bCount = 0;
for (const k in b) {
if (!ignoreUndefined || b[k] !== void 0) {
bCount++;
if (bCount > aCount || !deepEqual(a[k], b[k], opts)) return false;
}
}
return aCount === bCount;
}
return false;
}
function createControlledPromise(onResolve) {
let resolveLoadPromise;
let rejectLoadPromise;
const controlledPromise = new Promise((resolve, reject) => {
resolveLoadPromise = resolve;
rejectLoadPromise = reject;
});
controlledPromise.status = "pending";
controlledPromise.resolve = (value) => {
controlledPromise.status = "resolved";
controlledPromise.value = value;
resolveLoadPromise(value);
onResolve?.(value);
};
controlledPromise.reject = (e) => {
controlledPromise.status = "rejected";
rejectLoadPromise(e);
};
return controlledPromise;
}
function isPromise(value) {
return Boolean(
value && typeof value === "object" && typeof value.then === "function"
);
}
function findLast(array, predicate) {
for (let i = array.length - 1; i >= 0; i--) {
const item = array[i];
if (predicate(item)) return item;
}
return void 0;
}
var DECODE_IGNORE_LIST = Array.from(
(/* @__PURE__ */ new Map([
["%", "%25"],
["\\", "%5C"],
["/", "%2F"],
[";", "%3B"],
[":", "%3A"],
["@", "%40"],
["&", "%26"],
["=", "%3D"],
["+", "%2B"],
["$", "%24"],
[",", "%2C"]
])).values()
);
function decodePathSegment(part, decodeIgnore = DECODE_IGNORE_LIST, startIndex = 0) {
function decode2(part2) {
try {
return decodeURIComponent(part2);
} catch {
return part2.replaceAll(/%[0-9A-Fa-f]{2}/g, (match) => {
try {
return decodeURIComponent(match);
} catch {
return match;
}
});
}
}
if (part === "" || !part.match(/%[0-9A-Fa-f]{2}/g)) return part;
for (let i = startIndex; i < decodeIgnore.length; i++) {
const char = decodeIgnore[i];
if (char && part.includes(char)) {
const partsToDecode = part.split(char);
const partsToJoin = [];
for (const partToDecode of partsToDecode) {
partsToJoin.push(decodePathSegment(partToDecode, decodeIgnore, i + 1));
}
return partsToJoin.join(char);
}
}
return decode2(part);
}
// node_modules/tiny-invariant/dist/esm/tiny-invariant.js
var isProduction = false;
var prefix = "Invariant failed";
function invariant(condition, message) {
if (condition) {
return;
}
if (isProduction) {
throw new Error(prefix);
}
var provided = typeof message === "function" ? message() : message;
var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
throw new Error(value);
}
// node_modules/@tanstack/router-core/dist/esm/path.js
var SEGMENT_TYPE_PATHNAME = 0;
var SEGMENT_TYPE_PARAM = 1;
var SEGMENT_TYPE_WILDCARD = 2;
var SEGMENT_TYPE_OPTIONAL_PARAM = 3;
function joinPaths(paths) {
return cleanPath(
paths.filter((val) => {
return val !== void 0;
}).join("/")
);
}
function cleanPath(path) {
return path.replace(/\/{2,}/g, "/");
}
function trimPathLeft(path) {
return path === "/" ? path : path.replace(/^\/{1,}/, "");
}
function trimPathRight(path) {
return path === "/" ? path : path.replace(/\/{1,}$/, "");
}
function trimPath(path) {
return trimPathRight(trimPathLeft(path));
}
function removeTrailingSlash(value, basepath) {
if (value?.endsWith("/") && value !== "/" && value !== `${basepath}/`) {
return value.slice(0, -1);
}
return value;
}
function exactPathTest(pathName1, pathName2, basepath) {
return removeTrailingSlash(pathName1, basepath) === removeTrailingSlash(pathName2, basepath);
}
function segmentToString(segment) {
const { type, value } = segment;
if (type === SEGMENT_TYPE_PATHNAME) {
return value;
}
const { prefixSegment, suffixSegment } = segment;
if (type === SEGMENT_TYPE_PARAM) {
const param = value.substring(1);
if (prefixSegment && suffixSegment) {
return `${prefixSegment}{$${param}}${suffixSegment}`;
} else if (prefixSegment) {
return `${prefixSegment}{$${param}}`;
} else if (suffixSegment) {
return `{$${param}}${suffixSegment}`;
}
}
if (type === SEGMENT_TYPE_OPTIONAL_PARAM) {
const param = value.substring(1);
if (prefixSegment && suffixSegment) {
return `${prefixSegment}{-$${param}}${suffixSegment}`;
} else if (prefixSegment) {
return `${prefixSegment}{-$${param}}`;
} else if (suffixSegment) {
return `{-$${param}}${suffixSegment}`;
}
return `{-$${param}}`;
}
if (type === SEGMENT_TYPE_WILDCARD) {
if (prefixSegment && suffixSegment) {
return `${prefixSegment}{$}${suffixSegment}`;
} else if (prefixSegment) {
return `${prefixSegment}{$}`;
} else if (suffixSegment) {
return `{$}${suffixSegment}`;
}
}
return value;
}
function resolvePath({
base,
to,
trailingSlash = "never",
parseCache
}) {
let baseSegments = parsePathname(base, parseCache).slice();
const toSegments = parsePathname(to, parseCache);
if (baseSegments.length > 1 && last(baseSegments)?.value === "/") {
baseSegments.pop();
}
for (let index = 0, length = toSegments.length; index < length; index++) {
const toSegment = toSegments[index];
const value = toSegment.value;
if (value === "/") {
if (!index) {
baseSegments = [toSegment];
} else if (index === length - 1) {
baseSegments.push(toSegment);
} else ;
} else if (value === "..") {
baseSegments.pop();
} else if (value === ".") ;
else {
baseSegments.push(toSegment);
}
}
if (baseSegments.length > 1) {
if (last(baseSegments).value === "/") {
if (trailingSlash === "never") {
baseSegments.pop();
}
} else if (trailingSlash === "always") {
baseSegments.push({ type: SEGMENT_TYPE_PATHNAME, value: "/" });
}
}
const segmentValues = baseSegments.map(segmentToString);
const joined = joinPaths(segmentValues);
return joined;
}
var parsePathname = (pathname, cache) => {
if (!pathname) return [];
const cached = cache?.get(pathname);
if (cached) return cached;
const parsed = baseParsePathname(pathname);
cache?.set(pathname, parsed);
return parsed;
};
var PARAM_RE = /^\$.{1,}$/;
var PARAM_W_CURLY_BRACES_RE = /^(.*?)\{(\$[a-zA-Z_$][a-zA-Z0-9_$]*)\}(.*)$/;
var OPTIONAL_PARAM_W_CURLY_BRACES_RE = /^(.*?)\{-(\$[a-zA-Z_$][a-zA-Z0-9_$]*)\}(.*)$/;
var WILDCARD_RE = /^\$$/;
var WILDCARD_W_CURLY_BRACES_RE = /^(.*?)\{\$\}(.*)$/;
function baseParsePathname(pathname) {
pathname = cleanPath(pathname);
const segments = [];
if (pathname.slice(0, 1) === "/") {
pathname = pathname.substring(1);
segments.push({
type: SEGMENT_TYPE_PATHNAME,
value: "/"
});
}
if (!pathname) {
return segments;
}
const split = pathname.split("/").filter(Boolean);
segments.push(
...split.map((part) => {
const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE);
if (wildcardBracesMatch) {
const prefix2 = wildcardBracesMatch[1];
const suffix = wildcardBracesMatch[2];
return {
type: SEGMENT_TYPE_WILDCARD,
value: "$",
prefixSegment: prefix2 || void 0,
suffixSegment: suffix || void 0
};
}
const optionalParamBracesMatch = part.match(
OPTIONAL_PARAM_W_CURLY_BRACES_RE
);
if (optionalParamBracesMatch) {
const prefix2 = optionalParamBracesMatch[1];
const paramName = optionalParamBracesMatch[2];
const suffix = optionalParamBracesMatch[3];
return {
type: SEGMENT_TYPE_OPTIONAL_PARAM,
value: paramName,
// Now just $paramName (no prefix)
prefixSegment: prefix2 || void 0,
suffixSegment: suffix || void 0
};
}
const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE);
if (paramBracesMatch) {
const prefix2 = paramBracesMatch[1];
const paramName = paramBracesMatch[2];
const suffix = paramBracesMatch[3];
return {
type: SEGMENT_TYPE_PARAM,
value: "" + paramName,
prefixSegment: prefix2 || void 0,
suffixSegment: suffix || void 0
};
}
if (PARAM_RE.test(part)) {
const paramName = part.substring(1);
return {
type: SEGMENT_TYPE_PARAM,
value: "$" + paramName,
prefixSegment: void 0,
suffixSegment: void 0
};
}
if (WILDCARD_RE.test(part)) {
return {
type: SEGMENT_TYPE_WILDCARD,
value: "$",
prefixSegment: void 0,
suffixSegment: void 0
};
}
return {
type: SEGMENT_TYPE_PATHNAME,
value: decodePathSegment(part)
};
})
);
if (pathname.slice(-1) === "/") {
pathname = pathname.substring(1);
segments.push({
type: SEGMENT_TYPE_PATHNAME,
value: "/"
});
}
return segments;
}
function interpolatePath({
path,
params,
leaveWildcards,
leaveParams,
decodeCharMap,
parseCache
}) {
const interpolatedPathSegments = parsePathname(path, parseCache);
function encodeParam(key) {
const value = params[key];
const isValueString = typeof value === "string";
if (key === "*" || key === "_splat") {
return isValueString ? encodeURI(value) : value;
} else {
return isValueString ? encodePathParam(value, decodeCharMap) : value;
}
}
let isMissingParams = false;
const usedParams = {};
const interpolatedPath = joinPaths(
interpolatedPathSegments.map((segment) => {
if (segment.type === SEGMENT_TYPE_PATHNAME) {
return segment.value;
}
if (segment.type === SEGMENT_TYPE_WILDCARD) {
usedParams._splat = params._splat;
usedParams["*"] = params._splat;
const segmentPrefix = segment.prefixSegment || "";
const segmentSuffix = segment.suffixSegment || "";
if (!params._splat) {
isMissingParams = true;
if (leaveWildcards) {
return `${segmentPrefix}${segment.value}${segmentSuffix}`;
}
if (segmentPrefix || segmentSuffix) {
return `${segmentPrefix}${segmentSuffix}`;
}
return void 0;
}
const value = encodeParam("_splat");
if (leaveWildcards) {
return `${segmentPrefix}${segment.value}${value ?? ""}${segmentSuffix}`;
}
return `${segmentPrefix}${value}${segmentSuffix}`;
}
if (segment.type === SEGMENT_TYPE_PARAM) {
const key = segment.value.substring(1);
if (!isMissingParams && !(key in params)) {
isMissingParams = true;
}
usedParams[key] = params[key];
const segmentPrefix = segment.prefixSegment || "";
const segmentSuffix = segment.suffixSegment || "";
if (leaveParams) {
const value = encodeParam(segment.value);
return `${segmentPrefix}${segment.value}${value ?? ""}${segmentSuffix}`;
}
return `${segmentPrefix}${encodeParam(key) ?? "undefined"}${segmentSuffix}`;
}
if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
const key = segment.value.substring(1);
const segmentPrefix = segment.prefixSegment || "";
const segmentSuffix = segment.suffixSegment || "";
if (!(key in params) || params[key] == null) {
if (leaveWildcards) {
return `${segmentPrefix}${key}${segmentSuffix}`;
}
if (segmentPrefix || segmentSuffix) {
return `${segmentPrefix}${segmentSuffix}`;
}
return void 0;
}
usedParams[key] = params[key];
if (leaveParams) {
const value = encodeParam(segment.value);
return `${segmentPrefix}${segment.value}${value ?? ""}${segmentSuffix}`;
}
if (leaveWildcards) {
return `${segmentPrefix}${key}${encodeParam(key) ?? ""}${segmentSuffix}`;
}
return `${segmentPrefix}${encodeParam(key) ?? ""}${segmentSuffix}`;
}
return segment.value;
})
);
return { usedParams, interpolatedPath, isMissingParams };
}
function encodePathParam(value, decodeCharMap) {
let encoded = encodeURIComponent(value);
if (decodeCharMap) {
for (const [encodedChar, char] of decodeCharMap) {
encoded = encoded.replaceAll(encodedChar, char);
}
}
return encoded;
}
function matchPathname(currentPathname, matchLocation, parseCache) {
const pathParams = matchByPath(currentPathname, matchLocation, parseCache);
if (matchLocation.to && !pathParams) {
return;
}
return pathParams ?? {};
}
function matchByPath(from, {
to,
fuzzy,
caseSensitive
}, parseCache) {
const stringTo = to;
const baseSegments = parsePathname(
from.startsWith("/") ? from : `/${from}`,
parseCache
);
const routeSegments = parsePathname(
stringTo.startsWith("/") ? stringTo : `/${stringTo}`,
parseCache
);
const params = {};
const result = isMatch(
baseSegments,
routeSegments,
params,
fuzzy,
caseSensitive
);
return result ? params : void 0;
}
function isMatch(baseSegments, routeSegments, params, fuzzy, caseSensitive) {
let baseIndex = 0;
let routeIndex = 0;
while (baseIndex < baseSegments.length || routeIndex < routeSegments.length) {
const baseSegment = baseSegments[baseIndex];
const routeSegment = routeSegments[routeIndex];
if (routeSegment) {
if (routeSegment.type === SEGMENT_TYPE_WILDCARD) {
const remainingBaseSegments = baseSegments.slice(baseIndex);
let _splat;
if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
if (!baseSegment) return false;
const prefix2 = routeSegment.prefixSegment || "";
const suffix = routeSegment.suffixSegment || "";
const baseValue = baseSegment.value;
if ("prefixSegment" in routeSegment) {
if (!baseValue.startsWith(prefix2)) {
return false;
}
}
if ("suffixSegment" in routeSegment) {
if (!baseSegments[baseSegments.length - 1]?.value.endsWith(suffix)) {
return false;
}
}
let rejoinedSplat = decodeURI(
joinPaths(remainingBaseSegments.map((d) => d.value))
);
if (prefix2 && rejoinedSplat.startsWith(prefix2)) {
rejoinedSplat = rejoinedSplat.slice(prefix2.length);
}
if (suffix && rejoinedSplat.endsWith(suffix)) {
rejoinedSplat = rejoinedSplat.slice(
0,
rejoinedSplat.length - suffix.length
);
}
_splat = rejoinedSplat;
} else {
_splat = decodeURI(
joinPaths(remainingBaseSegments.map((d) => d.value))
);
}
params["*"] = _splat;
params["_splat"] = _splat;
return true;
}
if (routeSegment.type === SEGMENT_TYPE_PATHNAME) {
if (routeSegment.value === "/" && !baseSegment?.value) {
routeIndex++;
continue;
}
if (baseSegment) {
if (caseSensitive) {
if (routeSegment.value !== baseSegment.value) {
return false;
}
} else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
return false;
}
baseIndex++;
routeIndex++;
continue;
} else {
return false;
}
}
if (routeSegment.type === SEGMENT_TYPE_PARAM) {
if (!baseSegment) {
return false;
}
if (baseSegment.value === "/") {
return false;
}
let _paramValue = "";
let matched = false;
if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
const prefix2 = routeSegment.prefixSegment || "";
const suffix = routeSegment.suffixSegment || "";
const baseValue = baseSegment.value;
if (prefix2 && !baseValue.startsWith(prefix2)) {
return false;
}
if (suffix && !baseValue.endsWith(suffix)) {
return false;
}
let paramValue = baseValue;
if (prefix2 && paramValue.startsWith(prefix2)) {
paramValue = paramValue.slice(prefix2.length);
}
if (suffix && paramValue.endsWith(suffix)) {
paramValue = paramValue.slice(0, paramValue.length - suffix.length);
}
_paramValue = decodeURIComponent(paramValue);
matched = true;
} else {
_paramValue = decodeURIComponent(baseSegment.value);
matched = true;
}
if (matched) {
params[routeSegment.value.substring(1)] = _paramValue;
baseIndex++;
}
routeIndex++;
continue;
}
if (routeSegment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
if (!baseSegment) {
routeIndex++;
continue;
}
if (baseSegment.value === "/") {
routeIndex++;
continue;
}
let _paramValue = "";
let matched = false;
if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
const prefix2 = routeSegment.prefixSegment || "";
const suffix = routeSegment.suffixSegment || "";
const baseValue = baseSegment.value;
if ((!prefix2 || baseValue.startsWith(prefix2)) && (!suffix || baseValue.endsWith(suffix))) {
let paramValue = baseValue;
if (prefix2 && paramValue.startsWith(prefix2)) {
paramValue = paramValue.slice(prefix2.length);
}
if (suffix && paramValue.endsWith(suffix)) {
paramValue = paramValue.slice(
0,
paramValue.length - suffix.length
);
}
_paramValue = decodeURIComponent(paramValue);
matched = true;
}
} else {
let shouldMatchOptional = true;
for (let lookAhead = routeIndex + 1; lookAhead < routeSegments.length; lookAhead++) {
const futureRouteSegment = routeSegments[lookAhead];
if (futureRouteSegment?.type === SEGMENT_TYPE_PATHNAME && futureRouteSegment.value === baseSegment.value) {
shouldMatchOptional = false;
break;
}
if (futureRouteSegment?.type === SEGMENT_TYPE_PARAM || futureRouteSegment?.type === SEGMENT_TYPE_WILDCARD) {
if (baseSegments.length < routeSegments.length) {
shouldMatchOptional = false;
}
break;
}
}
if (shouldMatchOptional) {
_paramValue = decodeURIComponent(baseSegment.value);
matched = true;
}
}
if (matched) {
params[routeSegment.value.substring(1)] = _paramValue;
baseIndex++;
}
routeIndex++;
continue;
}
}
if (baseIndex < baseSegments.length && routeIndex >= routeSegments.length) {
params["**"] = joinPaths(
baseSegments.slice(baseIndex).map((d) => d.value)
);
return !!fuzzy && routeSegments[routeSegments.length - 1]?.value !== "/";
}
if (routeIndex < routeSegments.length && baseIndex >= baseSegments.length) {
for (let i = routeIndex; i < routeSegments.length; i++) {
if (routeSegments[i]?.type !== SEGMENT_TYPE_OPTIONAL_PARAM) {
return false;
}
}
break;
}
break;
}
return true;
}
// node_modules/@tanstack/router-core/dist/esm/process-route-tree.js
var SLASH_SCORE = 0.75;
var STATIC_SEGMENT_SCORE = 1;
var REQUIRED_PARAM_BASE_SCORE = 0.5;
var OPTIONAL_PARAM_BASE_SCORE = 0.4;
var WILDCARD_PARAM_BASE_SCORE = 0.25;
var STATIC_AFTER_DYNAMIC_BONUS_SCORE = 0.2;
var BOTH_PRESENCE_BASE_SCORE = 0.05;
var PREFIX_PRESENCE_BASE_SCORE = 0.02;
var SUFFIX_PRESENCE_BASE_SCORE = 0.01;
var PREFIX_LENGTH_SCORE_MULTIPLIER = 2e-4;
var SUFFIX_LENGTH_SCORE_MULTIPLIER = 1e-4;
function handleParam(segment, baseScore) {
if (segment.prefixSegment && segment.suffixSegment) {
return baseScore + BOTH_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
}
if (segment.prefixSegment) {
return baseScore + PREFIX_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length;
}
if (segment.suffixSegment) {
return baseScore + SUFFIX_PRESENCE_BASE_SCORE + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
}
return baseScore;
}
function sortRoutes(routes) {
const scoredRoutes = [];
routes.forEach((d, i) => {
if (d.isRoot || !d.path) {
return;
}
const trimmed = trimPathLeft(d.fullPath);
let parsed = parsePathname(trimmed);
let skip = 0;
while (parsed.length > skip + 1 && parsed[skip]?.value === "/") {
skip++;
}
if (skip > 0) parsed = parsed.slice(skip);
let optionalParamCount = 0;
let hasStaticAfter = false;
const scores = parsed.map((segment, index) => {
if (segment.value === "/") {
return SLASH_SCORE;
}
if (segment.type === SEGMENT_TYPE_PATHNAME) {
return STATIC_SEGMENT_SCORE;
}
let baseScore = void 0;
if (segment.type === SEGMENT_TYPE_PARAM) {
baseScore = REQUIRED_PARAM_BASE_SCORE;
} else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
baseScore = OPTIONAL_PARAM_BASE_SCORE;
optionalParamCount++;
} else {
baseScore = WILDCARD_PARAM_BASE_SCORE;
}
for (let i2 = index + 1; i2 < parsed.length; i2++) {
const nextSegment = parsed[i2];
if (nextSegment.type === SEGMENT_TYPE_PATHNAME && nextSegment.value !== "/") {
hasStaticAfter = true;
return handleParam(
segment,
baseScore + STATIC_AFTER_DYNAMIC_BONUS_SCORE
);
}
}
return handleParam(segment, baseScore);
});
scoredRoutes.push({
child: d,
trimmed,
parsed,
index: i,
scores,
optionalParamCount,
hasStaticAfter
});
});
const flatRoutes = scoredRoutes.sort((a, b) => {
const minLength = Math.min(a.scores.length, b.scores.length);
for (let i = 0; i < minLength; i++) {
if (a.scores[i] !== b.scores[i]) {
return b.scores[i] - a.scores[i];
}
}
if (a.scores.length !== b.scores.length) {
if (a.optionalParamCount !== b.optionalParamCount) {
if (a.hasStaticAfter === b.hasStaticAfter) {
return a.optionalParamCount - b.optionalParamCount;
} else if (a.hasStaticAfter && !b.hasStaticAfter) {
return -1;
} else if (!a.hasStaticAfter && b.hasStaticAfter) {
return 1;
}
}
return b.scores.length - a.scores.length;
}
for (let i = 0; i < minLength; i++) {
if (a.parsed[i].value !== b.parsed[i].value) {
return a.parsed[i].value > b.parsed[i].value ? 1 : -1;
}
}
return a.index - b.index;
}).map((d, i) => {
d.child.rank = i;
return d.child;
});
return flatRoutes;
}
function processRouteTree({
routeTree,
initRoute
}) {
const routesById = {};
const routesByPath = {};
const recurseRoutes = (childRoutes) => {
childRoutes.forEach((childRoute, i) => {
initRoute?.(childRoute, i);
const existingRoute = routesById[childRoute.id];
invariant(
!existingRoute,
`Duplicate routes found with id: ${String(childRoute.id)}`
);
routesById[childRoute.id] = childRoute;
if (!childRoute.isRoot && childRoute.path) {
const trimmedFullPath = trimPathRight(childRoute.fullPath);
if (!routesByPath[trimmedFullPath] || childRoute.fullPath.endsWith("/")) {
routesByPath[trimmedFullPath] = childRoute;
}
}
const children = childRoute.children;
if (children?.length) {
recurseRoutes(children);
}
});
};
recurseRoutes([routeTree]);
const flatRoutes = sortRoutes(Object.values(routesById));
return { routesById, routesByPath, flatRoutes };
}
// node_modules/@tanstack/router-core/dist/esm/not-found.js
function isNotFound(obj) {
return !!obj?.isNotFound;
}
// node_modules/@tanstack/router-core/dist/esm/scroll-restoration.js
function getSafeSessionStorage() {
try {
if (typeof window !== "undefined" && typeof window.sessionStorage === "object") {
return window.sessionStorage;
}
} catch {
}
return void 0;
}
var storageKey = "tsr-scroll-restoration-v1_3";
var throttle = (fn, wait) => {
let timeout;
return (...args) => {
if (!timeout) {
timeout = setTimeout(() => {
fn(...args);
timeout = null;
}, wait);
}
};
};
function createScrollRestorationCache() {
const safeSessionStorage = getSafeSessionStorage();
if (!safeSessionStorage) {
return null;
}
const persistedState = safeSessionStorage.getItem(storageKey);
let state = persistedState ? JSON.parse(persistedState) : {};
return {
state,
// This setter is simply to make sure that we set the sessionStorage right
// after the state is updated. It doesn't necessarily need to be a functional
// update.
set: (updater) => (state = functionalUpdate(updater, state) || state, safeSessionStorage.setItem(storageKey, JSON.stringify(state)))
};
}
var scrollRestorationCache = createScrollRestorationCache();
var defaultGetScrollRestorationKey = (location) => {
return location.state.__TSR_key || location.href;
};
function getCssSelector(el) {
const path = [];
let parent;
while (parent = el.parentNode) {
path.push(
`${el.tagName}:nth-child(${Array.prototype.indexOf.call(parent.children, el) + 1})`
);
el = parent;
}
return `${path.reverse().join(" > ")}`.toLowerCase();
}
var ignoreScroll = false;
function restoreScroll({
storageKey: storageKey2,
key,
behavior,
shouldScrollRestoration,
scrollToTopSelectors,
location
}) {
let byKey;
try {
byKey = JSON.parse(sessionStorage.getItem(storageKey2) || "{}");
} catch (error) {
console.error(error);
return;
}
const resolvedKey = key || window.history.state?.__TSR_key;
const elementEntries = byKey[resolvedKey];
ignoreScroll = true;
scroll: {
if (shouldScrollRestoration && elementEntries && Object.keys(elementEntries).length > 0) {
for (const elementSelector in elementEntries) {
const entry = elementEntries[elementSelector];
if (elementSelector === "window") {
window.scrollTo({
top: entry.scrollY,
left: entry.scrollX,
behavior
});
} else if (elementSelector) {
const element = document.querySelector(elementSelector);
if (element) {
element.scrollLeft = entry.scrollX;
element.scrollTop = entry.scrollY;
}
}
}
break scroll;
}
const hash = (location ?? window.location).hash.split("#", 2)[1];
if (hash) {
const hashScrollIntoViewOptions = window.history.state?.__hashScrollIntoViewOptions ?? true;
if (hashScrollIntoViewOptions) {
const el = document.getElementById(hash);
if (el) {
el.scrollIntoView(hashScrollIntoViewOptions);
}
}
break scroll;
}
const scrollOptions = { top: 0, left: 0, behavior };
window.scrollTo(scrollOptions);
if (scrollToTopSelectors) {
for (const selector of scrollToTopSelectors) {
if (selector === "window") continue;
const element = typeof selector === "function" ? selector() : document.querySelector(selector);
if (element) element.scrollTo(scrollOptions);
}
}
}
ignoreScroll = false;
}
function setupScrollRestoration(router, force) {
if (!scrollRestorationCache && !router.isServer) {
return;
}
const shouldScrollRestoration = force ?? router.options.scrollRestoration ?? false;
if (shouldScrollRestoration) {
router.isScrollRestoring = true;
}
if (router.isServer || router.isScrollRestorationSetup || !scrollRestorationCache) {
return;
}
router.isScrollRestorationSetup = true;
ignoreScroll = false;
const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
window.history.scrollRestoration = "manual";
const onScroll = (event) => {
if (ignoreScroll || !router.isScrollRestoring) {
return;
}
let elementSelector = "";
if (event.target === document || event.target === window) {
elementSelector = "window";
} else {
const attrId = event.target.getAttribute(
"data-scroll-restoration-id"
);
if (attrId) {
elementSelector = `[data-scroll-restoration-id="${attrId}"]`;
} else {
elementSelector = getCssSelector(event.target);
}
}
const restoreKey = getKey(router.state.location);
scrollRestorationCache.set((state) => {
const keyEntry = state[restoreKey] ||= {};
const elementEntry = keyEntry[elementSelector] ||= {};
if (elementSelector === "window") {
elementEntry.scrollX = window.scrollX || 0;
elementEntry.scrollY = window.scrollY || 0;
} else if (elementSelector) {
const element = document.querySelector(elementSelector);
if (element) {
elementEntry.scrollX = element.scrollLeft || 0;
elementEntry.scrollY = element.scrollTop || 0;
}
}
return state;
});
};
if (typeof document !== "undefined") {
document.addEventListener("scroll", throttle(onScroll, 100), true);
}
router.subscribe("onRendered", (event) => {
const cacheKey = getKey(event.toLocation);
if (!router.resetNextScroll) {
router.resetNextScroll = true;
return;
}
if (typeof router.options.scrollRestoration === "function") {
const shouldRestore = router.options.scrollRestoration({
location: router.latestLocation
});
if (!shouldRestore) {
return;
}
}
restoreScroll({
storageKey,
key: cacheKey,
behavior: router.options.scrollRestorationBehavior,
shouldScrollRestoration: router.isScrollRestoring,
scrollToTopSelectors: router.options.scrollToTopSelectors,
location: router.history.location
});
if (router.isScrollRestoring) {
scrollRestorationCache.set((state) => {
state[cacheKey] ||= {};
return state;
});
}
});
}
function handleHashScroll(router) {
if (typeof document !== "undefined" && document.querySelector) {
const hashScrollIntoViewOptions = router.state.location.state.__hashScrollIntoViewOptions ?? true;
if (hashScrollIntoViewOptions && router.state.location.hash !== "") {
const el = document.getElementById(router.state.location.hash);
if (el) {
el.scrollIntoView(hashScrollIntoViewOptions);
}
}
}
}
// node_modules/@tanstack/router-core/dist/esm/qss.js
function encode(obj, stringify = String) {
const result = new URLSearchParams();
for (const key in obj) {
const val = obj[key];
if (val !== void 0) {
result.set(key, stringify(val));
}
}
return result.toString();
}
function toValue(str) {
if (!str) return "";
if (str === "false") return false;
if (str === "true") return true;
return +str * 0 === 0 && +str + "" === str ? +str : str;
}
function decode(str) {
const searchParams = new URLSearchParams(str);
const result = {};
for (const [key, value] of searchParams.entries()) {
const previousValue = result[key];
if (previousValue == null) {
result[key] = toValue(value);
} else if (Array.isArray(previousValue)) {
previousValue.push(toValue(value));
} else {
result[key] = [previousValue, toValue(value)];
}
}
return result;
}
// node_modules/@tanstack/router-core/dist/esm/searchParams.js
var defaultParseSearch = parseSearchWith(JSON.parse);
var defaultStringifySearch = stringifySearchWith(
JSON.stringify,
JSON.parse
);
function parseSearchWith(parser) {
return (searchStr) => {
if (searchStr[0] === "?") {
searchStr = searchStr.substring(1);
}
const query = decode(searchStr);
for (const key in query) {
const value = query[key];
if (typeof value === "string") {
try {
query[key] = parser(value);
} catch (_err) {
}
}
}
return query;
};
}
function stringifySearchWith(stringify, parser) {
const hasParser = typeof parser === "function";
function stringifyValue(val) {
if (typeof val === "object" && val !== null) {
try {
return stringify(val);
} catch (_err) {
}
} else if (hasParser && typeof val === "string") {
try {
parser(val);
return stringify(val);
} catch (_err) {
}
}
return val;
}
return (search) => {
const searchStr = encode(search, stringifyValue);
return searchStr ? `?${searchStr}` : "";
};
}
// node_modules/@tanstack/router-core/dist/esm/root.js
var rootRouteId = "__root__";
// node_modules/@tanstack/router-core/dist/esm/redirect.js
function redirect(opts) {
opts.statusCode = opts.statusCode || opts.code || 307;
if (!opts.reloadDocument && typeof opts.href === "string") {
try {
new URL(opts.href);
opts.reloadDocument = true;
} catch {
}
}
const headers = new Headers(opts.headers);
if (opts.href && headers.get("Location") === null) {
headers.set("Location", opts.href);
}
const response = new Response(null, {
status: opts.statusCode,
headers
});
response.options = opts;
if (opts.throw) {
throw response;
}
return response;
}
function isRedirect(obj) {
return obj instanceof Response && !!obj.options;
}
// node_modules/@tanstack/router-core/dist/esm/lru-cache.js
function createLRUCache(max) {
const cache = /* @__PURE__ */ new Map();
let oldest;
let newest;
const touch = (entry) => {
if (!entry.next) return;
if (!entry.prev) {
entry.next.prev = void 0;
oldest = entry.next;
entry.next = void 0;
if (newest) {
entry.prev = newest;
newest.next = entry;
}
} else {
entry.prev.next = entry.next;
entry.next.prev = entry.prev;
entry.next = void 0;
if (newest) {
newest.next = entry;
entry.prev = newest;
}
}
newest = entry;
};
return {
get(key) {
const entry = cache.get(key);
if (!entry) return void 0;
touch(entry);
return entry.value;
},
set(key, value) {
if (cache.size >= max && oldest) {
const toDelete = oldest;
cache.delete(toDelete.key);
if (toDelete.next) {
oldest = toDelete.next;
toDelete.next.prev = void 0;
}
if (toDelete === newest) {
newest = void 0;
}
}
const existing = cache.get(key);
if (existing) {
existing.value = value;
touch(existing);
} else {
const entry = { key, value, prev: newest };
if (newest) newest.next = entry;
newest = entry;
if (!oldest) oldest = entry;
cache.set(key, entry);
}
}
};
}
// node_modules/@tanstack/router-core/dist/esm/load-matches.js
var triggerOnReady = (inner) => {
if (!inner.rendered) {
inner.rendered = true;
return inner.onReady?.();
}
};
var resolvePreload = (inner, matchId) => {
return !!(inner.preload && !inner.router.state.matches.some((d) => d.id === matchId));
};
var _handleNotFound = (inner, err) => {
const routeCursor = inner.router.routesById[err.routeId ?? ""] ?? inner.router.routeTree;
if (!routeCursor.options.notFoundComponent && inner.router.options?.defaultNotFoundComponent) {
routeCursor.options.notFoundComponent = inner.router.options.defaultNotFoundComponent;
}
invariant(
routeCursor.options.notFoundComponent,
"No notFoundComponent found. Please set a notFoundComponent on your route or provide a defaultNotFoundComponent to the router."
);
const matchForRoute = inner.matches.find((m) => m.routeId === routeCursor.id);
invariant(matchForRoute, "Could not find match for route: " + routeCursor.id);
inner.updateMatch(matchForRoute.id, (prev) => ({
...prev,
status: "notFound",
error: err,
isFetching: false
}));
if (err.routerCode === "BEFORE_LOAD" && routeCursor.parentRoute) {
err.routeId = routeCursor.parentRoute.id;
_handleNotFound(inner, err);
}
};
var handleRedirectAndNotFound = (inner, match, err) => {
if (!isRedirect(err) && !isNotFound(err)) return;
if (isRedirect(err) && err.redirectHandled && !err.options.reloadDocument) {
throw err;
}
if (match) {
match._nonReactive.beforeLoadPromise?.resolve();
match._nonReactive.loaderPromise?.resolve();
match._nonReactive.beforeLoadPromise = void 0;
match._nonReactive.loaderPromise = void 0;
const status = isRedirect(err) ? "redirected" : "notFound";
inner.updateMatch(match.id, (prev) => ({
...prev,
status,
isFetching: false,
error: err
}));
if (isNotFound(err) && !err.routeId) {
err.routeId = match.routeId;
}
match._nonReactive.loadPromise?.resolve();
}
if (isRedirect(err)) {
inner.rendered = true;
err.options._fromLocation = inner.location;
err.redirectHandled = true;
err = inner.router.resolveRedirect(err);
throw err;
} else {
_handleNotFound(inner, err);
throw err;
}
};
var shouldSkipLoader = (inner, matchId) => {
const match = inner.router.getMatch(matchId);
if (!inner.router.isServer && match._nonReactive.dehydrated) {
return true;
}
if (inner.router.isServer && match.ssr === false) {
return true;
}
return false;
};
var handleSerialError = (inner, index, err, routerCode) => {
const { id: matchId, routeId } = inner.matches[index];
const route = inner.router.looseRoutesById[routeId];
if (err instanceof Promise) {
throw err;
}
err.routerCode = routerCode;
inner.firstBadMatchIndex ??= index;
handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
try {
route.options.onError?.(err);
} catch (errorHandlerErr) {
err = errorHandlerErr;
handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
}
inner.updateMatch(matchId, (prev) => {
prev._nonReactive.beforeLoadPromise?.resolve();
prev._nonReactive.beforeLoadPromise = void 0;
prev._nonReactive.loadPromise?.resolve();
return {
...prev,
error: err,
status: "error",
isFetching: false,
updatedAt: Date.now(),
abortController: new AbortController()
};
});
};
var isBeforeLoadSsr = (inner, matchId, index, route) => {
const existingMatch = inner.router.getMatch(matchId);
const parentMatchId = inner.matches[index - 1]?.id;
const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0;
if (inner.router.isShell()) {
existingMatch.ssr = matchId === rootRouteId;
return;
}
if (parentMatch?.ssr === false) {
existingMatch.ssr = false;
return;
}
const parentOverride = (tempSsr2) => {
if (tempSsr2 === true && parentMatch?.ssr === "data-only") {
return "data-only";
}
return tempSsr2;
};
const defaultSsr = inner.router.options.defaultSsr ?? true;
if (route.options.ssr === void 0) {
existingMatch.ssr = parentOverride(defaultSsr);
return;
}
if (typeof route.options.ssr !== "function") {
existingMatch.ssr = parentOverride(route.options.ssr);
return;
}
const { search, params } = existingMatch;
const ssrFnContext = {
search: makeMaybe(search, existingMatch.searchError),
params: makeMaybe(params, existingMatch.paramsError),
location: inner.location,
matches: inner.matches.map((match) => ({
index: match.index,
pathname: match.pathname,
fullPath: match.fullPath,
staticData: match.staticData,
id: match.id,
routeId: match.routeId,
search: makeMaybe(match.search, match.searchError),
params: makeMaybe(match.params, match.paramsError),
ssr: match.ssr
}))
};
const tempSsr = route.options.ssr(ssrFnContext);
if (isPromise(tempSsr)) {
return tempSsr.then((ssr) => {
existingMatch.ssr = parentOverride(ssr ?? defaultSsr);
});
}
existingMatch.ssr = parentOverride(tempSsr ?? defaultSsr);
return;
};
var setupPendingTimeout = (inner, matchId, route, match) => {
if (match._nonReactive.pendingTimeout !== void 0) return;
const pendingMs = route.options.pendingMs ?? inner.router.options.defaultPendingMs;
const shouldPending = !!(inner.onReady && !inner.router.isServer && !resolvePreload(inner, matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? inner.router.options?.defaultPendingComponent));
if (shouldPending) {
const pendingTimeout = setTimeout(() => {
triggerOnReady(inner);
}, pendingMs);
match._nonReactive.pendingTimeout = pendingTimeout;
}
};
var preBeforeLoadSetup = (inner, matchId, route) => {
const existingMatch = inner.router.getMatch(matchId);
if (!existingMatch._nonReactive.beforeLoadPromise && !existingMatch._nonReactive.loaderPromise)
return;
setupPendingTimeout(inner, matchId, route, existingMatch);
const then = () => {
const match = inner.router.getMatch(matchId);
if (match.preload && (match.status === "redirected" || match.status === "notFound")) {
handleRedirectAndNotFound(inner, match, match.error);
}
};
return existingMatch._nonReactive.beforeLoadPromise ? existingMatch._nonReactive.beforeLoadPromise.then(then) : then();
};
var executeBeforeLoad = (inner, matchId, index, route) => {
const match = inner.router.getMatch(matchId);
const prevLoadPromise = match._nonReactive.loadPromise;
match._nonReactive.loadPromise = createControlledPromise(() => {
prevLoadPromise?.resolve();
});
const { paramsError, searchError } = match;
if (paramsError) {
handleSerialError(inner, index, paramsError, "PARSE_PARAMS");
}
if (searchError) {
handleSerialError(inner, index, searchError, "VALIDATE_SEARCH");
}
setupPendingTimeout(inner, matchId, route, match);
const abortController = new AbortController();
const parentMatchId = inner.matches[index - 1]?.id;
const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0;
const parentMatchContext = parentMatch?.context ?? inner.router.options.context ?? void 0;
const context = { ...parentMatchContext, ...match.__routeContext };
let isPending = false;
const pending = () => {
if (isPending) return;
isPending = true;
inner.updateMatch(matchId, (prev) => ({
...prev,
isFetching: "beforeLoad",
fetchCount: prev.fetchCount + 1,
abortController,
context
}));
};
const resolve = () => {
match._nonReactive.beforeLoadPromise?.resolve();
match._nonReactive.beforeLoadPromise = void 0;
inner.updateMatch(matchId, (prev) => ({
...prev,
isFetching: false
}));
};
if (!route.options.beforeLoad) {
batch(() => {
pending();
resolve();
});
return;
}
match._nonReactive.beforeLoadPromise = createControlledPromise();
const { search, params, cause } = match;
const preload = resolvePreload(inner, matchId);
const beforeLoadFnContext = {
search,
abortController,
params,
preload,
context,
location: inner.location,
navigate: (opts) => inner.router.navigate({
...opts,
_fromLocation: inner.location
}),
buildLocation: inner.router.buildLocation,
cause: preload ? "preload" : cause,
matches: inner.matches,
...inner.router.options.additionalContext
};
const updateContext = (beforeLoadContext2) => {
if (beforeLoadContext2 === void 0) {
batch(() => {
pending();
resolve();
});
return;
}
if (isRedirect(beforeLoadContext2) || isNotFound(beforeLoadContext2)) {
pending();
handleSerialError(inner, index, beforeLoadContext2, "BEFORE_LOAD");
}
batch(() => {
pending();
inner.updateMatch(matchId, (prev) => ({
...prev,
__beforeLoadContext: beforeLoadContext2,
context: {
...prev.context,
...beforeLoadContext2
}
}));
resolve();
});
};
let beforeLoadContext;
try {
beforeLoadContext = route.options.beforeLoad(beforeLoadFnContext);
if (isPromise(beforeLoadContext)) {
pending();
return beforeLoadContext.catch((err) => {
handleSerialError(inner, index, err, "BEFORE_LOAD");
}).then(updateContext);
}
} catch (err) {
pending();
handleSerialError(inner, index, err, "BEFORE_LOAD");
}
updateContext(beforeLoadContext);
return;
};
var handleBeforeLoad = (inner, index) => {
const { id: matchId, routeId } = inner.matches[index];
const route = inner.router.looseRoutesById[routeId];
const serverSsr = () => {
if (inner.router.isServer) {
const maybePromise = isBeforeLoadSsr(inner, matchId, index, route);
if (isPromise(maybePromise)) return maybePromise.then(queueExecution);
}
return queueExecution();
};
const execute = () => executeBeforeLoad(inner, matchId, index, route);
const queueExecution = () => {
if (shouldSkipLoader(inner, matchId)) return;
const result = preBeforeLoadSetup(inner, matchId, route);
return isPromise(result) ? result.then(execute) : execute();
};
return serverSsr();
};
var executeHead = (inner, matchId, route) => {
const match = inner.router.getMatch(matchId);
if (!match) {
return;
}
if (!route.options.head && !route.options.scripts && !route.options.headers) {
return;
}
const assetContext = {
matches: inner.matches,
match,
params: match.params,
loaderData: match.loaderData
};
return Promise.all([
route.options.head?.(assetContext),
route.options.scripts?.(assetContext),
route.options.headers?.(assetContext)
]).then(([headFnContent, scripts, headers]) => {
const meta = headFnContent?.meta;
const links = headFnContent?.links;
const headScripts = headFnContent?.scripts;
const styles = headFnContent?.styles;
return {
meta,
links,
headScripts,
headers,
scripts,
styles
};
});
};
var getLoaderContext = (inner, matchId, index, route) => {
const parentMatchPromise = inner.matchPromises[index - 1];
const { params, loaderDeps, abortController, context, cause } = inner.router.getMatch(matchId);
const preload = resolvePreload(inner, matchId);
return {
params,
deps: loaderDeps,
preload: !!preload,
parentMatchPromise,
abortController,
context,
location: inner.location,
navigate: (opts) => inner.router.navigate({
...opts,
_fromLocation: inner.location
}),
cause: preload ? "preload" : cause,
route,
...inner.router.options.additionalContext
};
};
var runLoader = async (inner, matchId, index, route) => {
try {
const match = inner.router.getMatch(matchId);
try {
if (!inner.router.isServer || match.ssr === true) {
loadRouteChunk(route);
}
const loaderResult = route.options.loader?.(
getLoaderContext(inner, matchId, index, route)
);
const loaderResultIsPromise = route.options.loader && isPromise(loaderResult);
const willLoadSomething = !!(loaderResultIsPromise || route._lazyPromise || route._componentsPromise || route.options.head || route.options.scripts || route.options.headers || match._nonReactive.minPendingPromise);
if (willLoadSomething) {
inner.updateMatch(matchId, (prev) => ({
...prev,
isFetching: "loader"
}));
}
if (route.options.loader) {
const loaderData = loaderResultIsPromise ? await loaderResult : loaderResult;
handleRedirectAndNotFound(
inner,
inner.router.getMatch(matchId),
loaderData
);
if (loaderData !== void 0) {
inner.updateMatch(matchId, (prev) => ({
...prev,
loaderData
}));
}
}
if (route._lazyPromise) await route._lazyPromise;
const headResult = executeHead(inner, matchId, route);
const head = headResult ? await headResult : void 0;
const pendingPromise = match._nonReactive.minPendingPromise;
if (pendingPromise) await pendingPromise;
if (route._componentsPromise) await route._componentsPromise;
inner.updateMatch(matchId, (prev) => ({
...prev,
error: void 0,
status: "success",
isFetching: false,
updatedAt: Date.now(),
...head
}));
} catch (e) {
let error = e;
const pendingPromise = match._nonReactive.minPendingPromise;
if (pendingPromise) await pendingPromise;
if (isNotFound(e)) {
await route.options.notFoundComponent?.preload?.();
}
handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), e);
try {
route.options.onError?.(e);
} catch (onErrorError) {
error = onErrorError;
handleRedirectAndNotFound(
inner,
inner.router.getMatch(matchId),
onErrorError
);
}
const headResult = executeHead(inner, matchId, route);
const head = headResult ? await headResult : void 0;
inner.updateMatch(matchId, (prev) => ({
...prev,
error,
status: "error",
isFetching: false,
...head
}));
}
} catch (err) {
const match = inner.router.getMatch(matchId);
if (match) {
const headResult = executeHead(inner, matchId, route);
if (headResult) {
const head = await headResult;
inner.updateMatch(matchId, (prev) => ({
...prev,
...head
}));
}
match._nonReactive.loaderPromise = void 0;
}
handleRedirectAndNotFound(inner, match, err);
}
};
var loadRouteMatch = async (inner, index) => {
const { id: matchId, routeId } = inner.matches[index];
let loaderShouldRunAsync = false;
let loaderIsRunningAsync = false;
const route = inner.router.looseRoutesById[routeId];
if (shouldSkipLoader(inner, matchId)) {
if (inner.router.isServer) {
const headResult = executeHead(inner, matchId, route);
if (headResult) {
const head = await headResult;
inner.updateMatch(matchId, (prev) => ({
...prev,
...head
}));
}
return inner.router.getMatch(matchId);
}
} else {
const prevMatch = inner.router.getMatch(matchId);
if (prevMatch._nonReactive.loaderPromise) {
if (prevMatch.status === "success" && !inner.sync && !prevMatch.preload) {
return prevMatch;
}
await prevMatch._nonReactive.loaderPromise;
const match2 = inner.router.getMatch(matchId);
if (match2.error) {
handleRedirectAndNotFound(inner, match2, match2.error);
}
} else {
const age = Date.now() - prevMatch.updatedAt;
const preload = resolvePreload(inner, matchId);
const staleAge = preload ? route.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0;
const shouldReloadOption = route.options.shouldReload;
const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext(inner, matchId, index, route)) : shouldReloadOption;
const nextPreload = !!preload && !inner.router.state.matches.some((d) => d.id === matchId);
const match2 = inner.router.getMatch(matchId);
match2._nonReactive.loaderPromise = createControlledPromise();
if (nextPreload !== match2.preload) {
inner.updateMatch(matchId, (prev) => ({
...prev,
preload: nextPreload
}));
}
const { status, invalid } = match2;
loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? age > staleAge));
if (preload && route.options.preload === false) ;
else if (loaderShouldRunAsync && !inner.sync) {
loaderIsRunningAsync = true;
(async () => {
try {
await runLoader(inner, matchId, index, route);
const match3 = inner.router.getMatch(matchId);
match3._nonReactive.loaderPromise?.resolve();
match3._nonReactive.loadPromise?.resolve();
match3._nonReactive.loaderPromise = void 0;
} catch (err) {
if (isRedirect(err)) {
await inner.router.navigate(err.options);
}
}
})();
} else if (status !== "success" || loaderShouldRunAsync && inner.sync) {
await runLoader(inner, matchId, index, route);
} else {
const headResult = executeHead(inner, matchId, route);
if (headResult) {
const head = await headResult;
inner.updateMatch(matchId, (prev) => ({
...prev,
...head
}));
}
}
}
}
const match = inner.router.getMatch(matchId);
if (!loaderIsRunningAsync) {
match._nonReactive.loaderPromise?.resolve();
match._nonReactive.loadPromise?.resolve();
}
clearTimeout(match._nonReactive.pendingTimeout);
match._nonReactive.pendingTimeout = void 0;
if (!loaderIsRunningAsync) match._nonReactive.loaderPromise = void 0;
match._nonReactive.dehydrated = void 0;
const nextIsFetching = loaderIsRunningAsync ? match.isFetching : false;
if (nextIsFetching !== match.isFetching || match.invalid !== false) {
inner.updateMatch(matchId, (prev) => ({
...prev,
isFetching: nextIsFetching,
invalid: false
}));
return inner.router.getMatch(matchId);
} else {
return match;
}
};
async function loadMatches(arg) {
const inner = Object.assign(arg, {
matchPromises: []
});
if (!inner.router.isServer && inner.router.state.matches.some((d) => d._forcePending)) {
triggerOnReady(inner);
}
try {
for (let i = 0; i < inner.matches.length; i++) {
const beforeLoad = handleBeforeLoad(inner, i);
if (isPromise(beforeLoad)) await beforeLoad;
}
const max = inner.firstBadMatchIndex ?? inner.matches.length;
for (let i = 0; i < max; i++) {
inner.matchPromises.push(loadRouteMatch(inner, i));
}
await Promise.all(inner.matchPromises);
const readyPromise = triggerOnReady(inner);
if (isPromise(readyPromise)) await readyPromise;
} catch (err) {
if (isNotFound(err) && !inner.preload) {
const readyPromise = triggerOnReady(inner);
if (isPromise(readyPromise)) await readyPromise;
throw err;
}
if (isRedirect(err)) {
throw err;
}
}
return inner.matches;
}
async function loadRouteChunk(route) {
if (!route._lazyLoaded && route._lazyPromise === void 0) {
if (route.lazyFn) {
route._lazyPromise = route.lazyFn().then((lazyRoute) => {
const { id: _id, ...options } = lazyRoute.options;
Object.assign(route.options, options);
route._lazyLoaded = true;
route._lazyPromise = void 0;
});
} else {
route._lazyLoaded = true;
}
}
if (!route._componentsLoaded && route._componentsPromise === void 0) {
const loadComponents = () => {
const preloads = [];
for (const type of componentTypes) {
const preload = route.options[type]?.preload;
if (preload) preloads.push(preload());
}
if (preloads.length)
return Promise.all(preloads).then(() => {
route._componentsLoaded = true;
route._componentsPromise = void 0;
});
route._componentsLoaded = true;
route._componentsPromise = void 0;
return;
};
route._componentsPromise = route._lazyPromise ? route._lazyPromise.then(loadComponents) : loadComponents();
}
return route._componentsPromise;
}
function makeMaybe(value, error) {
if (error) {
return { status: "error", error };
}
return { status: "success", value };
}
function routeNeedsPreload(route) {
for (const componentType of componentTypes) {
if (route.options[componentType]?.preload) {
return true;
}
}
return false;
}
var componentTypes = [
"component",
"errorComponent",
"pendingComponent",
"notFoundComponent"
];
// node_modules/@tanstack/router-core/dist/esm/rewrite.js
function composeRewrites(rewrites) {
return {
input: ({ url }) => {
for (const rewrite of rewrites) {
url = executeRewriteInput(rewrite, url);
}
return url;
},
output: ({ url }) => {
for (let i = rewrites.length - 1; i >= 0; i--) {
url = executeRewriteOutput(rewrites[i], url);
}
return url;
}
};
}
function rewriteBasepath(opts) {
const trimmedBasepath = trimPath(opts.basepath);
const normalizedBasepath = `/${trimmedBasepath}`;
const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
const checkBasepath = opts.caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
const checkBasepathWithSlash = opts.caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
return {
input: ({ url }) => {
const pathname = opts.caseSensitive ? url.pathname : url.pathname.toLowerCase();
if (pathname === checkBasepath) {
url.pathname = "/";
} else if (pathname.startsWith(checkBasepathWithSlash)) {
url.pathname = url.pathname.slice(normalizedBasepath.length);
}
return url;
},
output: ({ url }) => {
url.pathname = joinPaths(["/", trimmedBasepath, url.pathname]);
return url;
}
};
}
function executeRewriteInput(rewrite, url) {
const res = rewrite?.input?.({ url });
if (res) {
if (typeof res === "string") {
return new URL(res);
} else if (res instanceof URL) {
return res;
}
}
return url;
}
function executeRewriteOutput(rewrite, url) {
const res = rewrite?.output?.({ url });
if (res) {
if (typeof res === "string") {
return new URL(res);
} else if (res instanceof URL) {
return res;
}
}
return url;
}
// node_modules/@tanstack/router-core/dist/esm/router.js
function getLocationChangeInfo(routerState) {
const fromLocation = routerState.resolvedLocation;
const toLocation = routerState.location;
const pathChanged = fromLocation?.pathname !== toLocation.pathname;
const hrefChanged = fromLocation?.href !== toLocation.href;
const hashChanged = fromLocation?.hash !== toLocation.hash;
return { fromLocation, toLocation, pathChanged, hrefChanged, hashChanged };
}
var RouterCore = class {
/**
* @deprecated Use the `createRouter` function instead
*/
constructor(options) {
this.tempLocationKey = `${Math.round(
Math.random() * 1e7
)}`;
this.resetNextScroll = true;
this.shouldViewTransition = void 0;
this.isViewTransitionTypesSupported = void 0;
this.subscribers = /* @__PURE__ */ new Set();
this.isScrollRestoring = false;
this.isScrollRestorationSetup = false;
this.startTransition = (fn) => fn();
this.update = (newOptions) => {
if (newOptions.notFoundRoute) {
console.warn(
"The notFoundRoute API is deprecated and will be removed in the next major version. See https://tanstack.com/router/v1/docs/framework/react/guide/not-found-errors#migrating-from-notfoundroute for more info."
);
}
const prevOptions = this.options;
const prevBasepath = this.basepath ?? prevOptions?.basepath ?? "/";
const basepathWasUnset = this.basepath === void 0;
const prevRewriteOption = prevOptions?.rewrite;
this.options = {
...prevOptions,
...newOptions
};
this.isServer = this.options.isServer ?? typeof document === "undefined";
this.pathParamsDecodeCharMap = this.options.pathParamsAllowedCharacters ? new Map(
this.options.pathParamsAllowedCharacters.map((char) => [
encodeURIComponent(char),
char
])
) : void 0;
if (!this.history || this.options.history && this.options.history !== this.history) {
if (!this.options.history) {
if (!this.isServer) {
this.history = createBrowserHistory();
}
} else {
this.history = this.options.history;
}
}
this.origin = this.options.origin;
if (!this.origin) {
if (!this.isServer && window?.origin && window.origin !== "null") {
this.origin = window.origin;
} else {
this.origin = "http://localhost";
}
}
if (this.history) {
this.updateLatestLocation();
}
if (this.options.routeTree !== this.routeTree) {
this.routeTree = this.options.routeTree;
this.buildRouteTree();
}
if (!this.__store && this.latestLocation) {
this.__store = new Store(getInitialRouterState(this.latestLocation), {
onUpdate: () => {
this.__store.state = {
...this.state,
cachedMatches: this.state.cachedMatches.filter(
(d) => !["redirected"].includes(d.status)
)
};
}
});
setupScrollRestoration(this);
}
let needsLocationUpdate = false;
const nextBasepath = this.options.basepath ?? "/";
const nextRewriteOption = this.options.rewrite;
const basepathChanged = basepathWasUnset || prevBasepath !== nextBasepath;
const rewriteChanged = prevRewriteOption !== nextRewriteOption;
if (basepathChanged || rewriteChanged) {
this.basepath = nextBasepath;
const rewrites = [];
if (trimPath(nextBasepath) !== "") {
rewrites.push(
rewriteBasepath({
basepath: nextBasepath
})
);
}
if (nextRewriteOption) {
rewrites.push(nextRewriteOption);
}
this.rewrite = rewrites.length === 0 ? void 0 : rewrites.length === 1 ? rewrites[0] : composeRewrites(rewrites);
if (this.history) {
this.updateLatestLocation();
}
needsLocationUpdate = true;
}
if (needsLocationUpdate && this.__store) {
this.__store.state = {
...this.state,
location: this.latestLocation
};
}
if (typeof window !== "undefined" && "CSS" in window && typeof window.CSS?.supports === "function") {
this.isViewTransitionTypesSupported = window.CSS.supports(
"selector(:active-view-transition-type(a)"
);
}
};
this.updateLatestLocation = () => {
this.latestLocation = this.parseLocation(
this.history.location,
this.latestLocation
);
};
this.buildRouteTree = () => {
const { routesById, routesByPath, flatRoutes } = processRouteTree({
routeTree: this.routeTree,
initRoute: (route, i) => {
route.init({
originalIndex: i
});
}
});
this.routesById = routesById;
this.routesByPath = routesByPath;
this.flatRoutes = flatRoutes;
const notFoundRoute = this.options.notFoundRoute;
if (notFoundRoute) {
notFoundRoute.init({
originalIndex: 99999999999
});
this.routesById[notFoundRoute.id] = notFoundRoute;
}
};
this.subscribe = (eventType, fn) => {
const listener = {
eventType,
fn
};
this.subscribers.add(listener);
return () => {
this.subscribers.delete(listener);
};
};
this.emit = (routerEvent) => {
this.subscribers.forEach((listener) => {
if (listener.eventType === routerEvent.type) {
listener.fn(routerEvent);
}
});
};
this.parseLocation = (locationToParse, previousLocation) => {
const parse = ({
href,
state
}) => {
const fullUrl = new URL(href, this.origin);
const url = executeRewriteInput(this.rewrite, fullUrl);
const parsedSearch = this.options.parseSearch(url.search);
const searchStr = this.options.stringifySearch(parsedSearch);
url.search = searchStr;
const fullPath = url.href.replace(url.origin, "");
const { pathname, hash } = url;
return {
href: fullPath,
publicHref: href,
url: url.href,
pathname,
searchStr,
search: replaceEqualDeep(previousLocation?.search, parsedSearch),
hash: hash.split("#").reverse()[0] ?? "",
state: replaceEqualDeep(previousLocation?.state, state)
};
};
const location = parse(locationToParse);
const { __tempLocation, __tempKey } = location.state;
if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) {
const parsedTempLocation = parse(__tempLocation);
parsedTempLocation.state.key = location.state.key;
parsedTempLocation.state.__TSR_key = location.state.__TSR_key;
delete parsedTempLocation.state.__tempLocation;
return {
...parsedTempLocation,
maskedLocation: location
};
}
return location;
};
this.resolvePathWithBase = (from, path) => {
const resolvedPath = resolvePath({
base: from,
to: cleanPath(path),
trailingSlash: this.options.trailingSlash,
parseCache: this.parsePathnameCache
});
return resolvedPath;
};
this.matchRoutes = (pathnameOrNext, locationSearchOrOpts, opts) => {
if (typeof pathnameOrNext === "string") {
return this.matchRoutesInternal(
{
pathname: pathnameOrNext,
search: locationSearchOrOpts
},
opts
);
}
return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
};
this.parsePathnameCache = createLRUCache(1e3);
this.getMatchedRoutes = (pathname, routePathname) => {
return getMatchedRoutes({
pathname,
routePathname,
caseSensitive: this.options.caseSensitive,
routesByPath: this.routesByPath,
routesById: this.routesById,
flatRoutes: this.flatRoutes,
parseCache: this.parsePathnameCache
});
};
this.cancelMatch = (id) => {
const match = this.getMatch(id);
if (!match) return;
match.abortController.abort();
clearTimeout(match._nonReactive.pendingTimeout);
match._nonReactive.pendingTimeout = void 0;
};
this.cancelMatches = () => {
this.state.pendingMatches?.forEach((match) => {
this.cancelMatch(match.id);
});
};
this.buildLocation = (opts) => {
const build = (dest = {}) => {
const currentLocation = dest._fromLocation || this.latestLocation;
const allCurrentLocationMatches = this.matchRoutes(currentLocation, {
_buildLocation: true
});
const lastMatch = last(allCurrentLocationMatches);
if (dest.from && true && dest._isNavigate) {
const allFromMatches = this.getMatchedRoutes(
dest.from,
void 0
).matchedRoutes;
const matchedFrom = findLast(allCurrentLocationMatches, (d) => {
return comparePaths(d.fullPath, dest.from);
});
const matchedCurrent = findLast(allFromMatches, (d) => {
return comparePaths(d.fullPath, lastMatch.fullPath);
});
if (!matchedFrom && !matchedCurrent) {
console.warn(`Could not find match for from: ${dest.from}`);
}
}
const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lastMatch.fullPath;
const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
const fromSearch = lastMatch.search;
const fromParams = { ...lastMatch.params };
const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
const nextParams = dest.params === false || dest.params === null ? {} : (dest.params ?? true) === true ? fromParams : Object.assign(
fromParams,
functionalUpdate(dest.params, fromParams)
);
const interpolatedNextTo = interpolatePath({
path: nextTo,
params: nextParams,
parseCache: this.parsePathnameCache
}).interpolatedPath;
const destRoutes = this.matchRoutes(interpolatedNextTo, void 0, {
_buildLocation: true
}).map((d) => this.looseRoutesById[d.routeId]);
if (Object.keys(nextParams).length > 0) {
for (const route of destRoutes) {
const fn = route.options.params?.stringify ?? route.options.stringifyParams;
if (fn) {
Object.assign(nextParams, fn(nextParams));
}
}
}
const nextPathname = decodePathSegment(
interpolatePath({
// Use the original template path for interpolation
// This preserves the original parameter syntax including optional parameters
path: nextTo,
params: nextParams,
leaveWildcards: false,
leaveParams: opts.leaveParams,
decodeCharMap: this.pathParamsDecodeCharMap,
parseCache: this.parsePathnameCache
}).interpolatedPath
);
let nextSearch = fromSearch;
if (opts._includeValidateSearch && this.options.search?.strict) {
const validatedSearch = {};
destRoutes.forEach((route) => {
if (route.options.validateSearch) {
try {
Object.assign(
validatedSearch,
validateSearch(route.options.validateSearch, {
...validatedSearch,
...nextSearch
})
);
} catch {
}
}
});
nextSearch = validatedSearch;
}
nextSearch = applySearchMiddleware({
search: nextSearch,
dest,
destRoutes,
_includeValidateSearch: opts._includeValidateSearch
});
nextSearch = replaceEqualDeep(fromSearch, nextSearch);
const searchStr = this.options.stringifySearch(nextSearch);
const hash = dest.hash === true ? currentLocation.hash : dest.hash ? functionalUpdate(dest.hash, currentLocation.hash) : void 0;
const hashStr = hash ? `#${hash}` : "";
let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {};
nextState = replaceEqualDeep(currentLocation.state, nextState);
const fullPath = `${nextPathname}${searchStr}${hashStr}`;
const url = new URL(fullPath, this.origin);
const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
return {
publicHref: rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
href: fullPath,
url: rewrittenUrl.href,
pathname: nextPathname,
search: nextSearch,
searchStr,
state: nextState,
hash: hash ?? "",
unmaskOnReload: dest.unmaskOnReload
};
};
const buildWithMatches = (dest = {}, maskedDest) => {
const next = build(dest);
let maskedNext = maskedDest ? build(maskedDest) : void 0;
if (!maskedNext) {
let params = {};
const foundMask = this.options.routeMasks?.find((d) => {
const match = matchPathname(
next.pathname,
{
to: d.from,
caseSensitive: false,
fuzzy: false
},
this.parsePathnameCache
);
if (match) {
params = match;
return true;
}
return false;
});
if (foundMask) {
const { from: _from, ...maskProps } = foundMask;
maskedDest = {
from: opts.from,
...maskProps,
params
};
maskedNext = build(maskedDest);
}
}
if (maskedNext) {
next.maskedLocation = maskedNext;
}
return next;
};
if (opts.mask) {
return buildWithMatches(opts, {
from: opts.from,
...opts.mask
});
}
return buildWithMatches(opts);
};
this.commitLocation = ({
viewTransition,
ignoreBlocker,
...next
}) => {
const isSameState = () => {
const ignoredProps = [
"key",
// TODO: Remove in v2 - use __TSR_key instead
"__TSR_key",
"__TSR_index",
"__hashScrollIntoViewOptions"
];
ignoredProps.forEach((prop) => {
next.state[prop] = this.latestLocation.state[prop];
});
const isEqual = deepEqual(next.state, this.latestLocation.state);
ignoredProps.forEach((prop) => {
delete next.state[prop];
});
return isEqual;
};
const isSameUrl = trimPathRight(this.latestLocation.href) === trimPathRight(next.href);
const previousCommitPromise = this.commitLocationPromise;
this.commitLocationPromise = createControlledPromise(() => {
previousCommitPromise?.resolve();
});
if (isSameUrl && isSameState()) {
this.load();
} else {
let { maskedLocation, hashScrollIntoView, ...nextHistory } = next;
if (maskedLocation) {
nextHistory = {
...maskedLocation,
state: {
...maskedLocation.state,
__tempKey: void 0,
__tempLocation: {
...nextHistory,
search: nextHistory.searchStr,
state: {
...nextHistory.state,
__tempKey: void 0,
__tempLocation: void 0,
__TSR_key: void 0,
key: void 0
// TODO: Remove in v2 - use __TSR_key instead
}
}
}
};
if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) {
nextHistory.state.__tempKey = this.tempLocationKey;
}
}
nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
this.shouldViewTransition = viewTransition;
this.history[next.replace ? "replace" : "push"](
nextHistory.publicHref,
nextHistory.state,
{ ignoreBlocker }
);
}
this.resetNextScroll = next.resetScroll ?? true;
if (!this.history.subscribers.size) {
this.load();
}
return this.commitLocationPromise;
};
this.buildAndCommitLocation = ({
replace,
resetScroll,
hashScrollIntoView,
viewTransition,
ignoreBlocker,
href,
...rest
} = {}) => {
if (href) {
const currentIndex = this.history.location.state.__TSR_index;
const parsed = parseHref(href, {
__TSR_index: replace ? currentIndex : currentIndex + 1
});
rest.to = parsed.pathname;
rest.search = this.options.parseSearch(parsed.search);
rest.hash = parsed.hash.slice(1);
}
const location = this.buildLocation({
...rest,
_includeValidateSearch: true
});
return this.commitLocation({
...location,
viewTransition,
replace,
resetScroll,
hashScrollIntoView,
ignoreBlocker
});
};
this.navigate = ({ to, reloadDocument, href, ...rest }) => {
if (!reloadDocument && href) {
try {
new URL(`${href}`);
reloadDocument = true;
} catch {
}
}
if (reloadDocument) {
if (!href) {
const location = this.buildLocation({ to, ...rest });
href = location.url;
}
if (rest.replace) {
window.location.replace(href);
} else {
window.location.href = href;
}
return Promise.resolve();
}
return this.buildAndCommitLocation({
...rest,
href,
to,
_isNavigate: true
});
};
this.beforeLoad = () => {
this.cancelMatches();
this.updateLatestLocation();
if (this.isServer) {
const nextLocation = this.buildLocation({
to: this.latestLocation.pathname,
search: true,
params: true,
hash: true,
state: true,
_includeValidateSearch: true
});
const normalizeUrl = (url) => {
try {
return encodeURI(decodeURI(url));
} catch {
return url;
}
};
if (trimPath(normalizeUrl(this.latestLocation.href)) !== trimPath(normalizeUrl(nextLocation.href))) {
let href = nextLocation.url;
if (this.origin && href.startsWith(this.origin)) {
href = href.replace(this.origin, "") || "/";
}
throw redirect({ href });
}
}
const pendingMatches = this.matchRoutes(this.latestLocation);
this.__store.setState((s) => ({
...s,
status: "pending",
statusCode: 200,
isLoading: true,
location: this.latestLocation,
pendingMatches,
// If a cached moved to pendingMatches, remove it from cachedMatches
cachedMatches: s.cachedMatches.filter(
(d) => !pendingMatches.some((e) => e.id === d.id)
)
}));
};
this.load = async (opts) => {
let redirect2;
let notFound2;
let loadPromise;
loadPromise = new Promise((resolve) => {
this.startTransition(async () => {
try {
this.beforeLoad();
const next = this.latestLocation;
const prevLocation = this.state.resolvedLocation;
if (!this.state.redirect) {
this.emit({
type: "onBeforeNavigate",
...getLocationChangeInfo({
resolvedLocation: prevLocation,
location: next
})
});
}
this.emit({
type: "onBeforeLoad",
...getLocationChangeInfo({
resolvedLocation: prevLocation,
location: next
})
});
await loadMatches({
router: this,
sync: opts?.sync,
matches: this.state.pendingMatches,
location: next,
updateMatch: this.updateMatch,
// eslint-disable-next-line @typescript-eslint/require-await
onReady: async () => {
this.startViewTransition(async () => {
let exitingMatches;
let enteringMatches;
let stayingMatches;
batch(() => {
this.__store.setState((s) => {
const previousMatches = s.matches;
const newMatches = s.pendingMatches || s.matches;
exitingMatches = previousMatches.filter(
(match) => !newMatches.some((d) => d.id === match.id)
);
enteringMatches = newMatches.filter(
(match) => !previousMatches.some((d) => d.id === match.id)
);
stayingMatches = previousMatches.filter(
(match) => newMatches.some((d) => d.id === match.id)
);
return {
...s,
isLoading: false,
loadedAt: Date.now(),
matches: newMatches,
pendingMatches: void 0,
cachedMatches: [
...s.cachedMatches,
...exitingMatches.filter((d) => d.status !== "error")
]
};
});
this.clearExpiredCache();
});
[
[exitingMatches, "onLeave"],
[enteringMatches, "onEnter"],
[stayingMatches, "onStay"]
].forEach(([matches, hook]) => {
matches.forEach((match) => {
this.looseRoutesById[match.routeId].options[hook]?.(match);
});
});
});
}
});
} catch (err) {
if (isRedirect(err)) {
redirect2 = err;
if (!this.isServer) {
this.navigate({
...redirect2.options,
replace: true,
ignoreBlocker: true
});
}
} else if (isNotFound(err)) {
notFound2 = err;
}
this.__store.setState((s) => ({
...s,
statusCode: redirect2 ? redirect2.status : notFound2 ? 404 : s.matches.some((d) => d.status === "error") ? 500 : 200,
redirect: redirect2
}));
}
if (this.latestLoadPromise === loadPromise) {
this.commitLocationPromise?.resolve();
this.latestLoadPromise = void 0;
this.commitLocationPromise = void 0;
}
resolve();
});
});
this.latestLoadPromise = loadPromise;
await loadPromise;
while (this.latestLoadPromise && loadPromise !== this.latestLoadPromise) {
await this.latestLoadPromise;
}
let newStatusCode = void 0;
if (this.hasNotFoundMatch()) {
newStatusCode = 404;
} else if (this.__store.state.matches.some((d) => d.status === "error")) {
newStatusCode = 500;
}
if (newStatusCode !== void 0) {
this.__store.setState((s) => ({
...s,
statusCode: newStatusCode
}));
}
};
this.startViewTransition = (fn) => {
const shouldViewTransition = this.shouldViewTransition ?? this.options.defaultViewTransition;
delete this.shouldViewTransition;
if (shouldViewTransition && typeof document !== "undefined" && "startViewTransition" in document && typeof document.startViewTransition === "function") {
let startViewTransitionParams;
if (typeof shouldViewTransition === "object" && this.isViewTransitionTypesSupported) {
const next = this.latestLocation;
const prevLocation = this.state.resolvedLocation;
const resolvedViewTransitionTypes = typeof shouldViewTransition.types === "function" ? shouldViewTransition.types(
getLocationChangeInfo({
resolvedLocation: prevLocation,
location: next
})
) : shouldViewTransition.types;
if (resolvedViewTransitionTypes === false) {
fn();
return;
}
startViewTransitionParams = {
update: fn,
types: resolvedViewTransitionTypes
};
} else {
startViewTransitionParams = fn;
}
document.startViewTransition(startViewTransitionParams);
} else {
fn();
}
};
this.updateMatch = (id, updater) => {
const matchesKey = this.state.pendingMatches?.some((d) => d.id === id) ? "pendingMatches" : this.state.matches.some((d) => d.id === id) ? "matches" : this.state.cachedMatches.some((d) => d.id === id) ? "cachedMatches" : "";
if (matchesKey) {
this.__store.setState((s) => ({
...s,
[matchesKey]: s[matchesKey]?.map((d) => d.id === id ? updater(d) : d)
}));
}
};
this.getMatch = (matchId) => {
const findFn = (d) => d.id === matchId;
return this.state.cachedMatches.find(findFn) ?? this.state.pendingMatches?.find(findFn) ?? this.state.matches.find(findFn);
};
this.invalidate = (opts) => {
const invalidate = (d) => {
if (opts?.filter?.(d) ?? true) {
return {
...d,
invalid: true,
...opts?.forcePending || d.status === "error" ? { status: "pending", error: void 0 } : void 0
};
}
return d;
};
this.__store.setState((s) => ({
...s,
matches: s.matches.map(invalidate),
cachedMatches: s.cachedMatches.map(invalidate),
pendingMatches: s.pendingMatches?.map(invalidate)
}));
this.shouldViewTransition = false;
return this.load({ sync: opts?.sync });
};
this.resolveRedirect = (redirect2) => {
if (!redirect2.options.href) {
const location = this.buildLocation(redirect2.options);
let href = location.url;
if (this.origin && href.startsWith(this.origin)) {
href = href.replace(this.origin, "") || "/";
}
redirect2.options.href = location.href;
redirect2.headers.set("Location", href);
}
if (!redirect2.headers.get("Location")) {
redirect2.headers.set("Location", redirect2.options.href);
}
return redirect2;
};
this.clearCache = (opts) => {
const filter = opts?.filter;
if (filter !== void 0) {
this.__store.setState((s) => {
return {
...s,
cachedMatches: s.cachedMatches.filter(
(m) => !filter(m)
)
};
});
} else {
this.__store.setState((s) => {
return {
...s,
cachedMatches: []
};
});
}
};
this.clearExpiredCache = () => {
const filter = (d) => {
const route = this.looseRoutesById[d.routeId];
if (!route.options.loader) {
return true;
}
const gcTime = (d.preload ? route.options.preloadGcTime ?? this.options.defaultPreloadGcTime : route.options.gcTime ?? this.options.defaultGcTime) ?? 5 * 60 * 1e3;
const isError = d.status === "error";
if (isError) return true;
const gcEligible = Date.now() - d.updatedAt >= gcTime;
return gcEligible;
};
this.clearCache({ filter });
};
this.loadRouteChunk = loadRouteChunk;
this.preloadRoute = async (opts) => {
const next = this.buildLocation(opts);
let matches = this.matchRoutes(next, {
throwOnError: true,
preload: true,
dest: opts
});
const activeMatchIds = new Set(
[...this.state.matches, ...this.state.pendingMatches ?? []].map(
(d) => d.id
)
);
const loadedMatchIds = /* @__PURE__ */ new Set([
...activeMatchIds,
...this.state.cachedMatches.map((d) => d.id)
]);
batch(() => {
matches.forEach((match) => {
if (!loadedMatchIds.has(match.id)) {
this.__store.setState((s) => ({
...s,
cachedMatches: [...s.cachedMatches, match]
}));
}
});
});
try {
matches = await loadMatches({
router: this,
matches,
location: next,
preload: true,
updateMatch: (id, updater) => {
if (activeMatchIds.has(id)) {
matches = matches.map((d) => d.id === id ? updater(d) : d);
} else {
this.updateMatch(id, updater);
}
}
});
return matches;
} catch (err) {
if (isRedirect(err)) {
if (err.options.reloadDocument) {
return void 0;
}
return await this.preloadRoute({
...err.options,
_fromLocation: next
});
}
if (!isNotFound(err)) {
console.error(err);
}
return void 0;
}
};
this.matchRoute = (location, opts) => {
const matchLocation = {
...location,
to: location.to ? this.resolvePathWithBase(
location.from || "",
location.to
) : void 0,
params: location.params || {},
leaveParams: true
};
const next = this.buildLocation(matchLocation);
if (opts?.pending && this.state.status !== "pending") {
return false;
}
const pending = opts?.pending === void 0 ? !this.state.isLoading : opts.pending;
const baseLocation = pending ? this.latestLocation : this.state.resolvedLocation || this.state.location;
const match = matchPathname(
baseLocation.pathname,
{
...opts,
to: next.pathname
},
this.parsePathnameCache
);
if (!match) {
return false;
}
if (location.params) {
if (!deepEqual(match, location.params, { partial: true })) {
return false;
}
}
if (match && (opts?.includeSearch ?? true)) {
return deepEqual(baseLocation.search, next.search, { partial: true }) ? match : false;
}
return match;
};
this.hasNotFoundMatch = () => {
return this.__store.state.matches.some(
(d) => d.status === "notFound" || d.globalNotFound
);
};
this.update({
defaultPreloadDelay: 50,
defaultPendingMs: 1e3,
defaultPendingMinMs: 500,
context: void 0,
...options,
caseSensitive: options.caseSensitive ?? false,
notFoundMode: options.notFoundMode ?? "fuzzy",
stringifySearch: options.stringifySearch ?? defaultStringifySearch,
parseSearch: options.parseSearch ?? defaultParseSearch
});
if (typeof document !== "undefined") {
self.__TSR_ROUTER__ = this;
}
}
isShell() {
return !!this.options.isShell;
}
isPrerendering() {
return !!this.options.isPrerendering;
}
get state() {
return this.__store.state;
}
get looseRoutesById() {
return this.routesById;
}
matchRoutesInternal(next, opts) {
const { foundRoute, matchedRoutes, routeParams } = this.getMatchedRoutes(
next.pathname,
opts?.dest?.to
);
let isGlobalNotFound = false;
if (
// If we found a route, and it's not an index route and we have left over path
foundRoute ? foundRoute.path !== "/" && routeParams["**"] : (
// Or if we didn't find a route and we have left over path
trimPathRight(next.pathname)
)
) {
if (this.options.notFoundRoute) {
matchedRoutes.push(this.options.notFoundRoute);
} else {
isGlobalNotFound = true;
}
}
const globalNotFoundRouteId = (() => {
if (!isGlobalNotFound) {
return void 0;
}
if (this.options.notFoundMode !== "root") {
for (let i = matchedRoutes.length - 1; i >= 0; i--) {
const route = matchedRoutes[i];
if (route.children) {
return route.id;
}
}
}
return rootRouteId;
})();
const matches = [];
const getParentContext = (parentMatch) => {
const parentMatchId = parentMatch?.id;
const parentContext = !parentMatchId ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
return parentContext;
};
matchedRoutes.forEach((route, index) => {
const parentMatch = matches[index - 1];
const [preMatchSearch, strictMatchSearch, searchError] = (() => {
const parentSearch = parentMatch?.search ?? next.search;
const parentStrictSearch = parentMatch?._strictSearch ?? void 0;
try {
const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? void 0;
return [
{
...parentSearch,
...strictSearch
},
{ ...parentStrictSearch, ...strictSearch },
void 0
];
} catch (err) {
let searchParamError = err;
if (!(err instanceof SearchParamError)) {
searchParamError = new SearchParamError(err.message, {
cause: err
});
}
if (opts?.throwOnError) {
throw searchParamError;
}
return [parentSearch, {}, searchParamError];
}
})();
const loaderDeps = route.options.loaderDeps?.({
search: preMatchSearch
}) ?? "";
const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
const { interpolatedPath, usedParams } = interpolatePath({
path: route.fullPath,
params: routeParams,
decodeCharMap: this.pathParamsDecodeCharMap
});
const matchId = interpolatePath({
path: route.id,
params: routeParams,
leaveWildcards: true,
decodeCharMap: this.pathParamsDecodeCharMap,
parseCache: this.parsePathnameCache
}).interpolatedPath + loaderDepsHash;
const existingMatch = this.getMatch(matchId);
const previousMatch = this.state.matches.find(
(d) => d.routeId === route.id
);
const strictParams = existingMatch?._strictParams ?? usedParams;
let paramsError = void 0;
if (!existingMatch) {
const strictParseParams = route.options.params?.parse ?? route.options.parseParams;
if (strictParseParams) {
try {
Object.assign(
strictParams,
strictParseParams(strictParams)
);
} catch (err) {
paramsError = new PathParamError(err.message, {
cause: err
});
if (opts?.throwOnError) {
throw paramsError;
}
}
}
}
Object.assign(routeParams, strictParams);
const cause = previousMatch ? "stay" : "enter";
let match;
if (existingMatch) {
match = {
...existingMatch,
cause,
params: previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
_strictParams: strictParams,
search: previousMatch ? replaceEqualDeep(previousMatch.search, preMatchSearch) : replaceEqualDeep(existingMatch.search, preMatchSearch),
_strictSearch: strictMatchSearch
};
} else {
const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
match = {
id: matchId,
index,
routeId: route.id,
params: previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
_strictParams: strictParams,
pathname: interpolatedPath,
updatedAt: Date.now(),
search: previousMatch ? replaceEqualDeep(previousMatch.search, preMatchSearch) : preMatchSearch,
_strictSearch: strictMatchSearch,
searchError: void 0,
status,
isFetching: false,
error: void 0,
paramsError,
__routeContext: void 0,
_nonReactive: {
loadPromise: createControlledPromise()
},
__beforeLoadContext: void 0,
context: {},
abortController: new AbortController(),
fetchCount: 0,
cause,
loaderDeps: previousMatch ? replaceEqualDeep(previousMatch.loaderDeps, loaderDeps) : loaderDeps,
invalid: false,
preload: false,
links: void 0,
scripts: void 0,
headScripts: void 0,
meta: void 0,
staticData: route.options.staticData || {},
fullPath: route.fullPath
};
}
if (!opts?.preload) {
match.globalNotFound = globalNotFoundRouteId === route.id;
}
match.searchError = searchError;
const parentContext = getParentContext(parentMatch);
match.context = {
...parentContext,
...match.__routeContext,
...match.__beforeLoadContext
};
matches.push(match);
});
matches.forEach((match, index) => {
const route = this.looseRoutesById[match.routeId];
const existingMatch = this.getMatch(match.id);
if (!existingMatch && opts?._buildLocation !== true) {
const parentMatch = matches[index - 1];
const parentContext = getParentContext(parentMatch);
if (route.options.context) {
const contextFnContext = {
deps: match.loaderDeps,
params: match.params,
context: parentContext ?? {},
location: next,
navigate: (opts2) => this.navigate({ ...opts2, _fromLocation: next }),
buildLocation: this.buildLocation,
cause: match.cause,
abortController: match.abortController,
preload: !!match.preload,
matches
};
match.__routeContext = route.options.context(contextFnContext) ?? void 0;
}
match.context = {
...parentContext,
...match.__routeContext,
...match.__beforeLoadContext
};
}
});
return matches;
}
};
var SearchParamError = class extends Error {
};
var PathParamError = class extends Error {
};
var normalize = (str) => str.endsWith("/") && str.length > 1 ? str.slice(0, -1) : str;
function comparePaths(a, b) {
return normalize(a) === normalize(b);
}
function getInitialRouterState(location) {
return {
loadedAt: 0,
isLoading: false,
isTransitioning: false,
status: "idle",
resolvedLocation: void 0,
location,
matches: [],
pendingMatches: [],
cachedMatches: [],
statusCode: 200
};
}
function validateSearch(validateSearch2, input) {
if (validateSearch2 == null) return {};
if ("~standard" in validateSearch2) {
const result = validateSearch2["~standard"].validate(input);
if (result instanceof Promise)
throw new SearchParamError("Async validation not supported");
if (result.issues)
throw new SearchParamError(JSON.stringify(result.issues, void 0, 2), {
cause: result
});
return result.value;
}
if ("parse" in validateSearch2) {
return validateSearch2.parse(input);
}
if (typeof validateSearch2 === "function") {
return validateSearch2(input);
}
return {};
}
function getMatchedRoutes({
pathname,
routePathname,
caseSensitive,
routesByPath,
routesById,
flatRoutes,
parseCache
}) {
let routeParams = {};
const trimmedPath = trimPathRight(pathname);
const getMatchedParams = (route) => {
const result = matchPathname(
trimmedPath,
{
to: route.fullPath,
caseSensitive: route.options?.caseSensitive ?? caseSensitive,
// we need fuzzy matching for `notFoundMode: 'fuzzy'`
fuzzy: true
},
parseCache
);
return result;
};
let foundRoute = routePathname !== void 0 ? routesByPath[routePathname] : void 0;
if (foundRoute) {
routeParams = getMatchedParams(foundRoute);
} else {
let fuzzyMatch = void 0;
for (const route of flatRoutes) {
const matchedParams = getMatchedParams(route);
if (matchedParams) {
if (route.path !== "/" && matchedParams["**"]) {
if (!fuzzyMatch) {
fuzzyMatch = { foundRoute: route, routeParams: matchedParams };
}
} else {
foundRoute = route;
routeParams = matchedParams;
break;
}
}
}
if (!foundRoute && fuzzyMatch) {
foundRoute = fuzzyMatch.foundRoute;
routeParams = fuzzyMatch.routeParams;
}
}
let routeCursor = foundRoute || routesById[rootRouteId];
const matchedRoutes = [routeCursor];
while (routeCursor.parentRoute) {
routeCursor = routeCursor.parentRoute;
matchedRoutes.push(routeCursor);
}
matchedRoutes.reverse();
return { matchedRoutes, routeParams, foundRoute };
}
function applySearchMiddleware({
search,
dest,
destRoutes,
_includeValidateSearch
}) {
const allMiddlewares = destRoutes.reduce(
(acc, route) => {
const middlewares = [];
if ("search" in route.options) {
if (route.options.search?.middlewares) {
middlewares.push(...route.options.search.middlewares);
}
} else if (route.options.preSearchFilters || route.options.postSearchFilters) {
const legacyMiddleware = ({
search: search2,
next
}) => {
let nextSearch = search2;
if ("preSearchFilters" in route.options && route.options.preSearchFilters) {
nextSearch = route.options.preSearchFilters.reduce(
(prev, next2) => next2(prev),
search2
);
}
const result = next(nextSearch);
if ("postSearchFilters" in route.options && route.options.postSearchFilters) {
return route.options.postSearchFilters.reduce(
(prev, next2) => next2(prev),
result
);
}
return result;
};
middlewares.push(legacyMiddleware);
}
if (_includeValidateSearch && route.options.validateSearch) {
const validate = ({ search: search2, next }) => {
const result = next(search2);
try {
const validatedSearch = {
...result,
...validateSearch(route.options.validateSearch, result) ?? void 0
};
return validatedSearch;
} catch {
return result;
}
};
middlewares.push(validate);
}
return acc.concat(middlewares);
},
[]
) ?? [];
const final = ({ search: search2 }) => {
if (!dest.search) {
return {};
}
if (dest.search === true) {
return search2;
}
return functionalUpdate(dest.search, search2);
};
allMiddlewares.push(final);
const applyNext = (index, currentSearch) => {
if (index >= allMiddlewares.length) {
return currentSearch;
}
const middleware = allMiddlewares[index];
const next = (newSearch) => {
return applyNext(index + 1, newSearch);
};
return middleware({ search: currentSearch, next });
};
return applyNext(0, search);
}
// node_modules/@tanstack/router-core/dist/esm/link.js
var preloadWarning = "Error preloading route! \u261D\uFE0F";
// node_modules/@tanstack/router-core/dist/esm/route.js
var BaseRoute = class {
constructor(options) {
this.init = (opts) => {
this.originalIndex = opts.originalIndex;
const options2 = this.options;
const isRoot = !options2?.path && !options2?.id;
this.parentRoute = this.options.getParentRoute?.();
if (isRoot) {
this._path = rootRouteId;
} else if (!this.parentRoute) {
invariant(
false,
`Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance.`
);
}
let path = isRoot ? rootRouteId : options2?.path;
if (path && path !== "/") {
path = trimPathLeft(path);
}
const customId = options2?.id || path;
let id = isRoot ? rootRouteId : joinPaths([
this.parentRoute.id === rootRouteId ? "" : this.parentRoute.id,
customId
]);
if (path === rootRouteId) {
path = "/";
}
if (id !== rootRouteId) {
id = joinPaths(["/", id]);
}
const fullPath = id === rootRouteId ? "/" : joinPaths([this.parentRoute.fullPath, path]);
this._path = path;
this._id = id;
this._fullPath = fullPath;
this._to = fullPath;
};
this.clone = (other) => {
this._path = other._path;
this._id = other._id;
this._fullPath = other._fullPath;
this._to = other._to;
this.options.getParentRoute = other.options.getParentRoute;
this.children = other.children;
};
this.addChildren = (children) => {
return this._addFileChildren(children);
};
this._addFileChildren = (children) => {
if (Array.isArray(children)) {
this.children = children;
}
if (typeof children === "object" && children !== null) {
this.children = Object.values(children);
}
return this;
};
this._addFileTypes = () => {
return this;
};
this.updateLoader = (options2) => {
Object.assign(this.options, options2);
return this;
};
this.update = (options2) => {
Object.assign(this.options, options2);
return this;
};
this.lazy = (lazyFn2) => {
this.lazyFn = lazyFn2;
return this;
};
this.options = options || {};
this.isRoot = !options?.getParentRoute;
if (options?.id && options?.path) {
throw new Error(`Route cannot have both an 'id' and a 'path' option.`);
}
}
get to() {
return this._to;
}
get id() {
return this._id;
}
get path() {
return this._path;
}
get fullPath() {
return this._fullPath;
}
};
var BaseRootRoute = class extends BaseRoute {
constructor(options) {
super(options);
}
};
// node_modules/@tanstack/react-router/dist/esm/CatchBoundary.js
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
var React = __toESM(require_react(), 1);
function CatchBoundary(props) {
const errorComponent = props.errorComponent ?? ErrorComponent;
return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
CatchBoundaryImpl,
{
getResetKey: props.getResetKey,
onCatch: props.onCatch,
children: ({ error, reset }) => {
if (error) {
return React.createElement(errorComponent, {
error,
reset
});
}
return props.children;
}
}
);
}
var CatchBoundaryImpl = class extends React.Component {
constructor() {
super(...arguments);
this.state = { error: null };
}
static getDerivedStateFromProps(props) {
return { resetKey: props.getResetKey() };
}
static getDerivedStateFromError(error) {
return { error };
}
reset() {
this.setState({ error: null });
}
componentDidUpdate(prevProps, prevState) {
if (prevState.error && prevState.resetKey !== this.state.resetKey) {
this.reset();
}
}
componentDidCatch(error, errorInfo) {
if (this.props.onCatch) {
this.props.onCatch(error, errorInfo);
}
}
render() {
return this.props.children({
error: this.state.resetKey !== this.props.getResetKey() ? null : this.state.error,
reset: () => {
this.reset();
}
});
}
};
function ErrorComponent({ error }) {
const [show, setShow] = React.useState(true);
return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { padding: ".5rem", maxWidth: "100%" }, children: [
/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: ".5rem" }, children: [
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { style: { fontSize: "1rem" }, children: "Something went wrong!" }),
/* @__PURE__ */ (0, import_jsx_runtime.jsx)(
"button",
{
style: {
appearance: "none",
fontSize: ".6em",
border: "1px solid currentColor",
padding: ".1rem .2rem",
fontWeight: "bold",
borderRadius: ".25rem"
},
onClick: () => setShow((d) => !d),
children: show ? "Hide Error" : "Show Error"
}
)
] }),
/* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { height: ".25rem" } }),
show ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
"pre",
{
style: {
fontSize: ".7em",
border: "1px solid red",
borderRadius: ".25rem",
padding: ".3rem",
color: "red",
overflow: "auto"
},
children: error.message ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: error.message }) : null
}
) }) : null
] });
}
// node_modules/@tanstack/react-router/dist/esm/ClientOnly.js
var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
var import_react = __toESM(require_react(), 1);
function ClientOnly({ children, fallback = null }) {
return useHydrated() ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react.default.Fragment, { children }) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react.default.Fragment, { children: fallback });
}
function useHydrated() {
return import_react.default.useSyncExternalStore(
subscribe,
() => true,
() => false
);
}
function subscribe() {
return () => {
};
}
// node_modules/tiny-warning/dist/tiny-warning.esm.js
var isProduction2 = false;
function warning(condition, message) {
if (!isProduction2) {
if (condition) {
return;
}
var text = "Warning: " + message;
if (typeof console !== "undefined") {
console.warn(text);
}
try {
throw Error(text);
} catch (x) {
}
}
}
var tiny_warning_esm_default = warning;
// node_modules/@tanstack/react-router/dist/esm/route.js
var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
var import_react3 = __toESM(require_react(), 1);
// node_modules/@tanstack/react-router/dist/esm/useMatch.js
var React5 = __toESM(require_react(), 1);
// node_modules/@tanstack/react-store/dist/esm/index.js
var import_with_selector = __toESM(require_with_selector(), 1);
function useStore(store, selector = (d) => d, options = {}) {
const equal = options.equal ?? shallow;
const slice = (0, import_with_selector.useSyncExternalStoreWithSelector)(
store.subscribe,
() => store.state,
() => store.state,
selector,
equal
);
return slice;
}
function shallow(objA, objB) {
if (Object.is(objA, objB)) {
return true;
}
if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
return false;
}
if (objA instanceof Map && objB instanceof Map) {
if (objA.size !== objB.size) return false;
for (const [k, v] of objA) {
if (!objB.has(k) || !Object.is(v, objB.get(k))) return false;
}
return true;
}
if (objA instanceof Set && objB instanceof Set) {
if (objA.size !== objB.size) return false;
for (const v of objA) {
if (!objB.has(v)) return false;
}
return true;
}
if (objA instanceof Date && objB instanceof Date) {
if (objA.getTime() !== objB.getTime()) return false;
return true;
}
const keysA = getOwnKeys(objA);
if (keysA.length !== getOwnKeys(objB).length) {
return false;
}
for (let i = 0; i < keysA.length; i++) {
if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) {
return false;
}
}
return true;
}
function getOwnKeys(obj) {
return Object.keys(obj).concat(
Object.getOwnPropertySymbols(obj)
);
}
// node_modules/@tanstack/react-router/dist/esm/useRouterState.js
var import_react2 = __toESM(require_react(), 1);
// node_modules/@tanstack/react-router/dist/esm/useRouter.js
var React3 = __toESM(require_react(), 1);
// node_modules/@tanstack/react-router/dist/esm/routerContext.js
var React2 = __toESM(require_react(), 1);
var routerContext = React2.createContext(null);
function getRouterContext() {
if (typeof document === "undefined") {
return routerContext;
}
if (window.__TSR_ROUTER_CONTEXT__) {
return window.__TSR_ROUTER_CONTEXT__;
}
window.__TSR_ROUTER_CONTEXT__ = routerContext;
return routerContext;
}
// node_modules/@tanstack/react-router/dist/esm/useRouter.js
function useRouter(opts) {
const value = React3.useContext(getRouterContext());
tiny_warning_esm_default(
!((opts?.warn ?? true) && !value),
"useRouter must be used inside a <RouterProvider> component!"
);
return value;
}
// node_modules/@tanstack/react-router/dist/esm/useRouterState.js
function useRouterState(opts) {
const contextRouter = useRouter({
warn: opts?.router === void 0
});
const router = opts?.router || contextRouter;
const previousResult = (0, import_react2.useRef)(void 0);
return useStore(router.__store, (state) => {
if (opts?.select) {
if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {
const newSlice = replaceEqualDeep(
previousResult.current,
opts.select(state)
);
previousResult.current = newSlice;
return newSlice;
}
return opts.select(state);
}
return state;
});
}
// node_modules/@tanstack/react-router/dist/esm/matchContext.js
var React4 = __toESM(require_react(), 1);
var matchContext = React4.createContext(void 0);
var dummyMatchContext = React4.createContext(
void 0
);
// node_modules/@tanstack/react-router/dist/esm/useMatch.js
function useMatch(opts) {
const nearestMatchId = React5.useContext(
opts.from ? dummyMatchContext : matchContext
);
const matchSelection = useRouterState({
select: (state) => {
const match = state.matches.find(
(d) => opts.from ? opts.from === d.routeId : d.id === nearestMatchId
);
invariant(
!((opts.shouldThrow ?? true) && !match),
`Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`
);
if (match === void 0) {
return void 0;
}
return opts.select ? opts.select(match) : match;
},
structuralSharing: opts.structuralSharing
});
return matchSelection;
}
// node_modules/@tanstack/react-router/dist/esm/useLoaderData.js
function useLoaderData(opts) {
return useMatch({
from: opts.from,
strict: opts.strict,
structuralSharing: opts.structuralSharing,
select: (s) => {
return opts.select ? opts.select(s.loaderData) : s.loaderData;
}
});
}
// node_modules/@tanstack/react-router/dist/esm/useLoaderDeps.js
function useLoaderDeps(opts) {
const { select, ...rest } = opts;
return useMatch({
...rest,
select: (s) => {
return select ? select(s.loaderDeps) : s.loaderDeps;
}
});
}
// node_modules/@tanstack/react-router/dist/esm/useParams.js
function useParams(opts) {
return useMatch({
from: opts.from,
shouldThrow: opts.shouldThrow,
structuralSharing: opts.structuralSharing,
strict: opts.strict,
select: (match) => {
const params = opts.strict === false ? match.params : match._strictParams;
return opts.select ? opts.select(params) : params;
}
});
}
// node_modules/@tanstack/react-router/dist/esm/useSearch.js
function useSearch(opts) {
return useMatch({
from: opts.from,
strict: opts.strict,
shouldThrow: opts.shouldThrow,
structuralSharing: opts.structuralSharing,
select: (match) => {
return opts.select ? opts.select(match.search) : match.search;
}
});
}
// node_modules/@tanstack/react-router/dist/esm/useNavigate.js
var React6 = __toESM(require_react(), 1);
function useNavigate(_defaultOpts) {
const router = useRouter();
return React6.useCallback(
(options) => {
return router.navigate({
...options,
from: options.from ?? _defaultOpts?.from
});
},
[_defaultOpts?.from, router]
);
}
// node_modules/@tanstack/react-router/dist/esm/link.js
var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
var React8 = __toESM(require_react(), 1);
var import_react_dom = __toESM(require_react_dom(), 1);
// node_modules/@tanstack/react-router/dist/esm/utils.js
var React7 = __toESM(require_react(), 1);
var useLayoutEffect2 = typeof window !== "undefined" ? React7.useLayoutEffect : React7.useEffect;
function usePrevious(value) {
const ref = React7.useRef({
value,
prev: null
});
const current = ref.current.value;
if (value !== current) {
ref.current = {
value,
prev: current
};
}
return ref.current.prev;
}
function useIntersectionObserver(ref, callback, intersectionObserverOptions2 = {}, options = {}) {
React7.useEffect(() => {
if (!ref.current || options.disabled || typeof IntersectionObserver !== "function") {
return;
}
const observer = new IntersectionObserver(([entry]) => {
callback(entry);
}, intersectionObserverOptions2);
observer.observe(ref.current);
return () => {
observer.disconnect();
};
}, [callback, intersectionObserverOptions2, options.disabled, ref]);
}
function useForwardedRef(ref) {
const innerRef = React7.useRef(null);
React7.useImperativeHandle(ref, () => innerRef.current, []);
return innerRef;
}
// node_modules/@tanstack/react-router/dist/esm/link.js
function useLinkProps(options, forwardedRef) {
const router = useRouter();
const [isTransitioning, setIsTransitioning] = React8.useState(false);
const hasRenderFetched = React8.useRef(false);
const innerRef = useForwardedRef(forwardedRef);
const {
// custom props
activeProps,
inactiveProps,
activeOptions,
to,
preload: userPreload,
preloadDelay: userPreloadDelay,
hashScrollIntoView,
replace,
startTransition: startTransition2,
resetScroll,
viewTransition,
// element props
children,
target,
disabled,
style,
className,
onClick,
onFocus,
onMouseEnter,
onMouseLeave,
onTouchStart,
ignoreBlocker,
// prevent these from being returned
params: _params,
search: _search,
hash: _hash,
state: _state,
mask: _mask,
reloadDocument: _reloadDocument,
unsafeRelative: _unsafeRelative,
from: _from,
_fromLocation,
...propsSafeToSpread
} = options;
const currentSearch = useRouterState({
select: (s) => s.location.search,
structuralSharing: true
});
const from = options.from;
const _options = React8.useMemo(
() => {
return { ...options, from };
},
// eslint-disable-next-line react-hooks/exhaustive-deps
[
router,
currentSearch,
from,
options._fromLocation,
options.hash,
options.to,
options.search,
options.params,
options.state,
options.mask,
options.unsafeRelative
]
);
const next = React8.useMemo(
() => router.buildLocation({ ..._options }),
[router, _options]
);
const hrefOption = React8.useMemo(() => {
if (disabled) {
return void 0;
}
let href = next.maskedLocation ? next.maskedLocation.url : next.url;
let external = false;
if (router.origin) {
if (href.startsWith(router.origin)) {
href = router.history.createHref(href.replace(router.origin, "")) || "/";
} else {
external = true;
}
}
return { href, external };
}, [disabled, next.maskedLocation, next.url, router.origin, router.history]);
const externalLink = React8.useMemo(() => {
if (hrefOption?.external) {
return hrefOption.href;
}
try {
new URL(to);
return to;
} catch {
}
return void 0;
}, [to, hrefOption]);
const preload = options.reloadDocument || externalLink ? false : userPreload ?? router.options.defaultPreload;
const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
const isActive = useRouterState({
select: (s) => {
if (externalLink) return false;
if (activeOptions?.exact) {
const testExact = exactPathTest(
s.location.pathname,
next.pathname,
router.basepath
);
if (!testExact) {
return false;
}
} else {
const currentPathSplit = removeTrailingSlash(
s.location.pathname,
router.basepath
);
const nextPathSplit = removeTrailingSlash(
next.pathname,
router.basepath
);
const pathIsFuzzyEqual = currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/");
if (!pathIsFuzzyEqual) {
return false;
}
}
if (activeOptions?.includeSearch ?? true) {
const searchTest = deepEqual(s.location.search, next.search, {
partial: !activeOptions?.exact,
ignoreUndefined: !activeOptions?.explicitUndefined
});
if (!searchTest) {
return false;
}
}
if (activeOptions?.includeHash) {
return s.location.hash === next.hash;
}
return true;
}
});
const doPreload = React8.useCallback(() => {
router.preloadRoute({ ..._options }).catch((err) => {
console.warn(err);
console.warn(preloadWarning);
});
}, [router, _options]);
const preloadViewportIoCallback = React8.useCallback(
(entry) => {
if (entry?.isIntersecting) {
doPreload();
}
},
[doPreload]
);
useIntersectionObserver(
innerRef,
preloadViewportIoCallback,
intersectionObserverOptions,
{ disabled: !!disabled || !(preload === "viewport") }
);
React8.useEffect(() => {
if (hasRenderFetched.current) {
return;
}
if (!disabled && preload === "render") {
doPreload();
hasRenderFetched.current = true;
}
}, [disabled, doPreload, preload]);
const handleClick = (e) => {
const elementTarget = e.currentTarget.getAttribute("target");
const effectiveTarget = target !== void 0 ? target : elementTarget;
if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!effectiveTarget || effectiveTarget === "_self") && e.button === 0) {
e.preventDefault();
(0, import_react_dom.flushSync)(() => {
setIsTransitioning(true);
});
const unsub = router.subscribe("onResolved", () => {
unsub();
setIsTransitioning(false);
});
router.navigate({
..._options,
replace,
resetScroll,
hashScrollIntoView,
startTransition: startTransition2,
viewTransition,
ignoreBlocker
});
}
};
if (externalLink) {
return {
...propsSafeToSpread,
ref: innerRef,
href: externalLink,
...children && { children },
...target && { target },
...disabled && { disabled },
...style && { style },
...className && { className },
...onClick && { onClick },
...onFocus && { onFocus },
...onMouseEnter && { onMouseEnter },
...onMouseLeave && { onMouseLeave },
...onTouchStart && { onTouchStart }
};
}
const handleFocus = (_) => {
if (disabled) return;
if (preload) {
doPreload();
}
};
const handleTouchStart = handleFocus;
const handleEnter = (e) => {
if (disabled || !preload) return;
if (!preloadDelay) {
doPreload();
} else {
const eventTarget = e.target;
if (timeoutMap.has(eventTarget)) {
return;
}
const id = setTimeout(() => {
timeoutMap.delete(eventTarget);
doPreload();
}, preloadDelay);
timeoutMap.set(eventTarget, id);
}
};
const handleLeave = (e) => {
if (disabled || !preload || !preloadDelay) return;
const eventTarget = e.target;
const id = timeoutMap.get(eventTarget);
if (id) {
clearTimeout(id);
timeoutMap.delete(eventTarget);
}
};
const resolvedActiveProps = isActive ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
const resolvedInactiveProps = isActive ? STATIC_EMPTY_OBJECT : functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT;
const resolvedClassName = [
className,
resolvedActiveProps.className,
resolvedInactiveProps.className
].filter(Boolean).join(" ");
const resolvedStyle = (style || resolvedActiveProps.style || resolvedInactiveProps.style) && {
...style,
...resolvedActiveProps.style,
...resolvedInactiveProps.style
};
return {
...propsSafeToSpread,
...resolvedActiveProps,
...resolvedInactiveProps,
href: hrefOption?.href,
ref: innerRef,
onClick: composeHandlers([onClick, handleClick]),
onFocus: composeHandlers([onFocus, handleFocus]),
onMouseEnter: composeHandlers([onMouseEnter, handleEnter]),
onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),
onTouchStart: composeHandlers([onTouchStart, handleTouchStart]),
disabled: !!disabled,
target,
...resolvedStyle && { style: resolvedStyle },
...resolvedClassName && { className: resolvedClassName },
...disabled && STATIC_DISABLED_PROPS,
...isActive && STATIC_ACTIVE_PROPS,
...isTransitioning && STATIC_TRANSITIONING_PROPS
};
}
var STATIC_EMPTY_OBJECT = {};
var STATIC_ACTIVE_OBJECT = { className: "active" };
var STATIC_DISABLED_PROPS = { role: "link", "aria-disabled": true };
var STATIC_ACTIVE_PROPS = { "data-status": "active", "aria-current": "page" };
var STATIC_TRANSITIONING_PROPS = { "data-transitioning": "transitioning" };
var timeoutMap = /* @__PURE__ */ new WeakMap();
var intersectionObserverOptions = {
rootMargin: "100px"
};
var composeHandlers = (handlers) => (e) => {
for (const handler of handlers) {
if (!handler) continue;
if (e.defaultPrevented) return;
handler(e);
}
};
function createLink(Comp) {
return React8.forwardRef(function CreatedLink(props, ref) {
return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Link, { ...props, _asChild: Comp, ref });
});
}
var Link = React8.forwardRef(
(props, ref) => {
const { _asChild, ...rest } = props;
const {
type: _type,
ref: innerRef,
...linkProps
} = useLinkProps(rest, ref);
const children = typeof rest.children === "function" ? rest.children({
isActive: linkProps["data-status"] === "active"
}) : rest.children;
if (_asChild === void 0) {
delete linkProps.disabled;
}
return React8.createElement(
_asChild ? _asChild : "a",
{
...linkProps,
ref: innerRef
},
children
);
}
);
function isCtrlEvent(e) {
return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
}
// node_modules/@tanstack/react-router/dist/esm/route.js
var Route = class extends BaseRoute {
/**
* @deprecated Use the `createRoute` function instead.
*/
constructor(options) {
super(options);
this.useMatch = (opts) => {
return useMatch({
select: opts?.select,
from: this.id,
structuralSharing: opts?.structuralSharing
});
};
this.useRouteContext = (opts) => {
return useMatch({
...opts,
from: this.id,
select: (d) => opts?.select ? opts.select(d.context) : d.context
});
};
this.useSearch = (opts) => {
return useSearch({
select: opts?.select,
structuralSharing: opts?.structuralSharing,
from: this.id
});
};
this.useParams = (opts) => {
return useParams({
select: opts?.select,
structuralSharing: opts?.structuralSharing,
from: this.id
});
};
this.useLoaderDeps = (opts) => {
return useLoaderDeps({ ...opts, from: this.id });
};
this.useLoaderData = (opts) => {
return useLoaderData({ ...opts, from: this.id });
};
this.useNavigate = () => {
return useNavigate({ from: this.fullPath });
};
this.Link = import_react3.default.forwardRef(
(props, ref) => {
return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Link, { ref, from: this.fullPath, ...props });
}
);
this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
}
};
function createRoute(options) {
return new Route(
// TODO: Help us TypeChris, you're our only hope!
options
);
}
var RootRoute = class extends BaseRootRoute {
/**
* @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
*/
constructor(options) {
super(options);
this.useMatch = (opts) => {
return useMatch({
select: opts?.select,
from: this.id,
structuralSharing: opts?.structuralSharing
});
};
this.useRouteContext = (opts) => {
return useMatch({
...opts,
from: this.id,
select: (d) => opts?.select ? opts.select(d.context) : d.context
});
};
this.useSearch = (opts) => {
return useSearch({
select: opts?.select,
structuralSharing: opts?.structuralSharing,
from: this.id
});
};
this.useParams = (opts) => {
return useParams({
select: opts?.select,
structuralSharing: opts?.structuralSharing,
from: this.id
});
};
this.useLoaderDeps = (opts) => {
return useLoaderDeps({ ...opts, from: this.id });
};
this.useLoaderData = (opts) => {
return useLoaderData({ ...opts, from: this.id });
};
this.useNavigate = () => {
return useNavigate({ from: this.fullPath });
};
this.Link = import_react3.default.forwardRef(
(props, ref) => {
return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Link, { ref, from: this.fullPath, ...props });
}
);
this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
}
};
function createRootRoute(options) {
return new RootRoute(options);
}
// node_modules/@tanstack/react-router/dist/esm/fileRoute.js
function createFileRoute(path) {
if (typeof path === "object") {
return new FileRoute(path, {
silent: true
}).createRoute(path);
}
return new FileRoute(path, {
silent: true
}).createRoute;
}
var FileRoute = class {
constructor(path, _opts) {
this.path = path;
this.createRoute = (options) => {
tiny_warning_esm_default(
this.silent,
"FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead."
);
const route = createRoute(options);
route.isRoot = false;
return route;
};
this.silent = _opts?.silent;
}
};
var LazyRoute = class {
constructor(opts) {
this.useMatch = (opts2) => {
return useMatch({
select: opts2?.select,
from: this.options.id,
structuralSharing: opts2?.structuralSharing
});
};
this.useRouteContext = (opts2) => {
return useMatch({
from: this.options.id,
select: (d) => opts2?.select ? opts2.select(d.context) : d.context
});
};
this.useSearch = (opts2) => {
return useSearch({
select: opts2?.select,
structuralSharing: opts2?.structuralSharing,
from: this.options.id
});
};
this.useParams = (opts2) => {
return useParams({
select: opts2?.select,
structuralSharing: opts2?.structuralSharing,
from: this.options.id
});
};
this.useLoaderDeps = (opts2) => {
return useLoaderDeps({ ...opts2, from: this.options.id });
};
this.useLoaderData = (opts2) => {
return useLoaderData({ ...opts2, from: this.options.id });
};
this.useNavigate = () => {
const router = useRouter();
return useNavigate({ from: router.routesById[this.options.id].fullPath });
};
this.options = opts;
this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
}
};
function createLazyRoute(id) {
return (opts) => {
return new LazyRoute({
id,
...opts
});
};
}
function createLazyFileRoute(id) {
if (typeof id === "object") {
return new LazyRoute(id);
}
return (opts) => new LazyRoute({ id, ...opts });
}
// node_modules/@tanstack/react-router/dist/esm/Matches.js
var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
var React11 = __toESM(require_react(), 1);
// node_modules/@tanstack/react-router/dist/esm/Transitioner.js
var React9 = __toESM(require_react(), 1);
function Transitioner() {
const router = useRouter();
const mountLoadForRouter = React9.useRef({ router, mounted: false });
const [isTransitioning, setIsTransitioning] = React9.useState(false);
const { hasPendingMatches, isLoading } = useRouterState({
select: (s) => ({
isLoading: s.isLoading,
hasPendingMatches: s.matches.some((d) => d.status === "pending")
}),
structuralSharing: true
});
const previousIsLoading = usePrevious(isLoading);
const isAnyPending = isLoading || isTransitioning || hasPendingMatches;
const previousIsAnyPending = usePrevious(isAnyPending);
const isPagePending = isLoading || hasPendingMatches;
const previousIsPagePending = usePrevious(isPagePending);
router.startTransition = (fn) => {
setIsTransitioning(true);
React9.startTransition(() => {
fn();
setIsTransitioning(false);
});
};
React9.useEffect(() => {
const unsub = router.history.subscribe(router.load);
const nextLocation = router.buildLocation({
to: router.latestLocation.pathname,
search: true,
params: true,
hash: true,
state: true,
_includeValidateSearch: true
});
if (trimPathRight(router.latestLocation.href) !== trimPathRight(nextLocation.href)) {
router.commitLocation({ ...nextLocation, replace: true });
}
return () => {
unsub();
};
}, [router, router.history]);
useLayoutEffect2(() => {
if (
// if we are hydrating from SSR, loading is triggered in ssr-client
typeof window !== "undefined" && router.ssr || mountLoadForRouter.current.router === router && mountLoadForRouter.current.mounted
) {
return;
}
mountLoadForRouter.current = { router, mounted: true };
const tryLoad = async () => {
try {
await router.load();
} catch (err) {
console.error(err);
}
};
tryLoad();
}, [router]);
useLayoutEffect2(() => {
if (previousIsLoading && !isLoading) {
router.emit({
type: "onLoad",
// When the new URL has committed, when the new matches have been loaded into state.matches
...getLocationChangeInfo(router.state)
});
}
}, [previousIsLoading, router, isLoading]);
useLayoutEffect2(() => {
if (previousIsPagePending && !isPagePending) {
router.emit({
type: "onBeforeRouteMount",
...getLocationChangeInfo(router.state)
});
}
}, [isPagePending, previousIsPagePending, router]);
useLayoutEffect2(() => {
if (previousIsAnyPending && !isAnyPending) {
router.emit({
type: "onResolved",
...getLocationChangeInfo(router.state)
});
router.__store.setState((s) => ({
...s,
status: "idle",
resolvedLocation: s.location
}));
handleHashScroll(router);
}
}, [isAnyPending, previousIsAnyPending, router]);
return null;
}
// node_modules/@tanstack/react-router/dist/esm/Match.js
var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
var React10 = __toESM(require_react(), 1);
// node_modules/@tanstack/react-router/dist/esm/not-found.js
var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
function CatchNotFound(props) {
const resetKey = useRouterState({
select: (s) => `not-found-${s.location.pathname}-${s.status}`
});
return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
CatchBoundary,
{
getResetKey: () => resetKey,
onCatch: (error, errorInfo) => {
if (isNotFound(error)) {
props.onCatch?.(error, errorInfo);
} else {
throw error;
}
},
errorComponent: ({ error }) => {
if (isNotFound(error)) {
return props.fallback?.(error);
} else {
throw error;
}
},
children: props.children
}
);
}
function DefaultGlobalNotFound() {
return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("p", { children: "Not Found" });
}
// node_modules/@tanstack/react-router/dist/esm/SafeFragment.js
var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
function SafeFragment(props) {
return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children: props.children });
}
// node_modules/@tanstack/react-router/dist/esm/renderRouteNotFound.js
var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
function renderRouteNotFound(router, route, data) {
if (!route.options.notFoundComponent) {
if (router.options.defaultNotFoundComponent) {
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(router.options.defaultNotFoundComponent, { data });
}
if (true) {
tiny_warning_esm_default(
route.options.notFoundComponent,
`A notFoundError was encountered on the route with ID "${route.id}", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (<div>Not Found<div>)`
);
}
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(DefaultGlobalNotFound, {});
}
return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(route.options.notFoundComponent, { data });
}
// node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js
var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
// node_modules/@tanstack/react-router/dist/esm/ScriptOnce.js
var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
function ScriptOnce({ children }) {
const router = useRouter();
if (!router.isServer) {
return null;
}
return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
"script",
{
nonce: router.options.ssr?.nonce,
className: "$tsr",
dangerouslySetInnerHTML: {
__html: [children].filter(Boolean).join("\n") + ";$_TSR.c()"
}
}
);
}
// node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js
function ScrollRestoration() {
const router = useRouter();
if (!router.isScrollRestoring || !router.isServer) {
return null;
}
if (typeof router.options.scrollRestoration === "function") {
const shouldRestore = router.options.scrollRestoration({
location: router.latestLocation
});
if (!shouldRestore) {
return null;
}
}
const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
const userKey = getKey(router.latestLocation);
const resolvedKey = userKey !== defaultGetScrollRestorationKey(router.latestLocation) ? userKey : void 0;
const restoreScrollOptions = {
storageKey,
shouldScrollRestoration: true
};
if (resolvedKey) {
restoreScrollOptions.key = resolvedKey;
}
return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
ScriptOnce,
{
children: `(${restoreScroll.toString()})(${JSON.stringify(restoreScrollOptions)})`
}
);
}
// node_modules/@tanstack/react-router/dist/esm/Match.js
var Match = React10.memo(function MatchImpl({
matchId
}) {
const router = useRouter();
const matchState = useRouterState({
select: (s) => {
const match = s.matches.find((d) => d.id === matchId);
invariant(
match,
`Could not find match for matchId "${matchId}". Please file an issue!`
);
return {
routeId: match.routeId,
ssr: match.ssr,
_displayPending: match._displayPending
};
},
structuralSharing: true
});
const route = router.routesById[matchState.routeId];
const PendingComponent = route.options.pendingComponent ?? router.options.defaultPendingComponent;
const pendingElement = PendingComponent ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(PendingComponent, {}) : null;
const routeErrorComponent = route.options.errorComponent ?? router.options.defaultErrorComponent;
const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch;
const routeNotFoundComponent = route.isRoot ? (
// If it's the root route, use the globalNotFound option, with fallback to the notFoundRoute's component
route.options.notFoundComponent ?? router.options.notFoundRoute?.options.component
) : route.options.notFoundComponent;
const resolvedNoSsr = matchState.ssr === false || matchState.ssr === "data-only";
const ResolvedSuspenseBoundary = (
// If we're on the root route, allow forcefully wrapping in suspense
(!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) && (route.options.wrapInSuspense ?? PendingComponent ?? (route.options.errorComponent?.preload || resolvedNoSsr)) ? React10.Suspense : SafeFragment
);
const ResolvedCatchBoundary = routeErrorComponent ? CatchBoundary : SafeFragment;
const ResolvedNotFoundBoundary = routeNotFoundComponent ? CatchNotFound : SafeFragment;
const resetKey = useRouterState({
select: (s) => s.loadedAt
});
const parentRouteId = useRouterState({
select: (s) => {
const index = s.matches.findIndex((d) => d.id === matchId);
return s.matches[index - 1]?.routeId;
}
});
const ShellComponent = route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment;
return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(ShellComponent, { children: [
/* @__PURE__ */ (0, import_jsx_runtime10.jsx)(matchContext.Provider, { value: matchId, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(ResolvedSuspenseBoundary, { fallback: pendingElement, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
ResolvedCatchBoundary,
{
getResetKey: () => resetKey,
errorComponent: routeErrorComponent || ErrorComponent,
onCatch: (error, errorInfo) => {
if (isNotFound(error)) throw error;
tiny_warning_esm_default(false, `Error in route match: ${matchId}`);
routeOnCatch?.(error, errorInfo);
},
children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
ResolvedNotFoundBoundary,
{
fallback: (error) => {
if (!routeNotFoundComponent || error.routeId && error.routeId !== matchState.routeId || !error.routeId && !route.isRoot)
throw error;
return React10.createElement(routeNotFoundComponent, error);
},
children: resolvedNoSsr || matchState._displayPending ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(ClientOnly, { fallback: pendingElement, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(MatchInner, { matchId }) }) : /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(MatchInner, { matchId })
}
)
}
) }) }),
parentRouteId === rootRouteId && router.options.scrollRestoration ? /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_jsx_runtime10.Fragment, { children: [
/* @__PURE__ */ (0, import_jsx_runtime10.jsx)(OnRendered, {}),
/* @__PURE__ */ (0, import_jsx_runtime10.jsx)(ScrollRestoration, {})
] }) : null
] });
});
function OnRendered() {
const router = useRouter();
const prevLocationRef = React10.useRef(
void 0
);
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
"script",
{
suppressHydrationWarning: true,
ref: (el) => {
if (el && (prevLocationRef.current === void 0 || prevLocationRef.current.href !== router.latestLocation.href)) {
router.emit({
type: "onRendered",
...getLocationChangeInfo(router.state)
});
prevLocationRef.current = router.latestLocation;
}
}
},
router.latestLocation.state.__TSR_key
);
}
var MatchInner = React10.memo(function MatchInnerImpl({
matchId
}) {
const router = useRouter();
const { match, key, routeId } = useRouterState({
select: (s) => {
const match2 = s.matches.find((d) => d.id === matchId);
const routeId2 = match2.routeId;
const remountFn = router.routesById[routeId2].options.remountDeps ?? router.options.defaultRemountDeps;
const remountDeps = remountFn?.({
routeId: routeId2,
loaderDeps: match2.loaderDeps,
params: match2._strictParams,
search: match2._strictSearch
});
const key2 = remountDeps ? JSON.stringify(remountDeps) : void 0;
return {
key: key2,
routeId: routeId2,
match: {
id: match2.id,
status: match2.status,
error: match2.error,
_forcePending: match2._forcePending,
_displayPending: match2._displayPending
}
};
},
structuralSharing: true
});
const route = router.routesById[routeId];
const out = React10.useMemo(() => {
const Comp = route.options.component ?? router.options.defaultComponent;
if (Comp) {
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Comp, {}, key);
}
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Outlet, {});
}, [key, route.options.component, router.options.defaultComponent]);
if (match._displayPending) {
throw router.getMatch(match.id)?._nonReactive.displayPendingPromise;
}
if (match._forcePending) {
throw router.getMatch(match.id)?._nonReactive.minPendingPromise;
}
if (match.status === "pending") {
const pendingMinMs = route.options.pendingMinMs ?? router.options.defaultPendingMinMs;
if (pendingMinMs) {
const routerMatch = router.getMatch(match.id);
if (routerMatch && !routerMatch._nonReactive.minPendingPromise) {
if (!router.isServer) {
const minPendingPromise = createControlledPromise();
routerMatch._nonReactive.minPendingPromise = minPendingPromise;
setTimeout(() => {
minPendingPromise.resolve();
routerMatch._nonReactive.minPendingPromise = void 0;
}, pendingMinMs);
}
}
}
throw router.getMatch(match.id)?._nonReactive.loadPromise;
}
if (match.status === "notFound") {
invariant(isNotFound(match.error), "Expected a notFound error");
return renderRouteNotFound(router, route, match.error);
}
if (match.status === "redirected") {
invariant(isRedirect(match.error), "Expected a redirect error");
throw router.getMatch(match.id)?._nonReactive.loadPromise;
}
if (match.status === "error") {
if (router.isServer) {
const RouteErrorComponent = (route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent;
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
RouteErrorComponent,
{
error: match.error,
reset: void 0,
info: {
componentStack: ""
}
}
);
}
throw match.error;
}
return out;
});
var Outlet = React10.memo(function OutletImpl() {
const router = useRouter();
const matchId = React10.useContext(matchContext);
const routeId = useRouterState({
select: (s) => s.matches.find((d) => d.id === matchId)?.routeId
});
const route = router.routesById[routeId];
const parentGlobalNotFound = useRouterState({
select: (s) => {
const matches = s.matches;
const parentMatch = matches.find((d) => d.id === matchId);
invariant(
parentMatch,
`Could not find parent match for matchId "${matchId}"`
);
return parentMatch.globalNotFound;
}
});
const childMatchId = useRouterState({
select: (s) => {
const matches = s.matches;
const index = matches.findIndex((d) => d.id === matchId);
return matches[index + 1]?.id;
}
});
const pendingElement = router.options.defaultPendingComponent ? /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(router.options.defaultPendingComponent, {}) : null;
if (parentGlobalNotFound) {
return renderRouteNotFound(router, route, void 0);
}
if (!childMatchId) {
return null;
}
const nextMatch = /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Match, { matchId: childMatchId });
if (matchId === rootRouteId) {
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(React10.Suspense, { fallback: pendingElement, children: nextMatch });
}
return nextMatch;
});
// node_modules/@tanstack/react-router/dist/esm/Matches.js
function Matches() {
const router = useRouter();
const rootRoute = router.routesById[rootRouteId];
const PendingComponent = rootRoute.options.pendingComponent ?? router.options.defaultPendingComponent;
const pendingElement = PendingComponent ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(PendingComponent, {}) : null;
const ResolvedSuspense = router.isServer || typeof document !== "undefined" && router.ssr ? SafeFragment : React11.Suspense;
const inner = /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(ResolvedSuspense, { fallback: pendingElement, children: [
!router.isServer && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Transitioner, {}),
/* @__PURE__ */ (0, import_jsx_runtime11.jsx)(MatchesInner, {})
] });
return router.options.InnerWrap ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(router.options.InnerWrap, { children: inner }) : inner;
}
function MatchesInner() {
const router = useRouter();
const matchId = useRouterState({
select: (s) => {
return s.matches[0]?.id;
}
});
const resetKey = useRouterState({
select: (s) => s.loadedAt
});
const matchComponent = matchId ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Match, { matchId }) : null;
return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(matchContext.Provider, { value: matchId, children: router.options.disableGlobalCatchBoundary ? matchComponent : /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
CatchBoundary,
{
getResetKey: () => resetKey,
errorComponent: ErrorComponent,
onCatch: (error) => {
tiny_warning_esm_default(
false,
`The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!`
);
tiny_warning_esm_default(false, error.message || error.toString());
},
children: matchComponent
}
) });
}
function useMatches(opts) {
return useRouterState({
select: (state) => {
const matches = state.matches;
return opts?.select ? opts.select(matches) : matches;
},
structuralSharing: opts?.structuralSharing
});
}
// node_modules/@tanstack/react-router/dist/esm/router.js
var createRouter = (options) => {
return new Router(options);
};
var Router = class extends RouterCore {
constructor(options) {
super(options);
}
};
if (typeof globalThis !== "undefined") {
globalThis.createFileRoute = createFileRoute;
globalThis.createLazyFileRoute = createLazyFileRoute;
} else if (typeof window !== "undefined") {
window.createFileRoute = createFileRoute;
window.createLazyFileRoute = createLazyFileRoute;
}
// node_modules/@tanstack/react-router/dist/esm/RouterProvider.js
var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
function RouterContextProvider({
router,
children,
...rest
}) {
if (Object.keys(rest).length > 0) {
router.update({
...router.options,
...rest,
context: {
...router.options.context,
...rest.context
}
});
}
const routerContext2 = getRouterContext();
const provider = /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(routerContext2.Provider, { value: router, children });
if (router.options.Wrap) {
return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(router.options.Wrap, { children: provider });
}
return provider;
}
function RouterProvider({ router, ...rest }) {
return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(RouterContextProvider, { router, ...rest, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Matches, {}) });
}
// node_modules/@tanstack/react-router/dist/esm/useLocation.js
function useLocation(opts) {
return useRouterState({
select: (state) => opts?.select ? opts.select(state.location) : state.location
});
}
// node_modules/@tanstack/react-router/dist/esm/useCanGoBack.js
function useCanGoBack() {
return useRouterState({ select: (s) => s.location.state.__TSR_index !== 0 });
}
// packages/route/build-module/lock-unlock.mjs
var import_private_apis = __toESM(require_private_apis(), 1);
var { lock, unlock } = (0, import_private_apis.__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/route"
);
// packages/route/build-module/private-apis.mjs
var privateApis = {};
lock(privateApis, {
// Router creation and setup
createBrowserHistory,
createLazyRoute,
createRouter,
createRootRoute,
createRoute,
Outlet,
RouterProvider,
// Internal routing utilities
redirect,
createLink,
useCanGoBack,
useLoaderData,
useLocation,
useMatches,
useRouter,
// History utilities
parseHref
});
// packages/route/build-module/index.mjs
function useInvalidate() {
const router = useRouter();
return () => router.invalidate();
}
export {
Link,
privateApis,
redirect,
useInvalidate,
useNavigate,
useParams,
useSearch
};
/*! Bundled license information:
use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
(**
* @license React
* use-sync-external-store-shim.development.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js:
(**
* @license React
* use-sync-external-store-shim/with-selector.development.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*)
*/
//# sourceMappingURL=index.js.map