AlkantarClanX12
Your IP : 216.73.217.24 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 notFound(options = {}) {
options.isNotFound = true;
if (options.throw) throw options;
return options;
}
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,
useRouterState,
// History utilities
parseHref
});
// packages/route/build-module/index.mjs
function useInvalidate() {
const router = useRouter();
return () => router.invalidate();
}
export {
Link,
notFound,
privateApis,
redirect,
useInvalidate,
useLinkProps,
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.
*)
*/
Home - Capital GMC Buick Regina
Skip to content
{{ $t(category) }}
Error
{{vehicle.modelData.year}} {{vehicle.modelData.make}} {{vehicle.modelData.model}}
Starting from {{vehicle.modelData.startingPrice | moneyFormat(lang)}}
Welcome to Capital GMC BUICK – REGINA Thank you for choosing Capital GMC Buick | Regina, your premier certified Buick and GMC dealership proudly serving drivers in Regina and the surrounding communities. Whether you’re searching for a brand-new Buick or GMC vehicle or a meticulously inspected pre-owned model, we have a diverse selection to match your needs and lifestyle.
Beyond our impressive inventory, we offer a seamless and stress-free financing experience through our well-connected finance centre, where our team of experts is dedicated to securing the best loan or lease options for you, quickly, transparently, and hassle-free.
But our commitment to you doesn’t stop at the sale. Our state-of-the-art service centre is staffed with skilled Buick and GMC technicians who use the latest equipment and genuine OEM parts to keep your vehicle running at its best. From routine maintenance to complex repairs, we’ve got you covered.
Experience top-tier customer service, quality vehicles, and expert care, all in one place. Visit Capital GMC Buick | Regina today or call us at 306-205-8072 with any questions. We’re here to help!
Ask a Question
Capital GMC Buick – Regina
Contact Us
Have a question or need assistance? Fill out the form and we will reach out to you as soon as possible.
Notice: JavaScript is required for this content.
CLOSE
Schedule a Visit
Let us know when you are coming and how we can assist you. We can ensure someone will be on hand to help you out at the desired date and time.
Notice: JavaScript is required for this content.
CLOSE
Find a Career
Have a look at our list of available positions and apply online today to join our team!
×
Opportunities to Grow
The auto industry is constantly changing and we want to continue to grow. We offer growth, leadership & mentorship programs to allow our staff to grow with us.
×
Competitive Salary
We have a significant earning potential with incentive-based pay in most roles. We also offer an employee referral bonus with paid bonuses.
×
Health & Dental
We offer a comprehensive benefits package including extended health, dental, and vision care. We also include paramedical, life insurance, paid sick leave, short & long-term disability coverages.
×
Vacation
We value our employees and want everyone to take their vacation time. We offer a minimum of 2 weeks vacation each year.
×
Training & Development
We have many opportunities for paid education and training in-house as well as training from the Manufacturer.
×
$10,000 Cash Giveaway – Terms & Conditions All October long, stop by Capital GMC Buick Cadillac, to enter for your chance to win $10,000 cash. No purchase is required, but entries must be made in-store.
The contest is open to residents of Saskatchewan who are 18+. Dealership employees and their households are not eligible. Entries will be accepted from October 1 to October 31, 2025. A random draw will take place on November 1, 2025.
The prize is one $10,000 award, paid by cheque, and must be accepted as awarded. Winner will be contacted by phone or email and must respond within 7 days or another entry may be drawn. Odds of winning depend on the number of entries received.By entering, you agree that Capital Automotive Group may use your name and photo for winner announcements. The contest is governed by the laws of Saskatchewan.
Notice: JavaScript is required for this content.
CLOSE
Members Only Bonus
