8483 lines
288 KiB
JavaScript
8483 lines
288 KiB
JavaScript
"use client";
|
|
import {
|
|
require_jsx_runtime
|
|
} from "./chunk-Q252ZSRM.js";
|
|
import {
|
|
require_react_dom
|
|
} from "./chunk-T4ZNA42A.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-3ZNQHJRW.js";
|
|
import {
|
|
__commonJS,
|
|
__toESM
|
|
} from "./chunk-4MBMRILA.js";
|
|
|
|
// 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 === React3.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 = useState5({
|
|
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]
|
|
);
|
|
useEffect7(
|
|
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 React3 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState5 = React3.useState, useEffect7 = React3.useEffect, useLayoutEffect3 = React3.useLayoutEffect, useDebugValue = React3.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 !== React3.useSyncExternalStore ? React3.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 React3 = require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef10 = React3.useRef, useEffect7 = React3.useEffect, useMemo4 = React3.useMemo, useDebugValue = React3.useDebugValue;
|
|
exports.useSyncExternalStoreWithSelector = function(subscribe2, getSnapshot, getServerSnapshot, selector, isEqual) {
|
|
var instRef = useRef10(null);
|
|
if (null === instRef.current) {
|
|
var inst = { hasValue: false, value: null };
|
|
instRef.current = inst;
|
|
} else inst = instRef.current;
|
|
instRef = useMemo4(
|
|
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]);
|
|
useEffect7(
|
|
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();
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/utils.js
|
|
var React$1 = __toESM(require_react(), 1);
|
|
var reactUse = React$1["use"];
|
|
var useLayoutEffect2 = typeof window !== "undefined" ? React$1.useLayoutEffect : React$1.useEffect;
|
|
function usePrevious(value) {
|
|
const ref = React$1.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 = {}) {
|
|
React$1.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 = React$1.useRef(null);
|
|
React$1.useImperativeHandle(ref, () => innerRef.current, []);
|
|
return innerRef;
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/isServer/development.js
|
|
var isServer = void 0;
|
|
|
|
// 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;
|
|
var isEnumerable = Object.prototype.propertyIsEnumerable;
|
|
var createNull = () => /* @__PURE__ */ Object.create(null);
|
|
var nullReplaceEqualDeep = (prev, next) => replaceEqualDeep(prev, next, createNull);
|
|
function replaceEqualDeep(prev, _next, _makeObj = () => ({}), _depth = 0) {
|
|
if (isServer) return _next;
|
|
if (prev === _next) return prev;
|
|
if (_depth > 500) return _next;
|
|
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) : _makeObj();
|
|
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, _makeObj, _depth + 1);
|
|
copy[key] = v;
|
|
if (v === p) equalItems++;
|
|
}
|
|
return prevSize === nextSize && equalItems === prevSize ? prev : copy;
|
|
}
|
|
function getEnumerableOwnKeys(o) {
|
|
const names = Object.getOwnPropertyNames(o);
|
|
for (const name of names) if (!isEnumerable.call(o, name)) return false;
|
|
const symbols = Object.getOwnPropertySymbols(o);
|
|
if (symbols.length === 0) return names;
|
|
const keys = names;
|
|
for (const symbol of symbols) {
|
|
if (!isEnumerable.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 == null ? void 0 : opts.ignoreUndefined) ?? true;
|
|
if (opts == null ? void 0 : 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 == null ? void 0 : onResolve(value);
|
|
};
|
|
controlledPromise.reject = (e) => {
|
|
controlledPromise.status = "rejected";
|
|
rejectLoadPromise(e);
|
|
};
|
|
return controlledPromise;
|
|
}
|
|
function isModuleNotFoundError(error) {
|
|
if (typeof (error == null ? void 0 : error.message) !== "string") return false;
|
|
return error.message.startsWith("Failed to fetch dynamically imported module") || error.message.startsWith("error loading dynamically imported module") || error.message.startsWith("Importing a module script failed");
|
|
}
|
|
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;
|
|
}
|
|
}
|
|
function sanitizePathSegment(segment) {
|
|
return segment.replace(/[\x00-\x1f\x7f]/g, "");
|
|
}
|
|
function decodeSegment(segment) {
|
|
let decoded;
|
|
try {
|
|
decoded = decodeURI(segment);
|
|
} catch {
|
|
decoded = segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => {
|
|
try {
|
|
return decodeURI(match);
|
|
} catch {
|
|
return match;
|
|
}
|
|
});
|
|
}
|
|
return sanitizePathSegment(decoded);
|
|
}
|
|
var DEFAULT_PROTOCOL_ALLOWLIST = [
|
|
"http:",
|
|
"https:",
|
|
"mailto:",
|
|
"tel:"
|
|
];
|
|
function isDangerousProtocol(url, allowlist) {
|
|
if (!url) return false;
|
|
try {
|
|
const parsed = new URL(url);
|
|
return !allowlist.has(parsed.protocol);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
var HTML_ESCAPE_LOOKUP = {
|
|
"&": "\\u0026",
|
|
">": "\\u003e",
|
|
"<": "\\u003c",
|
|
"\u2028": "\\u2028",
|
|
"\u2029": "\\u2029"
|
|
};
|
|
var HTML_ESCAPE_REGEX = /[&><\u2028\u2029]/g;
|
|
function escapeHtml(str) {
|
|
return str.replace(HTML_ESCAPE_REGEX, (match) => HTML_ESCAPE_LOOKUP[match]);
|
|
}
|
|
function decodePath(path) {
|
|
if (!path) return {
|
|
path,
|
|
handledProtocolRelativeURL: false
|
|
};
|
|
if (!/[%\\\x00-\x1f\x7f]/.test(path) && !path.startsWith("//")) return {
|
|
path,
|
|
handledProtocolRelativeURL: false
|
|
};
|
|
const re = /%25|%5C/gi;
|
|
let cursor = 0;
|
|
let result = "";
|
|
let match;
|
|
while (null !== (match = re.exec(path))) {
|
|
result += decodeSegment(path.slice(cursor, match.index)) + match[0];
|
|
cursor = re.lastIndex;
|
|
}
|
|
result = result + decodeSegment(cursor ? path.slice(cursor) : path);
|
|
let handledProtocolRelativeURL = false;
|
|
if (result.startsWith("//")) {
|
|
handledProtocolRelativeURL = true;
|
|
result = "/" + result.replace(/^\/+/, "");
|
|
}
|
|
return {
|
|
path: result,
|
|
handledProtocolRelativeURL
|
|
};
|
|
}
|
|
function encodePathLikeUrl(path) {
|
|
if (!/\s|[^\u0000-\u007F]/.test(path)) return path;
|
|
return path.replace(/\s|[^\u0000-\u007F]/gu, encodeURIComponent);
|
|
}
|
|
function arraysEqual(a, b) {
|
|
if (a === b) return true;
|
|
if (a.length !== b.length) return false;
|
|
for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
|
|
return true;
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/invariant.js
|
|
function invariant() {
|
|
throw new Error("Invariant failed");
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
},
|
|
clear() {
|
|
cache.clear();
|
|
oldest = void 0;
|
|
newest = void 0;
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.js
|
|
var SEGMENT_TYPE_INDEX = 4;
|
|
var SEGMENT_TYPE_PATHLESS = 5;
|
|
function getOpenAndCloseBraces(part) {
|
|
const openBrace = part.indexOf("{");
|
|
if (openBrace === -1) return null;
|
|
const closeBrace = part.indexOf("}", openBrace);
|
|
if (closeBrace === -1) return null;
|
|
if (openBrace + 1 >= part.length) return null;
|
|
return [openBrace, closeBrace];
|
|
}
|
|
function parseSegment(path, start, output = new Uint16Array(6)) {
|
|
const next = path.indexOf("/", start);
|
|
const end = next === -1 ? path.length : next;
|
|
const part = path.substring(start, end);
|
|
if (!part || !part.includes("$")) {
|
|
output[0] = 0;
|
|
output[1] = start;
|
|
output[2] = start;
|
|
output[3] = end;
|
|
output[4] = end;
|
|
output[5] = end;
|
|
return output;
|
|
}
|
|
if (part === "$") {
|
|
const total = path.length;
|
|
output[0] = 2;
|
|
output[1] = start;
|
|
output[2] = start;
|
|
output[3] = total;
|
|
output[4] = total;
|
|
output[5] = total;
|
|
return output;
|
|
}
|
|
if (part.charCodeAt(0) === 36) {
|
|
output[0] = 1;
|
|
output[1] = start;
|
|
output[2] = start + 1;
|
|
output[3] = end;
|
|
output[4] = end;
|
|
output[5] = end;
|
|
return output;
|
|
}
|
|
const braces = getOpenAndCloseBraces(part);
|
|
if (braces) {
|
|
const [openBrace, closeBrace] = braces;
|
|
const firstChar = part.charCodeAt(openBrace + 1);
|
|
if (firstChar === 45) {
|
|
if (openBrace + 2 < part.length && part.charCodeAt(openBrace + 2) === 36) {
|
|
const paramStart = openBrace + 3;
|
|
const paramEnd = closeBrace;
|
|
if (paramStart < paramEnd) {
|
|
output[0] = 3;
|
|
output[1] = start + openBrace;
|
|
output[2] = start + paramStart;
|
|
output[3] = start + paramEnd;
|
|
output[4] = start + closeBrace + 1;
|
|
output[5] = end;
|
|
return output;
|
|
}
|
|
}
|
|
} else if (firstChar === 36) {
|
|
const dollarPos = openBrace + 1;
|
|
const afterDollar = openBrace + 2;
|
|
if (afterDollar === closeBrace) {
|
|
output[0] = 2;
|
|
output[1] = start + openBrace;
|
|
output[2] = start + dollarPos;
|
|
output[3] = start + afterDollar;
|
|
output[4] = start + closeBrace + 1;
|
|
output[5] = path.length;
|
|
return output;
|
|
}
|
|
output[0] = 1;
|
|
output[1] = start + openBrace;
|
|
output[2] = start + afterDollar;
|
|
output[3] = start + closeBrace;
|
|
output[4] = start + closeBrace + 1;
|
|
output[5] = end;
|
|
return output;
|
|
}
|
|
}
|
|
output[0] = 0;
|
|
output[1] = start;
|
|
output[2] = start;
|
|
output[3] = end;
|
|
output[4] = end;
|
|
output[5] = end;
|
|
return output;
|
|
}
|
|
function parseSegments(defaultCaseSensitive, data, route, start, node, depth, onRoute) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
|
|
onRoute == null ? void 0 : onRoute(route);
|
|
let cursor = start;
|
|
{
|
|
const path = route.fullPath ?? route.from;
|
|
const length = path.length;
|
|
const caseSensitive = ((_a = route.options) == null ? void 0 : _a.caseSensitive) ?? defaultCaseSensitive;
|
|
const skipOnParamError = !!(((_c = (_b = route.options) == null ? void 0 : _b.params) == null ? void 0 : _c.parse) && ((_e = (_d = route.options) == null ? void 0 : _d.skipRouteOnParseError) == null ? void 0 : _e.params));
|
|
while (cursor < length) {
|
|
const segment = parseSegment(path, cursor, data);
|
|
let nextNode;
|
|
const start2 = cursor;
|
|
const end = segment[5];
|
|
cursor = end + 1;
|
|
depth++;
|
|
switch (segment[0]) {
|
|
case 0: {
|
|
const value = path.substring(segment[2], segment[3]);
|
|
if (caseSensitive) {
|
|
const existingNode = (_f = node.static) == null ? void 0 : _f.get(value);
|
|
if (existingNode) nextNode = existingNode;
|
|
else {
|
|
node.static ?? (node.static = /* @__PURE__ */ new Map());
|
|
const next = createStaticNode(route.fullPath ?? route.from);
|
|
next.parent = node;
|
|
next.depth = depth;
|
|
nextNode = next;
|
|
node.static.set(value, next);
|
|
}
|
|
} else {
|
|
const name = value.toLowerCase();
|
|
const existingNode = (_g = node.staticInsensitive) == null ? void 0 : _g.get(name);
|
|
if (existingNode) nextNode = existingNode;
|
|
else {
|
|
node.staticInsensitive ?? (node.staticInsensitive = /* @__PURE__ */ new Map());
|
|
const next = createStaticNode(route.fullPath ?? route.from);
|
|
next.parent = node;
|
|
next.depth = depth;
|
|
nextNode = next;
|
|
node.staticInsensitive.set(name, next);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 1: {
|
|
const prefix_raw = path.substring(start2, segment[1]);
|
|
const suffix_raw = path.substring(segment[4], end);
|
|
const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
|
|
const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
|
|
const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
|
|
const existingNode = !skipOnParamError && ((_h = node.dynamic) == null ? void 0 : _h.find((s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix));
|
|
if (existingNode) nextNode = existingNode;
|
|
else {
|
|
const next = createDynamicNode(1, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
|
|
nextNode = next;
|
|
next.depth = depth;
|
|
next.parent = node;
|
|
node.dynamic ?? (node.dynamic = []);
|
|
node.dynamic.push(next);
|
|
}
|
|
break;
|
|
}
|
|
case 3: {
|
|
const prefix_raw = path.substring(start2, segment[1]);
|
|
const suffix_raw = path.substring(segment[4], end);
|
|
const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
|
|
const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
|
|
const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
|
|
const existingNode = !skipOnParamError && ((_i = node.optional) == null ? void 0 : _i.find((s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix));
|
|
if (existingNode) nextNode = existingNode;
|
|
else {
|
|
const next = createDynamicNode(3, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
|
|
nextNode = next;
|
|
next.parent = node;
|
|
next.depth = depth;
|
|
node.optional ?? (node.optional = []);
|
|
node.optional.push(next);
|
|
}
|
|
break;
|
|
}
|
|
case 2: {
|
|
const prefix_raw = path.substring(start2, segment[1]);
|
|
const suffix_raw = path.substring(segment[4], end);
|
|
const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
|
|
const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
|
|
const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
|
|
const next = createDynamicNode(2, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
|
|
nextNode = next;
|
|
next.parent = node;
|
|
next.depth = depth;
|
|
node.wildcard ?? (node.wildcard = []);
|
|
node.wildcard.push(next);
|
|
}
|
|
}
|
|
node = nextNode;
|
|
}
|
|
if (skipOnParamError && route.children && !route.isRoot && route.id && route.id.charCodeAt(route.id.lastIndexOf("/") + 1) === 95) {
|
|
const pathlessNode = createStaticNode(route.fullPath ?? route.from);
|
|
pathlessNode.kind = SEGMENT_TYPE_PATHLESS;
|
|
pathlessNode.parent = node;
|
|
depth++;
|
|
pathlessNode.depth = depth;
|
|
node.pathless ?? (node.pathless = []);
|
|
node.pathless.push(pathlessNode);
|
|
node = pathlessNode;
|
|
}
|
|
const isLeaf = (route.path || !route.children) && !route.isRoot;
|
|
if (isLeaf && path.endsWith("/")) {
|
|
const indexNode = createStaticNode(route.fullPath ?? route.from);
|
|
indexNode.kind = SEGMENT_TYPE_INDEX;
|
|
indexNode.parent = node;
|
|
depth++;
|
|
indexNode.depth = depth;
|
|
node.index = indexNode;
|
|
node = indexNode;
|
|
}
|
|
node.parse = ((_k = (_j = route.options) == null ? void 0 : _j.params) == null ? void 0 : _k.parse) ?? null;
|
|
node.skipOnParamError = skipOnParamError;
|
|
node.parsingPriority = ((_m = (_l = route.options) == null ? void 0 : _l.skipRouteOnParseError) == null ? void 0 : _m.priority) ?? 0;
|
|
if (isLeaf && !node.route) {
|
|
node.route = route;
|
|
node.fullPath = route.fullPath ?? route.from;
|
|
}
|
|
}
|
|
if (route.children) for (const child of route.children) parseSegments(defaultCaseSensitive, data, child, cursor, node, depth, onRoute);
|
|
}
|
|
function sortDynamic(a, b) {
|
|
if (a.skipOnParamError && !b.skipOnParamError) return -1;
|
|
if (!a.skipOnParamError && b.skipOnParamError) return 1;
|
|
if (a.skipOnParamError && b.skipOnParamError && (a.parsingPriority || b.parsingPriority)) return b.parsingPriority - a.parsingPriority;
|
|
if (a.prefix && b.prefix && a.prefix !== b.prefix) {
|
|
if (a.prefix.startsWith(b.prefix)) return -1;
|
|
if (b.prefix.startsWith(a.prefix)) return 1;
|
|
}
|
|
if (a.suffix && b.suffix && a.suffix !== b.suffix) {
|
|
if (a.suffix.endsWith(b.suffix)) return -1;
|
|
if (b.suffix.endsWith(a.suffix)) return 1;
|
|
}
|
|
if (a.prefix && !b.prefix) return -1;
|
|
if (!a.prefix && b.prefix) return 1;
|
|
if (a.suffix && !b.suffix) return -1;
|
|
if (!a.suffix && b.suffix) return 1;
|
|
if (a.caseSensitive && !b.caseSensitive) return -1;
|
|
if (!a.caseSensitive && b.caseSensitive) return 1;
|
|
return 0;
|
|
}
|
|
function sortTreeNodes(node) {
|
|
var _a, _b, _c;
|
|
if (node.pathless) for (const child of node.pathless) sortTreeNodes(child);
|
|
if (node.static) for (const child of node.static.values()) sortTreeNodes(child);
|
|
if (node.staticInsensitive) for (const child of node.staticInsensitive.values()) sortTreeNodes(child);
|
|
if ((_a = node.dynamic) == null ? void 0 : _a.length) {
|
|
node.dynamic.sort(sortDynamic);
|
|
for (const child of node.dynamic) sortTreeNodes(child);
|
|
}
|
|
if ((_b = node.optional) == null ? void 0 : _b.length) {
|
|
node.optional.sort(sortDynamic);
|
|
for (const child of node.optional) sortTreeNodes(child);
|
|
}
|
|
if ((_c = node.wildcard) == null ? void 0 : _c.length) {
|
|
node.wildcard.sort(sortDynamic);
|
|
for (const child of node.wildcard) sortTreeNodes(child);
|
|
}
|
|
}
|
|
function createStaticNode(fullPath) {
|
|
return {
|
|
kind: 0,
|
|
depth: 0,
|
|
pathless: null,
|
|
index: null,
|
|
static: null,
|
|
staticInsensitive: null,
|
|
dynamic: null,
|
|
optional: null,
|
|
wildcard: null,
|
|
route: null,
|
|
fullPath,
|
|
parent: null,
|
|
parse: null,
|
|
skipOnParamError: false,
|
|
parsingPriority: 0
|
|
};
|
|
}
|
|
function createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {
|
|
return {
|
|
kind,
|
|
depth: 0,
|
|
pathless: null,
|
|
index: null,
|
|
static: null,
|
|
staticInsensitive: null,
|
|
dynamic: null,
|
|
optional: null,
|
|
wildcard: null,
|
|
route: null,
|
|
fullPath,
|
|
parent: null,
|
|
parse: null,
|
|
skipOnParamError: false,
|
|
parsingPriority: 0,
|
|
caseSensitive,
|
|
prefix,
|
|
suffix
|
|
};
|
|
}
|
|
function processRouteMasks(routeList, processedTree) {
|
|
const segmentTree = createStaticNode("/");
|
|
const data = new Uint16Array(6);
|
|
for (const route of routeList) parseSegments(false, data, route, 1, segmentTree, 0);
|
|
sortTreeNodes(segmentTree);
|
|
processedTree.masksTree = segmentTree;
|
|
processedTree.flatCache = createLRUCache(1e3);
|
|
}
|
|
function findFlatMatch(path, processedTree) {
|
|
path || (path = "/");
|
|
const cached = processedTree.flatCache.get(path);
|
|
if (cached) return cached;
|
|
const result = findMatch(path, processedTree.masksTree);
|
|
processedTree.flatCache.set(path, result);
|
|
return result;
|
|
}
|
|
function findSingleMatch(from, caseSensitive, fuzzy, path, processedTree) {
|
|
from || (from = "/");
|
|
path || (path = "/");
|
|
const key = caseSensitive ? `case\0${from}` : from;
|
|
let tree = processedTree.singleCache.get(key);
|
|
if (!tree) {
|
|
tree = createStaticNode("/");
|
|
parseSegments(caseSensitive, new Uint16Array(6), { from }, 1, tree, 0);
|
|
processedTree.singleCache.set(key, tree);
|
|
}
|
|
return findMatch(path, tree, fuzzy);
|
|
}
|
|
function findRouteMatch(path, processedTree, fuzzy = false) {
|
|
const key = fuzzy ? path : `nofuzz\0${path}`;
|
|
const cached = processedTree.matchCache.get(key);
|
|
if (cached !== void 0) return cached;
|
|
path || (path = "/");
|
|
let result;
|
|
try {
|
|
result = findMatch(path, processedTree.segmentTree, fuzzy);
|
|
} catch (err) {
|
|
if (err instanceof URIError) result = null;
|
|
else throw err;
|
|
}
|
|
if (result) result.branch = buildRouteBranch(result.route);
|
|
processedTree.matchCache.set(key, result);
|
|
return result;
|
|
}
|
|
function trimPathRight(path) {
|
|
return path === "/" ? path : path.replace(/\/{1,}$/, "");
|
|
}
|
|
function processRouteTree(routeTree, caseSensitive = false, initRoute) {
|
|
const segmentTree = createStaticNode(routeTree.fullPath);
|
|
const data = new Uint16Array(6);
|
|
const routesById = {};
|
|
const routesByPath = {};
|
|
let index = 0;
|
|
parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, (route) => {
|
|
initRoute == null ? void 0 : initRoute(route, index);
|
|
if (route.id in routesById) {
|
|
if (true) throw new Error(`Invariant failed: Duplicate routes found with id: ${String(route.id)}`);
|
|
invariant();
|
|
}
|
|
routesById[route.id] = route;
|
|
if (index !== 0 && route.path) {
|
|
const trimmedFullPath = trimPathRight(route.fullPath);
|
|
if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith("/")) routesByPath[trimmedFullPath] = route;
|
|
}
|
|
index++;
|
|
});
|
|
sortTreeNodes(segmentTree);
|
|
return {
|
|
processedTree: {
|
|
segmentTree,
|
|
singleCache: createLRUCache(1e3),
|
|
matchCache: createLRUCache(1e3),
|
|
flatCache: null,
|
|
masksTree: null
|
|
},
|
|
routesById,
|
|
routesByPath
|
|
};
|
|
}
|
|
function findMatch(path, segmentTree, fuzzy = false) {
|
|
const parts = path.split("/");
|
|
const leaf = getNodeMatch(path, parts, segmentTree, fuzzy);
|
|
if (!leaf) return null;
|
|
const [rawParams] = extractParams(path, parts, leaf);
|
|
return {
|
|
route: leaf.node.route,
|
|
rawParams,
|
|
parsedParams: leaf.parsedParams
|
|
};
|
|
}
|
|
function extractParams(path, parts, leaf) {
|
|
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
|
|
const list = buildBranch(leaf.node);
|
|
let nodeParts = null;
|
|
const rawParams = /* @__PURE__ */ Object.create(null);
|
|
let partIndex = ((_a = leaf.extract) == null ? void 0 : _a.part) ?? 0;
|
|
let nodeIndex = ((_b = leaf.extract) == null ? void 0 : _b.node) ?? 0;
|
|
let pathIndex = ((_c = leaf.extract) == null ? void 0 : _c.path) ?? 0;
|
|
let segmentCount = ((_d = leaf.extract) == null ? void 0 : _d.segment) ?? 0;
|
|
for (; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++, segmentCount++) {
|
|
const node = list[nodeIndex];
|
|
if (node.kind === SEGMENT_TYPE_INDEX) break;
|
|
if (node.kind === SEGMENT_TYPE_PATHLESS) {
|
|
segmentCount--;
|
|
partIndex--;
|
|
pathIndex--;
|
|
continue;
|
|
}
|
|
const part = parts[partIndex];
|
|
const currentPathIndex = pathIndex;
|
|
if (part) pathIndex += part.length;
|
|
if (node.kind === 1) {
|
|
nodeParts ?? (nodeParts = leaf.node.fullPath.split("/"));
|
|
const nodePart = nodeParts[segmentCount];
|
|
const preLength = ((_e = node.prefix) == null ? void 0 : _e.length) ?? 0;
|
|
if (nodePart.charCodeAt(preLength) === 123) {
|
|
const sufLength = ((_f = node.suffix) == null ? void 0 : _f.length) ?? 0;
|
|
const name = nodePart.substring(preLength + 2, nodePart.length - sufLength - 1);
|
|
const value = part.substring(preLength, part.length - sufLength);
|
|
rawParams[name] = decodeURIComponent(value);
|
|
} else {
|
|
const name = nodePart.substring(1);
|
|
rawParams[name] = decodeURIComponent(part);
|
|
}
|
|
} else if (node.kind === 3) {
|
|
if (leaf.skipped & 1 << nodeIndex) {
|
|
partIndex--;
|
|
pathIndex = currentPathIndex - 1;
|
|
continue;
|
|
}
|
|
nodeParts ?? (nodeParts = leaf.node.fullPath.split("/"));
|
|
const nodePart = nodeParts[segmentCount];
|
|
const preLength = ((_g = node.prefix) == null ? void 0 : _g.length) ?? 0;
|
|
const sufLength = ((_h = node.suffix) == null ? void 0 : _h.length) ?? 0;
|
|
const name = nodePart.substring(preLength + 3, nodePart.length - sufLength - 1);
|
|
const value = node.suffix || node.prefix ? part.substring(preLength, part.length - sufLength) : part;
|
|
if (value) rawParams[name] = decodeURIComponent(value);
|
|
} else if (node.kind === 2) {
|
|
const n = node;
|
|
const value = path.substring(currentPathIndex + (((_i = n.prefix) == null ? void 0 : _i.length) ?? 0), path.length - (((_j = n.suffix) == null ? void 0 : _j.length) ?? 0));
|
|
const splat = decodeURIComponent(value);
|
|
rawParams["*"] = splat;
|
|
rawParams._splat = splat;
|
|
break;
|
|
}
|
|
}
|
|
if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams);
|
|
return [rawParams, {
|
|
part: partIndex,
|
|
node: nodeIndex,
|
|
path: pathIndex,
|
|
segment: segmentCount
|
|
}];
|
|
}
|
|
function buildRouteBranch(route) {
|
|
const list = [route];
|
|
while (route.parentRoute) {
|
|
route = route.parentRoute;
|
|
list.push(route);
|
|
}
|
|
list.reverse();
|
|
return list;
|
|
}
|
|
function buildBranch(node) {
|
|
const list = Array(node.depth + 1);
|
|
do {
|
|
list[node.depth] = node;
|
|
node = node.parent;
|
|
} while (node);
|
|
return list;
|
|
}
|
|
function getNodeMatch(path, parts, segmentTree, fuzzy) {
|
|
if (path === "/" && segmentTree.index) return {
|
|
node: segmentTree.index,
|
|
skipped: 0
|
|
};
|
|
const trailingSlash = !last(parts);
|
|
const pathIsIndex = trailingSlash && path !== "/";
|
|
const partsLength = parts.length - (trailingSlash ? 1 : 0);
|
|
const stack = [{
|
|
node: segmentTree,
|
|
index: 1,
|
|
skipped: 0,
|
|
depth: 1,
|
|
statics: 1,
|
|
dynamics: 0,
|
|
optionals: 0
|
|
}];
|
|
let wildcardMatch = null;
|
|
let bestFuzzy = null;
|
|
let bestMatch = null;
|
|
while (stack.length) {
|
|
const frame = stack.pop();
|
|
const { node, index, skipped, depth, statics, dynamics, optionals } = frame;
|
|
let { extract, rawParams, parsedParams } = frame;
|
|
if (node.skipOnParamError) {
|
|
if (!validateMatchParams(path, parts, frame)) continue;
|
|
rawParams = frame.rawParams;
|
|
extract = frame.extract;
|
|
parsedParams = frame.parsedParams;
|
|
}
|
|
if (fuzzy && node.route && node.kind !== SEGMENT_TYPE_INDEX && isFrameMoreSpecific(bestFuzzy, frame)) bestFuzzy = frame;
|
|
const isBeyondPath = index === partsLength;
|
|
if (isBeyondPath) {
|
|
if (node.route && !pathIsIndex && isFrameMoreSpecific(bestMatch, frame)) bestMatch = frame;
|
|
if (!node.optional && !node.wildcard && !node.index && !node.pathless) continue;
|
|
}
|
|
const part = isBeyondPath ? void 0 : parts[index];
|
|
let lowerPart;
|
|
if (isBeyondPath && node.index) {
|
|
const indexFrame = {
|
|
node: node.index,
|
|
index,
|
|
skipped,
|
|
depth: depth + 1,
|
|
statics,
|
|
dynamics,
|
|
optionals,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
};
|
|
let indexValid = true;
|
|
if (node.index.skipOnParamError) {
|
|
if (!validateMatchParams(path, parts, indexFrame)) indexValid = false;
|
|
}
|
|
if (indexValid) {
|
|
if (statics === partsLength && !dynamics && !optionals && !skipped) return indexFrame;
|
|
if (isFrameMoreSpecific(bestMatch, indexFrame)) bestMatch = indexFrame;
|
|
}
|
|
}
|
|
if (node.wildcard && isFrameMoreSpecific(wildcardMatch, frame)) for (const segment of node.wildcard) {
|
|
const { prefix, suffix } = segment;
|
|
if (prefix) {
|
|
if (isBeyondPath) continue;
|
|
if (!(segment.caseSensitive ? part : lowerPart ?? (lowerPart = part.toLowerCase())).startsWith(prefix)) continue;
|
|
}
|
|
if (suffix) {
|
|
if (isBeyondPath) continue;
|
|
const end = parts.slice(index).join("/").slice(-suffix.length);
|
|
if ((segment.caseSensitive ? end : end.toLowerCase()) !== suffix) continue;
|
|
}
|
|
const frame2 = {
|
|
node: segment,
|
|
index: partsLength,
|
|
skipped,
|
|
depth,
|
|
statics,
|
|
dynamics,
|
|
optionals,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
};
|
|
if (segment.skipOnParamError) {
|
|
if (!validateMatchParams(path, parts, frame2)) continue;
|
|
}
|
|
wildcardMatch = frame2;
|
|
break;
|
|
}
|
|
if (node.optional) {
|
|
const nextSkipped = skipped | 1 << depth;
|
|
const nextDepth = depth + 1;
|
|
for (let i = node.optional.length - 1; i >= 0; i--) {
|
|
const segment = node.optional[i];
|
|
stack.push({
|
|
node: segment,
|
|
index,
|
|
skipped: nextSkipped,
|
|
depth: nextDepth,
|
|
statics,
|
|
dynamics,
|
|
optionals,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
});
|
|
}
|
|
if (!isBeyondPath) for (let i = node.optional.length - 1; i >= 0; i--) {
|
|
const segment = node.optional[i];
|
|
const { prefix, suffix } = segment;
|
|
if (prefix || suffix) {
|
|
const casePart = segment.caseSensitive ? part : lowerPart ?? (lowerPart = part.toLowerCase());
|
|
if (prefix && !casePart.startsWith(prefix)) continue;
|
|
if (suffix && !casePart.endsWith(suffix)) continue;
|
|
}
|
|
stack.push({
|
|
node: segment,
|
|
index: index + 1,
|
|
skipped,
|
|
depth: nextDepth,
|
|
statics,
|
|
dynamics,
|
|
optionals: optionals + 1,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
});
|
|
}
|
|
}
|
|
if (!isBeyondPath && node.dynamic && part) for (let i = node.dynamic.length - 1; i >= 0; i--) {
|
|
const segment = node.dynamic[i];
|
|
const { prefix, suffix } = segment;
|
|
if (prefix || suffix) {
|
|
const casePart = segment.caseSensitive ? part : lowerPart ?? (lowerPart = part.toLowerCase());
|
|
if (prefix && !casePart.startsWith(prefix)) continue;
|
|
if (suffix && !casePart.endsWith(suffix)) continue;
|
|
}
|
|
stack.push({
|
|
node: segment,
|
|
index: index + 1,
|
|
skipped,
|
|
depth: depth + 1,
|
|
statics,
|
|
dynamics: dynamics + 1,
|
|
optionals,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
});
|
|
}
|
|
if (!isBeyondPath && node.staticInsensitive) {
|
|
const match = node.staticInsensitive.get(lowerPart ?? (lowerPart = part.toLowerCase()));
|
|
if (match) stack.push({
|
|
node: match,
|
|
index: index + 1,
|
|
skipped,
|
|
depth: depth + 1,
|
|
statics: statics + 1,
|
|
dynamics,
|
|
optionals,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
});
|
|
}
|
|
if (!isBeyondPath && node.static) {
|
|
const match = node.static.get(part);
|
|
if (match) stack.push({
|
|
node: match,
|
|
index: index + 1,
|
|
skipped,
|
|
depth: depth + 1,
|
|
statics: statics + 1,
|
|
dynamics,
|
|
optionals,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
});
|
|
}
|
|
if (node.pathless) {
|
|
const nextDepth = depth + 1;
|
|
for (let i = node.pathless.length - 1; i >= 0; i--) {
|
|
const segment = node.pathless[i];
|
|
stack.push({
|
|
node: segment,
|
|
index,
|
|
skipped,
|
|
depth: nextDepth,
|
|
statics,
|
|
dynamics,
|
|
optionals,
|
|
extract,
|
|
rawParams,
|
|
parsedParams
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (bestMatch && wildcardMatch) return isFrameMoreSpecific(wildcardMatch, bestMatch) ? bestMatch : wildcardMatch;
|
|
if (bestMatch) return bestMatch;
|
|
if (wildcardMatch) return wildcardMatch;
|
|
if (fuzzy && bestFuzzy) {
|
|
let sliceIndex = bestFuzzy.index;
|
|
for (let i = 0; i < bestFuzzy.index; i++) sliceIndex += parts[i].length;
|
|
const splat = sliceIndex === path.length ? "/" : path.slice(sliceIndex);
|
|
bestFuzzy.rawParams ?? (bestFuzzy.rawParams = /* @__PURE__ */ Object.create(null));
|
|
bestFuzzy.rawParams["**"] = decodeURIComponent(splat);
|
|
return bestFuzzy;
|
|
}
|
|
return null;
|
|
}
|
|
function validateMatchParams(path, parts, frame) {
|
|
try {
|
|
const [rawParams, state] = extractParams(path, parts, frame);
|
|
frame.rawParams = rawParams;
|
|
frame.extract = state;
|
|
const parsed = frame.node.parse(rawParams);
|
|
frame.parsedParams = Object.assign(/* @__PURE__ */ Object.create(null), frame.parsedParams, parsed);
|
|
return true;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
function isFrameMoreSpecific(prev, next) {
|
|
if (!prev) return true;
|
|
return next.statics > prev.statics || next.statics === prev.statics && (next.dynamics > prev.dynamics || next.dynamics === prev.dynamics && (next.optionals > prev.optionals || next.optionals === prev.optionals && ((next.node.kind === SEGMENT_TYPE_INDEX) > (prev.node.kind === SEGMENT_TYPE_INDEX) || next.node.kind === SEGMENT_TYPE_INDEX === (prev.node.kind === SEGMENT_TYPE_INDEX) && next.depth > prev.depth)));
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/path.js
|
|
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 trimPathRight2(path) {
|
|
const len = path.length;
|
|
return len > 1 && path[len - 1] === "/" ? path.replace(/\/{1,}$/, "") : path;
|
|
}
|
|
function trimPath(path) {
|
|
return trimPathRight2(trimPathLeft(path));
|
|
}
|
|
function removeTrailingSlash(value, basepath) {
|
|
if ((value == null ? void 0 : 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 resolvePath({ base, to, trailingSlash = "never", cache }) {
|
|
const isAbsolute = to.startsWith("/");
|
|
const isBase = !isAbsolute && to === ".";
|
|
let key;
|
|
if (cache) {
|
|
key = isAbsolute ? to : isBase ? base : base + "\0" + to;
|
|
const cached = cache.get(key);
|
|
if (cached) return cached;
|
|
}
|
|
let baseSegments;
|
|
if (isBase) baseSegments = base.split("/");
|
|
else if (isAbsolute) baseSegments = to.split("/");
|
|
else {
|
|
baseSegments = base.split("/");
|
|
while (baseSegments.length > 1 && last(baseSegments) === "") baseSegments.pop();
|
|
const toSegments = to.split("/");
|
|
for (let index = 0, length = toSegments.length; index < length; index++) {
|
|
const value = toSegments[index];
|
|
if (value === "") {
|
|
if (!index) baseSegments = [value];
|
|
else if (index === length - 1) baseSegments.push(value);
|
|
} else if (value === "..") baseSegments.pop();
|
|
else if (value === ".") {
|
|
} else baseSegments.push(value);
|
|
}
|
|
}
|
|
if (baseSegments.length > 1) {
|
|
if (last(baseSegments) === "") {
|
|
if (trailingSlash === "never") baseSegments.pop();
|
|
} else if (trailingSlash === "always") baseSegments.push("");
|
|
}
|
|
let segment;
|
|
let joined = "";
|
|
for (let i = 0; i < baseSegments.length; i++) {
|
|
if (i > 0) joined += "/";
|
|
const part = baseSegments[i];
|
|
if (!part) continue;
|
|
segment = parseSegment(part, 0, segment);
|
|
const kind = segment[0];
|
|
if (kind === 0) {
|
|
joined += part;
|
|
continue;
|
|
}
|
|
const end = segment[5];
|
|
const prefix = part.substring(0, segment[1]);
|
|
const suffix = part.substring(segment[4], end);
|
|
const value = part.substring(segment[2], segment[3]);
|
|
if (kind === 1) joined += prefix || suffix ? `${prefix}{$${value}}${suffix}` : `$${value}`;
|
|
else if (kind === 2) joined += prefix || suffix ? `${prefix}{$}${suffix}` : "$";
|
|
else joined += `${prefix}{-$${value}}${suffix}`;
|
|
}
|
|
joined = cleanPath(joined);
|
|
const result = joined || "/";
|
|
if (key && cache) cache.set(key, result);
|
|
return result;
|
|
}
|
|
function compileDecodeCharMap(pathParamsAllowedCharacters) {
|
|
const charMap = new Map(pathParamsAllowedCharacters.map((char) => [encodeURIComponent(char), char]));
|
|
const pattern = Array.from(charMap.keys()).map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
|
|
const regex = new RegExp(pattern, "g");
|
|
return (encoded) => encoded.replace(regex, (match) => charMap.get(match) ?? match);
|
|
}
|
|
function encodeParam(key, params, decoder) {
|
|
const value = params[key];
|
|
if (typeof value !== "string") return value;
|
|
if (key === "_splat") {
|
|
if (/^[a-zA-Z0-9\-._~!/]*$/.test(value)) return value;
|
|
return value.split("/").map((segment) => encodePathParam(segment, decoder)).join("/");
|
|
} else return encodePathParam(value, decoder);
|
|
}
|
|
function interpolatePath({ path, params, decoder, ...rest }) {
|
|
let isMissingParams = false;
|
|
const usedParams = /* @__PURE__ */ Object.create(null);
|
|
if (!path || path === "/") return {
|
|
interpolatedPath: "/",
|
|
usedParams,
|
|
isMissingParams
|
|
};
|
|
if (!path.includes("$")) return {
|
|
interpolatedPath: path,
|
|
usedParams,
|
|
isMissingParams
|
|
};
|
|
if (isServer ?? rest.server) {
|
|
if (path.indexOf("{") === -1) {
|
|
const length2 = path.length;
|
|
let cursor2 = 0;
|
|
let joined2 = "";
|
|
while (cursor2 < length2) {
|
|
while (cursor2 < length2 && path.charCodeAt(cursor2) === 47) cursor2++;
|
|
if (cursor2 >= length2) break;
|
|
const start = cursor2;
|
|
let end = path.indexOf("/", cursor2);
|
|
if (end === -1) end = length2;
|
|
cursor2 = end;
|
|
const part = path.substring(start, end);
|
|
if (!part) continue;
|
|
if (part.charCodeAt(0) === 36) if (part.length === 1) {
|
|
const splat = params._splat;
|
|
usedParams._splat = splat;
|
|
usedParams["*"] = splat;
|
|
if (!splat) {
|
|
isMissingParams = true;
|
|
continue;
|
|
}
|
|
const value = encodeParam("_splat", params, decoder);
|
|
joined2 += "/" + value;
|
|
} else {
|
|
const key = part.substring(1);
|
|
if (!isMissingParams && !(key in params)) isMissingParams = true;
|
|
usedParams[key] = params[key];
|
|
const value = encodeParam(key, params, decoder) ?? "undefined";
|
|
joined2 += "/" + value;
|
|
}
|
|
else joined2 += "/" + part;
|
|
}
|
|
if (path.endsWith("/")) joined2 += "/";
|
|
return {
|
|
usedParams,
|
|
interpolatedPath: joined2 || "/",
|
|
isMissingParams
|
|
};
|
|
}
|
|
}
|
|
const length = path.length;
|
|
let cursor = 0;
|
|
let segment;
|
|
let joined = "";
|
|
while (cursor < length) {
|
|
const start = cursor;
|
|
segment = parseSegment(path, start, segment);
|
|
const end = segment[5];
|
|
cursor = end + 1;
|
|
if (start === end) continue;
|
|
const kind = segment[0];
|
|
if (kind === 0) {
|
|
joined += "/" + path.substring(start, end);
|
|
continue;
|
|
}
|
|
if (kind === 2) {
|
|
const splat = params._splat;
|
|
usedParams._splat = splat;
|
|
usedParams["*"] = splat;
|
|
const prefix = path.substring(start, segment[1]);
|
|
const suffix = path.substring(segment[4], end);
|
|
if (!splat) {
|
|
isMissingParams = true;
|
|
if (prefix || suffix) joined += "/" + prefix + suffix;
|
|
continue;
|
|
}
|
|
const value = encodeParam("_splat", params, decoder);
|
|
joined += "/" + prefix + value + suffix;
|
|
continue;
|
|
}
|
|
if (kind === 1) {
|
|
const key = path.substring(segment[2], segment[3]);
|
|
if (!isMissingParams && !(key in params)) isMissingParams = true;
|
|
usedParams[key] = params[key];
|
|
const prefix = path.substring(start, segment[1]);
|
|
const suffix = path.substring(segment[4], end);
|
|
const value = encodeParam(key, params, decoder) ?? "undefined";
|
|
joined += "/" + prefix + value + suffix;
|
|
continue;
|
|
}
|
|
if (kind === 3) {
|
|
const key = path.substring(segment[2], segment[3]);
|
|
const valueRaw = params[key];
|
|
if (valueRaw == null) continue;
|
|
usedParams[key] = valueRaw;
|
|
const prefix = path.substring(start, segment[1]);
|
|
const suffix = path.substring(segment[4], end);
|
|
const value = encodeParam(key, params, decoder) ?? "";
|
|
joined += "/" + prefix + value + suffix;
|
|
continue;
|
|
}
|
|
}
|
|
if (path.endsWith("/")) joined += "/";
|
|
return {
|
|
usedParams,
|
|
interpolatedPath: joined || "/",
|
|
isMissingParams
|
|
};
|
|
}
|
|
function encodePathParam(value, decoder) {
|
|
const encoded = encodeURIComponent(value);
|
|
return (decoder == null ? void 0 : decoder(encoded)) ?? encoded;
|
|
}
|
|
|
|
// 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 == null ? void 0 : obj.isNotFound) === true;
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/scroll-restoration.js
|
|
function getSafeSessionStorage() {
|
|
try {
|
|
return typeof window !== "undefined" && typeof window.sessionStorage === "object" ? window.sessionStorage : void 0;
|
|
} catch {
|
|
return;
|
|
}
|
|
}
|
|
var storageKey = "tsr-scroll-restoration-v1_3";
|
|
function createScrollRestorationCache() {
|
|
const safeSessionStorage = getSafeSessionStorage();
|
|
if (!safeSessionStorage) return null;
|
|
let state = {};
|
|
try {
|
|
const parsed = JSON.parse(safeSessionStorage.getItem("tsr-scroll-restoration-v1_3") || "{}");
|
|
if (isPlainObject(parsed)) state = parsed;
|
|
} catch {
|
|
}
|
|
const persist = () => {
|
|
try {
|
|
safeSessionStorage.setItem(storageKey, JSON.stringify(state));
|
|
} catch {
|
|
if (true) console.warn("[ts-router] Could not persist scroll restoration state to sessionStorage.");
|
|
}
|
|
};
|
|
return {
|
|
get state() {
|
|
return state;
|
|
},
|
|
set: (updater) => {
|
|
state = functionalUpdate(updater, state) || state;
|
|
},
|
|
persist
|
|
};
|
|
}
|
|
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();
|
|
}
|
|
function getElementScrollRestorationEntry(router, options) {
|
|
var _a, _b, _c;
|
|
const restoreKey = (options.getKey || defaultGetScrollRestorationKey)(router.latestLocation);
|
|
if (options.id) return (_a = scrollRestorationCache == null ? void 0 : scrollRestorationCache.state[restoreKey]) == null ? void 0 : _a[`[${scrollRestorationIdAttribute}="${options.id}"]`];
|
|
const element = (_b = options.getElement) == null ? void 0 : _b.call(options);
|
|
if (!element) return;
|
|
return (_c = scrollRestorationCache == null ? void 0 : scrollRestorationCache.state[restoreKey]) == null ? void 0 : _c[element instanceof Window ? windowScrollTarget : getCssSelector(element)];
|
|
}
|
|
var ignoreScroll = false;
|
|
var windowScrollTarget = "window";
|
|
var scrollRestorationIdAttribute = "data-scroll-restoration-id";
|
|
function setupScrollRestoration(router, force) {
|
|
if (!scrollRestorationCache && !(isServer ?? router.isServer)) return;
|
|
const cache = scrollRestorationCache;
|
|
if (force ?? router.options.scrollRestoration ?? false) router.isScrollRestoring = true;
|
|
if ((isServer ?? router.isServer) || router.isScrollRestorationSetup || !cache) return;
|
|
router.isScrollRestorationSetup = true;
|
|
ignoreScroll = false;
|
|
const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
|
|
const trackedScrollEntries = /* @__PURE__ */ new Map();
|
|
window.history.scrollRestoration = "manual";
|
|
const onScroll = (event) => {
|
|
if (ignoreScroll || !router.isScrollRestoring) return;
|
|
if (event.target === document || event.target === window) trackedScrollEntries.set(windowScrollTarget, {
|
|
scrollX: window.scrollX || 0,
|
|
scrollY: window.scrollY || 0
|
|
});
|
|
else {
|
|
const target = event.target;
|
|
trackedScrollEntries.set(target, {
|
|
scrollX: target.scrollLeft || 0,
|
|
scrollY: target.scrollTop || 0
|
|
});
|
|
}
|
|
};
|
|
const snapshotCurrentScrollTargets = (restoreKey) => {
|
|
var _a;
|
|
if (!router.isScrollRestoring || !restoreKey || trackedScrollEntries.size === 0 || !cache) return;
|
|
const keyEntry = (_a = cache.state)[restoreKey] || (_a[restoreKey] = {});
|
|
for (const [target, position] of trackedScrollEntries) {
|
|
let selector;
|
|
if (target === windowScrollTarget) selector = windowScrollTarget;
|
|
else if (target.isConnected) {
|
|
const attrId = target.getAttribute(scrollRestorationIdAttribute);
|
|
selector = attrId ? `[${scrollRestorationIdAttribute}="${attrId}"]` : getCssSelector(target);
|
|
}
|
|
if (!selector) continue;
|
|
keyEntry[selector] = position;
|
|
}
|
|
};
|
|
document.addEventListener("scroll", onScroll, true);
|
|
router.subscribe("onBeforeLoad", (event) => {
|
|
snapshotCurrentScrollTargets(event.fromLocation ? getKey(event.fromLocation) : void 0);
|
|
trackedScrollEntries.clear();
|
|
});
|
|
window.addEventListener("pagehide", () => {
|
|
snapshotCurrentScrollTargets(getKey(router.stores.resolvedLocation.get() ?? router.stores.location.get()));
|
|
cache.persist();
|
|
});
|
|
router.subscribe("onRendered", (event) => {
|
|
var _a;
|
|
const cacheKey = getKey(event.toLocation);
|
|
const behavior = router.options.scrollRestorationBehavior;
|
|
const scrollToTopSelectors = router.options.scrollToTopSelectors;
|
|
trackedScrollEntries.clear();
|
|
if (!router.resetNextScroll) {
|
|
router.resetNextScroll = true;
|
|
return;
|
|
}
|
|
if (typeof router.options.scrollRestoration === "function" && !router.options.scrollRestoration({ location: router.latestLocation })) return;
|
|
ignoreScroll = true;
|
|
try {
|
|
const elementEntries = router.isScrollRestoring ? cache.state[cacheKey] : void 0;
|
|
let restored = false;
|
|
if (elementEntries) for (const elementSelector in elementEntries) {
|
|
const entry = elementEntries[elementSelector];
|
|
if (!isPlainObject(entry)) continue;
|
|
const { scrollX, scrollY } = entry;
|
|
if (!Number.isFinite(scrollX) || !Number.isFinite(scrollY)) continue;
|
|
if (elementSelector === windowScrollTarget) {
|
|
window.scrollTo({
|
|
top: scrollY,
|
|
left: scrollX,
|
|
behavior
|
|
});
|
|
restored = true;
|
|
} else if (elementSelector) {
|
|
let element;
|
|
try {
|
|
element = document.querySelector(elementSelector);
|
|
} catch {
|
|
continue;
|
|
}
|
|
if (element) {
|
|
element.scrollLeft = scrollX;
|
|
element.scrollTop = scrollY;
|
|
restored = true;
|
|
}
|
|
}
|
|
}
|
|
if (!restored) {
|
|
const hash = router.history.location.hash.slice(1);
|
|
if (hash) {
|
|
const hashScrollIntoViewOptions = ((_a = window.history.state) == null ? void 0 : _a.__hashScrollIntoViewOptions) ?? true;
|
|
if (hashScrollIntoViewOptions) {
|
|
const el = document.getElementById(hash);
|
|
if (el) el.scrollIntoView(hashScrollIntoViewOptions);
|
|
}
|
|
} else {
|
|
const scrollOptions = {
|
|
top: 0,
|
|
left: 0,
|
|
behavior
|
|
};
|
|
window.scrollTo(scrollOptions);
|
|
if (scrollToTopSelectors) for (const selector of scrollToTopSelectors) {
|
|
if (selector === windowScrollTarget) continue;
|
|
const element = typeof selector === "function" ? selector() : document.querySelector(selector);
|
|
if (element) element.scrollTo(scrollOptions);
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
ignoreScroll = false;
|
|
}
|
|
if (router.isScrollRestoring) cache.set((state) => {
|
|
state[cacheKey] || (state[cacheKey] = {});
|
|
return state;
|
|
});
|
|
});
|
|
}
|
|
|
|
// 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 = /* @__PURE__ */ Object.create(null);
|
|
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._builtLocation && !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/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) {
|
|
var _a;
|
|
const res = (_a = rewrite == null ? void 0 : rewrite.input) == null ? void 0 : _a.call(rewrite, { url });
|
|
if (res) {
|
|
if (typeof res === "string") return new URL(res);
|
|
else if (res instanceof URL) return res;
|
|
}
|
|
return url;
|
|
}
|
|
function executeRewriteOutput(rewrite, url) {
|
|
var _a;
|
|
const res = (_a = rewrite == null ? void 0 : rewrite.output) == null ? void 0 : _a.call(rewrite, { 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/stores.js
|
|
function createNonReactiveMutableStore(initialValue) {
|
|
let value = initialValue;
|
|
return {
|
|
get() {
|
|
return value;
|
|
},
|
|
set(nextOrUpdater) {
|
|
value = functionalUpdate(nextOrUpdater, value);
|
|
}
|
|
};
|
|
}
|
|
function createNonReactiveReadonlyStore(read) {
|
|
return { get() {
|
|
return read();
|
|
} };
|
|
}
|
|
function createRouterStores(initialState, config) {
|
|
const { createMutableStore, createReadonlyStore, batch: batch2, init } = config;
|
|
const matchStores = /* @__PURE__ */ new Map();
|
|
const pendingMatchStores = /* @__PURE__ */ new Map();
|
|
const cachedMatchStores = /* @__PURE__ */ new Map();
|
|
const status = createMutableStore(initialState.status);
|
|
const loadedAt = createMutableStore(initialState.loadedAt);
|
|
const isLoading = createMutableStore(initialState.isLoading);
|
|
const isTransitioning = createMutableStore(initialState.isTransitioning);
|
|
const location = createMutableStore(initialState.location);
|
|
const resolvedLocation = createMutableStore(initialState.resolvedLocation);
|
|
const statusCode = createMutableStore(initialState.statusCode);
|
|
const redirect2 = createMutableStore(initialState.redirect);
|
|
const matchesId = createMutableStore([]);
|
|
const pendingIds = createMutableStore([]);
|
|
const cachedIds = createMutableStore([]);
|
|
const matches = createReadonlyStore(() => readPoolMatches(matchStores, matchesId.get()));
|
|
const pendingMatches = createReadonlyStore(() => readPoolMatches(pendingMatchStores, pendingIds.get()));
|
|
const cachedMatches = createReadonlyStore(() => readPoolMatches(cachedMatchStores, cachedIds.get()));
|
|
const firstId = createReadonlyStore(() => matchesId.get()[0]);
|
|
const hasPending = createReadonlyStore(() => matchesId.get().some((matchId) => {
|
|
var _a;
|
|
return ((_a = matchStores.get(matchId)) == null ? void 0 : _a.get().status) === "pending";
|
|
}));
|
|
const matchRouteDeps = createReadonlyStore(() => {
|
|
var _a;
|
|
return {
|
|
locationHref: location.get().href,
|
|
resolvedLocationHref: (_a = resolvedLocation.get()) == null ? void 0 : _a.href,
|
|
status: status.get()
|
|
};
|
|
});
|
|
const __store = createReadonlyStore(() => ({
|
|
status: status.get(),
|
|
loadedAt: loadedAt.get(),
|
|
isLoading: isLoading.get(),
|
|
isTransitioning: isTransitioning.get(),
|
|
matches: matches.get(),
|
|
location: location.get(),
|
|
resolvedLocation: resolvedLocation.get(),
|
|
statusCode: statusCode.get(),
|
|
redirect: redirect2.get()
|
|
}));
|
|
const matchStoreByRouteIdCache = createLRUCache(64);
|
|
function getRouteMatchStore(routeId) {
|
|
let cached = matchStoreByRouteIdCache.get(routeId);
|
|
if (!cached) {
|
|
cached = createReadonlyStore(() => {
|
|
const ids = matchesId.get();
|
|
for (const id of ids) {
|
|
const matchStore = matchStores.get(id);
|
|
if (matchStore && matchStore.routeId === routeId) return matchStore.get();
|
|
}
|
|
});
|
|
matchStoreByRouteIdCache.set(routeId, cached);
|
|
}
|
|
return cached;
|
|
}
|
|
const store = {
|
|
status,
|
|
loadedAt,
|
|
isLoading,
|
|
isTransitioning,
|
|
location,
|
|
resolvedLocation,
|
|
statusCode,
|
|
redirect: redirect2,
|
|
matchesId,
|
|
pendingIds,
|
|
cachedIds,
|
|
matches,
|
|
pendingMatches,
|
|
cachedMatches,
|
|
firstId,
|
|
hasPending,
|
|
matchRouteDeps,
|
|
matchStores,
|
|
pendingMatchStores,
|
|
cachedMatchStores,
|
|
__store,
|
|
getRouteMatchStore,
|
|
setMatches,
|
|
setPending,
|
|
setCached
|
|
};
|
|
setMatches(initialState.matches);
|
|
init == null ? void 0 : init(store);
|
|
function setMatches(nextMatches) {
|
|
reconcileMatchPool(nextMatches, matchStores, matchesId, createMutableStore, batch2);
|
|
}
|
|
function setPending(nextMatches) {
|
|
reconcileMatchPool(nextMatches, pendingMatchStores, pendingIds, createMutableStore, batch2);
|
|
}
|
|
function setCached(nextMatches) {
|
|
reconcileMatchPool(nextMatches, cachedMatchStores, cachedIds, createMutableStore, batch2);
|
|
}
|
|
return store;
|
|
}
|
|
function readPoolMatches(pool, ids) {
|
|
const matches = [];
|
|
for (const id of ids) {
|
|
const matchStore = pool.get(id);
|
|
if (matchStore) matches.push(matchStore.get());
|
|
}
|
|
return matches;
|
|
}
|
|
function reconcileMatchPool(nextMatches, pool, idStore, createMutableStore, batch2) {
|
|
const nextIds = nextMatches.map((d) => d.id);
|
|
const nextIdSet = new Set(nextIds);
|
|
batch2(() => {
|
|
for (const id of pool.keys()) if (!nextIdSet.has(id)) pool.delete(id);
|
|
for (const nextMatch of nextMatches) {
|
|
const existing = pool.get(nextMatch.id);
|
|
if (!existing) {
|
|
const matchStore = createMutableStore(nextMatch);
|
|
matchStore.routeId = nextMatch.routeId;
|
|
pool.set(nextMatch.id, matchStore);
|
|
continue;
|
|
}
|
|
existing.routeId = nextMatch.routeId;
|
|
if (existing.get() !== nextMatch) existing.set(nextMatch);
|
|
}
|
|
if (!arraysEqual(idStore.get(), nextIds)) idStore.set(nextIds);
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/load-matches.js
|
|
var triggerOnReady = (inner) => {
|
|
var _a;
|
|
if (!inner.rendered) {
|
|
inner.rendered = true;
|
|
return (_a = inner.onReady) == null ? void 0 : _a.call(inner);
|
|
}
|
|
};
|
|
var hasForcePendingActiveMatch = (router) => {
|
|
return router.stores.matchesId.get().some((matchId) => {
|
|
var _a;
|
|
return (_a = router.stores.matchStores.get(matchId)) == null ? void 0 : _a.get()._forcePending;
|
|
});
|
|
};
|
|
var resolvePreload = (inner, matchId) => {
|
|
return !!(inner.preload && !inner.router.stores.matchStores.has(matchId));
|
|
};
|
|
var buildMatchContext = (inner, index, includeCurrentMatch = true) => {
|
|
const context = { ...inner.router.options.context ?? {} };
|
|
const end = includeCurrentMatch ? index : index - 1;
|
|
for (let i = 0; i <= end; i++) {
|
|
const innerMatch = inner.matches[i];
|
|
if (!innerMatch) continue;
|
|
const m = inner.router.getMatch(innerMatch.id);
|
|
if (!m) continue;
|
|
Object.assign(context, m.__routeContext, m.__beforeLoadContext);
|
|
}
|
|
return context;
|
|
};
|
|
var getNotFoundBoundaryIndex = (inner, err) => {
|
|
if (!inner.matches.length) return;
|
|
const requestedRouteId = err.routeId;
|
|
const matchedRootIndex = inner.matches.findIndex((m) => m.routeId === inner.router.routeTree.id);
|
|
const rootIndex = matchedRootIndex >= 0 ? matchedRootIndex : 0;
|
|
let startIndex = requestedRouteId ? inner.matches.findIndex((match) => match.routeId === requestedRouteId) : inner.firstBadMatchIndex ?? inner.matches.length - 1;
|
|
if (startIndex < 0) startIndex = rootIndex;
|
|
for (let i = startIndex; i >= 0; i--) {
|
|
const match = inner.matches[i];
|
|
if (inner.router.looseRoutesById[match.routeId].options.notFoundComponent) return i;
|
|
}
|
|
return requestedRouteId ? startIndex : rootIndex;
|
|
};
|
|
var handleRedirectAndNotFound = (inner, match, err) => {
|
|
var _a, _b, _c;
|
|
if (!isRedirect(err) && !isNotFound(err)) return;
|
|
if (isRedirect(err) && err.redirectHandled && !err.options.reloadDocument) throw err;
|
|
if (match) {
|
|
(_a = match._nonReactive.beforeLoadPromise) == null ? void 0 : _a.resolve();
|
|
(_b = match._nonReactive.loaderPromise) == null ? void 0 : _b.resolve();
|
|
match._nonReactive.beforeLoadPromise = void 0;
|
|
match._nonReactive.loaderPromise = void 0;
|
|
match._nonReactive.error = err;
|
|
inner.updateMatch(match.id, (prev) => ({
|
|
...prev,
|
|
status: isRedirect(err) ? "redirected" : isNotFound(err) ? "notFound" : prev.status === "pending" ? "success" : prev.status,
|
|
context: buildMatchContext(inner, match.index),
|
|
isFetching: false,
|
|
error: err
|
|
}));
|
|
if (isNotFound(err) && !err.routeId) err.routeId = match.routeId;
|
|
(_c = match._nonReactive.loadPromise) == null ? void 0 : _c.resolve();
|
|
}
|
|
if (isRedirect(err)) {
|
|
inner.rendered = true;
|
|
err.options._fromLocation = inner.location;
|
|
err.redirectHandled = true;
|
|
err = inner.router.resolveRedirect(err);
|
|
}
|
|
throw err;
|
|
};
|
|
var shouldSkipLoader = (inner, matchId) => {
|
|
const match = inner.router.getMatch(matchId);
|
|
if (!match) return true;
|
|
if (!(isServer ?? inner.router.isServer) && match._nonReactive.dehydrated) return true;
|
|
if ((isServer ?? inner.router.isServer) && match.ssr === false) return true;
|
|
return false;
|
|
};
|
|
var syncMatchContext = (inner, matchId, index) => {
|
|
const nextContext = buildMatchContext(inner, index);
|
|
inner.updateMatch(matchId, (prev) => {
|
|
return {
|
|
...prev,
|
|
context: nextContext
|
|
};
|
|
});
|
|
};
|
|
var handleSerialError = (inner, index, err, routerCode) => {
|
|
var _a, _b;
|
|
const { id: matchId, routeId } = inner.matches[index];
|
|
const route = inner.router.looseRoutesById[routeId];
|
|
if (err instanceof Promise) throw err;
|
|
err.routerCode = routerCode;
|
|
inner.firstBadMatchIndex ?? (inner.firstBadMatchIndex = index);
|
|
handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
|
|
try {
|
|
(_b = (_a = route.options).onError) == null ? void 0 : _b.call(_a, err);
|
|
} catch (errorHandlerErr) {
|
|
err = errorHandlerErr;
|
|
handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
|
|
}
|
|
inner.updateMatch(matchId, (prev) => {
|
|
var _a2, _b2;
|
|
(_a2 = prev._nonReactive.beforeLoadPromise) == null ? void 0 : _a2.resolve();
|
|
prev._nonReactive.beforeLoadPromise = void 0;
|
|
(_b2 = prev._nonReactive.loadPromise) == null ? void 0 : _b2.resolve();
|
|
return {
|
|
...prev,
|
|
error: err,
|
|
status: "error",
|
|
isFetching: false,
|
|
updatedAt: Date.now(),
|
|
abortController: new AbortController()
|
|
};
|
|
});
|
|
if (!inner.preload && !isRedirect(err) && !isNotFound(err)) inner.serialError ?? (inner.serialError = err);
|
|
};
|
|
var isBeforeLoadSsr = (inner, matchId, index, route) => {
|
|
var _a;
|
|
const existingMatch = inner.router.getMatch(matchId);
|
|
const parentMatchId = (_a = inner.matches[index - 1]) == null ? void 0 : _a.id;
|
|
const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0;
|
|
if (inner.router.isShell()) {
|
|
existingMatch.ssr = route.id === rootRouteId;
|
|
return;
|
|
}
|
|
if ((parentMatch == null ? void 0 : parentMatch.ssr) === false) {
|
|
existingMatch.ssr = false;
|
|
return;
|
|
}
|
|
const parentOverride = (tempSsr2) => {
|
|
if (tempSsr2 === true && (parentMatch == null ? void 0 : 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);
|
|
};
|
|
var setupPendingTimeout = (inner, matchId, route, match) => {
|
|
var _a;
|
|
if (match._nonReactive.pendingTimeout !== void 0) return;
|
|
const pendingMs = route.options.pendingMs ?? inner.router.options.defaultPendingMs;
|
|
if (!!(inner.onReady && !(isServer ?? inner.router.isServer) && !resolvePreload(inner, matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? ((_a = inner.router.options) == null ? void 0 : _a.defaultPendingComponent)))) {
|
|
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);
|
|
let prevLoadPromise = match._nonReactive.loadPromise;
|
|
match._nonReactive.loadPromise = createControlledPromise(() => {
|
|
prevLoadPromise == null ? void 0 : prevLoadPromise.resolve();
|
|
prevLoadPromise = void 0;
|
|
});
|
|
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();
|
|
let isPending = false;
|
|
const pending = () => {
|
|
if (isPending) return;
|
|
isPending = true;
|
|
inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
isFetching: "beforeLoad",
|
|
fetchCount: prev.fetchCount + 1,
|
|
abortController
|
|
}));
|
|
};
|
|
const resolve = () => {
|
|
var _a;
|
|
(_a = match._nonReactive.beforeLoadPromise) == null ? void 0 : _a.resolve();
|
|
match._nonReactive.beforeLoadPromise = void 0;
|
|
inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
isFetching: false
|
|
}));
|
|
};
|
|
if (!route.options.beforeLoad) {
|
|
inner.router.batch(() => {
|
|
pending();
|
|
resolve();
|
|
});
|
|
return;
|
|
}
|
|
match._nonReactive.beforeLoadPromise = createControlledPromise();
|
|
const context = {
|
|
...buildMatchContext(inner, index, false),
|
|
...match.__routeContext
|
|
};
|
|
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,
|
|
routeId: route.id,
|
|
...inner.router.options.additionalContext
|
|
};
|
|
const updateContext = (beforeLoadContext2) => {
|
|
if (beforeLoadContext2 === void 0) {
|
|
inner.router.batch(() => {
|
|
pending();
|
|
resolve();
|
|
});
|
|
return;
|
|
}
|
|
if (isRedirect(beforeLoadContext2) || isNotFound(beforeLoadContext2)) {
|
|
pending();
|
|
handleSerialError(inner, index, beforeLoadContext2, "BEFORE_LOAD");
|
|
}
|
|
inner.router.batch(() => {
|
|
pending();
|
|
inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
__beforeLoadContext: 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);
|
|
};
|
|
var handleBeforeLoad = (inner, index) => {
|
|
const { id: matchId, routeId } = inner.matches[index];
|
|
const route = inner.router.looseRoutesById[routeId];
|
|
const serverSsr = () => {
|
|
if (isServer ?? 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) => {
|
|
var _a, _b, _c, _d, _e, _f;
|
|
const match = inner.router.getMatch(matchId);
|
|
if (!match) return;
|
|
if (!route.options.head && !route.options.scripts && !route.options.headers) return;
|
|
const assetContext = {
|
|
ssr: inner.router.options.ssr,
|
|
matches: inner.matches,
|
|
match,
|
|
params: match.params,
|
|
loaderData: match.loaderData
|
|
};
|
|
return Promise.all([
|
|
(_b = (_a = route.options).head) == null ? void 0 : _b.call(_a, assetContext),
|
|
(_d = (_c = route.options).scripts) == null ? void 0 : _d.call(_c, assetContext),
|
|
(_f = (_e = route.options).headers) == null ? void 0 : _f.call(_e, assetContext)
|
|
]).then(([headFnContent, scripts, headers]) => {
|
|
return {
|
|
meta: headFnContent == null ? void 0 : headFnContent.meta,
|
|
links: headFnContent == null ? void 0 : headFnContent.links,
|
|
headScripts: headFnContent == null ? void 0 : headFnContent.scripts,
|
|
headers,
|
|
scripts,
|
|
styles: headFnContent == null ? void 0 : headFnContent.styles
|
|
};
|
|
});
|
|
};
|
|
var getLoaderContext = (inner, matchPromises, matchId, index, route) => {
|
|
const parentMatchPromise = matchPromises[index - 1];
|
|
const { params, loaderDeps, abortController, cause } = inner.router.getMatch(matchId);
|
|
const context = buildMatchContext(inner, index);
|
|
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, matchPromises, matchId, index, route) => {
|
|
var _a, _b, _c, _d, _e;
|
|
try {
|
|
const match = inner.router.getMatch(matchId);
|
|
try {
|
|
if (!(isServer ?? inner.router.isServer) || match.ssr === true) loadRouteChunk(route);
|
|
const routeLoader = route.options.loader;
|
|
const loader = typeof routeLoader === "function" ? routeLoader : routeLoader == null ? void 0 : routeLoader.handler;
|
|
const loaderResult = loader == null ? void 0 : loader(getLoaderContext(inner, matchPromises, matchId, index, route));
|
|
const loaderResultIsPromise = !!loader && isPromise(loaderResult);
|
|
if (!!(loaderResultIsPromise || route._lazyPromise || route._componentsPromise || route.options.head || route.options.scripts || route.options.headers || match._nonReactive.minPendingPromise)) inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
isFetching: "loader"
|
|
}));
|
|
if (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 pendingPromise = match._nonReactive.minPendingPromise;
|
|
if (pendingPromise) await pendingPromise;
|
|
if (route._componentsPromise) await route._componentsPromise;
|
|
inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
error: void 0,
|
|
context: buildMatchContext(inner, index),
|
|
status: "success",
|
|
isFetching: false,
|
|
updatedAt: Date.now()
|
|
}));
|
|
} catch (e) {
|
|
let error = e;
|
|
if ((error == null ? void 0 : error.name) === "AbortError") {
|
|
if (match.abortController.signal.aborted) {
|
|
(_a = match._nonReactive.loaderPromise) == null ? void 0 : _a.resolve();
|
|
match._nonReactive.loaderPromise = void 0;
|
|
return;
|
|
}
|
|
inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
status: prev.status === "pending" ? "success" : prev.status,
|
|
isFetching: false,
|
|
context: buildMatchContext(inner, index)
|
|
}));
|
|
return;
|
|
}
|
|
const pendingPromise = match._nonReactive.minPendingPromise;
|
|
if (pendingPromise) await pendingPromise;
|
|
if (isNotFound(e)) await ((_c = (_b = route.options.notFoundComponent) == null ? void 0 : _b.preload) == null ? void 0 : _c.call(_b));
|
|
handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), e);
|
|
try {
|
|
(_e = (_d = route.options).onError) == null ? void 0 : _e.call(_d, e);
|
|
} catch (onErrorError) {
|
|
error = onErrorError;
|
|
handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), onErrorError);
|
|
}
|
|
if (!isRedirect(error) && !isNotFound(error)) await loadRouteChunk(route, ["errorComponent"]);
|
|
inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
error,
|
|
context: buildMatchContext(inner, index),
|
|
status: "error",
|
|
isFetching: false
|
|
}));
|
|
}
|
|
} catch (err) {
|
|
const match = inner.router.getMatch(matchId);
|
|
if (match) match._nonReactive.loaderPromise = void 0;
|
|
handleRedirectAndNotFound(inner, match, err);
|
|
}
|
|
};
|
|
var loadRouteMatch = async (inner, matchPromises, index) => {
|
|
var _a, _b, _c, _d;
|
|
async function handleLoader(preload, prevMatch, previousRouteMatchId, match2, route2) {
|
|
const age = Date.now() - prevMatch.updatedAt;
|
|
const staleAge = preload ? route2.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route2.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0;
|
|
const shouldReloadOption = route2.options.shouldReload;
|
|
const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext(inner, matchPromises, matchId, index, route2)) : shouldReloadOption;
|
|
const { status, invalid } = match2;
|
|
const staleMatchShouldReload = age >= staleAge && (!!inner.forceStaleReload || match2.cause === "enter" || previousRouteMatchId !== void 0 && previousRouteMatchId !== match2.id);
|
|
loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? staleMatchShouldReload));
|
|
if (preload && route2.options.preload === false) {
|
|
} else if (loaderShouldRunAsync && !inner.sync && shouldReloadInBackground) {
|
|
loaderIsRunningAsync = true;
|
|
(async () => {
|
|
var _a2, _b2;
|
|
try {
|
|
await runLoader(inner, matchPromises, matchId, index, route2);
|
|
const match3 = inner.router.getMatch(matchId);
|
|
(_a2 = match3._nonReactive.loaderPromise) == null ? void 0 : _a2.resolve();
|
|
(_b2 = match3._nonReactive.loadPromise) == null ? void 0 : _b2.resolve();
|
|
match3._nonReactive.loaderPromise = void 0;
|
|
match3._nonReactive.loadPromise = void 0;
|
|
} catch (err) {
|
|
if (isRedirect(err)) await inner.router.navigate(err.options);
|
|
}
|
|
})();
|
|
} else if (status !== "success" || loaderShouldRunAsync) await runLoader(inner, matchPromises, matchId, index, route2);
|
|
else syncMatchContext(inner, matchId, index);
|
|
}
|
|
const { id: matchId, routeId } = inner.matches[index];
|
|
let loaderShouldRunAsync = false;
|
|
let loaderIsRunningAsync = false;
|
|
const route = inner.router.looseRoutesById[routeId];
|
|
const routeLoader = route.options.loader;
|
|
const shouldReloadInBackground = ((typeof routeLoader === "function" ? void 0 : routeLoader == null ? void 0 : routeLoader.staleReloadMode) ?? inner.router.options.defaultStaleReloadMode) !== "blocking";
|
|
if (shouldSkipLoader(inner, matchId)) {
|
|
if (!inner.router.getMatch(matchId)) return inner.matches[index];
|
|
syncMatchContext(inner, matchId, index);
|
|
if (isServer ?? inner.router.isServer) return inner.router.getMatch(matchId);
|
|
} else {
|
|
const prevMatch = inner.router.getMatch(matchId);
|
|
const activeIdAtIndex = inner.router.stores.matchesId.get()[index];
|
|
const previousRouteMatchId = ((_a = activeIdAtIndex && inner.router.stores.matchStores.get(activeIdAtIndex) || null) == null ? void 0 : _a.routeId) === routeId ? activeIdAtIndex : (_b = inner.router.stores.matches.get().find((d) => d.routeId === routeId)) == null ? void 0 : _b.id;
|
|
const preload = resolvePreload(inner, matchId);
|
|
if (prevMatch._nonReactive.loaderPromise) {
|
|
if (prevMatch.status === "success" && !inner.sync && !prevMatch.preload && shouldReloadInBackground) return prevMatch;
|
|
await prevMatch._nonReactive.loaderPromise;
|
|
const match2 = inner.router.getMatch(matchId);
|
|
const error = match2._nonReactive.error || match2.error;
|
|
if (error) handleRedirectAndNotFound(inner, match2, error);
|
|
if (match2.status === "pending") await handleLoader(preload, prevMatch, previousRouteMatchId, match2, route);
|
|
} else {
|
|
const nextPreload = preload && !inner.router.stores.matchStores.has(matchId);
|
|
const match2 = inner.router.getMatch(matchId);
|
|
match2._nonReactive.loaderPromise = createControlledPromise();
|
|
if (nextPreload !== match2.preload) inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
preload: nextPreload
|
|
}));
|
|
await handleLoader(preload, prevMatch, previousRouteMatchId, match2, route);
|
|
}
|
|
}
|
|
const match = inner.router.getMatch(matchId);
|
|
if (!loaderIsRunningAsync) {
|
|
(_c = match._nonReactive.loaderPromise) == null ? void 0 : _c.resolve();
|
|
(_d = match._nonReactive.loadPromise) == null ? void 0 : _d.resolve();
|
|
match._nonReactive.loadPromise = void 0;
|
|
}
|
|
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) {
|
|
var _a, _b;
|
|
const inner = arg;
|
|
const matchPromises = [];
|
|
if (!(isServer ?? inner.router.isServer) && hasForcePendingActiveMatch(inner.router)) triggerOnReady(inner);
|
|
let beforeLoadNotFound;
|
|
for (let i = 0; i < inner.matches.length; i++) {
|
|
try {
|
|
const beforeLoad = handleBeforeLoad(inner, i);
|
|
if (isPromise(beforeLoad)) await beforeLoad;
|
|
} catch (err) {
|
|
if (isRedirect(err)) throw err;
|
|
if (isNotFound(err)) beforeLoadNotFound = err;
|
|
else if (!inner.preload) throw err;
|
|
break;
|
|
}
|
|
if (inner.serialError || inner.firstBadMatchIndex != null) break;
|
|
}
|
|
const baseMaxIndexExclusive = inner.firstBadMatchIndex ?? inner.matches.length;
|
|
const boundaryIndex = beforeLoadNotFound && !inner.preload ? getNotFoundBoundaryIndex(inner, beforeLoadNotFound) : void 0;
|
|
const maxIndexExclusive = beforeLoadNotFound && inner.preload ? 0 : boundaryIndex !== void 0 ? Math.min(boundaryIndex + 1, baseMaxIndexExclusive) : baseMaxIndexExclusive;
|
|
let firstNotFound;
|
|
let firstUnhandledRejection;
|
|
for (let i = 0; i < maxIndexExclusive; i++) matchPromises.push(loadRouteMatch(inner, matchPromises, i));
|
|
try {
|
|
await Promise.all(matchPromises);
|
|
} catch {
|
|
const settled = await Promise.allSettled(matchPromises);
|
|
for (const result of settled) {
|
|
if (result.status !== "rejected") continue;
|
|
const reason = result.reason;
|
|
if (isRedirect(reason)) throw reason;
|
|
if (isNotFound(reason)) firstNotFound ?? (firstNotFound = reason);
|
|
else firstUnhandledRejection ?? (firstUnhandledRejection = reason);
|
|
}
|
|
if (firstUnhandledRejection !== void 0) throw firstUnhandledRejection;
|
|
}
|
|
const notFoundToThrow = firstNotFound ?? (beforeLoadNotFound && !inner.preload ? beforeLoadNotFound : void 0);
|
|
let headMaxIndex = inner.firstBadMatchIndex !== void 0 ? inner.firstBadMatchIndex : inner.matches.length - 1;
|
|
if (!notFoundToThrow && beforeLoadNotFound && inner.preload) return inner.matches;
|
|
if (notFoundToThrow) {
|
|
const renderedBoundaryIndex = getNotFoundBoundaryIndex(inner, notFoundToThrow);
|
|
if (renderedBoundaryIndex === void 0) {
|
|
if (true) throw new Error("Invariant failed: Could not find match for notFound boundary");
|
|
invariant();
|
|
}
|
|
const boundaryMatch = inner.matches[renderedBoundaryIndex];
|
|
const boundaryRoute = inner.router.looseRoutesById[boundaryMatch.routeId];
|
|
const defaultNotFoundComponent = (_a = inner.router.options) == null ? void 0 : _a.defaultNotFoundComponent;
|
|
if (!boundaryRoute.options.notFoundComponent && defaultNotFoundComponent) boundaryRoute.options.notFoundComponent = defaultNotFoundComponent;
|
|
notFoundToThrow.routeId = boundaryMatch.routeId;
|
|
const boundaryIsRoot = boundaryMatch.routeId === inner.router.routeTree.id;
|
|
inner.updateMatch(boundaryMatch.id, (prev) => ({
|
|
...prev,
|
|
...boundaryIsRoot ? {
|
|
status: "success",
|
|
globalNotFound: true,
|
|
error: void 0
|
|
} : {
|
|
status: "notFound",
|
|
error: notFoundToThrow
|
|
},
|
|
isFetching: false
|
|
}));
|
|
headMaxIndex = renderedBoundaryIndex;
|
|
await loadRouteChunk(boundaryRoute, ["notFoundComponent"]);
|
|
} else if (!inner.preload) {
|
|
const rootMatch = inner.matches[0];
|
|
if (!rootMatch.globalNotFound) {
|
|
if ((_b = inner.router.getMatch(rootMatch.id)) == null ? void 0 : _b.globalNotFound) inner.updateMatch(rootMatch.id, (prev) => ({
|
|
...prev,
|
|
globalNotFound: false,
|
|
error: void 0
|
|
}));
|
|
}
|
|
}
|
|
if (inner.serialError && inner.firstBadMatchIndex !== void 0) {
|
|
const errorRoute = inner.router.looseRoutesById[inner.matches[inner.firstBadMatchIndex].routeId];
|
|
await loadRouteChunk(errorRoute, ["errorComponent"]);
|
|
}
|
|
for (let i = 0; i <= headMaxIndex; i++) {
|
|
const { id: matchId, routeId } = inner.matches[i];
|
|
const route = inner.router.looseRoutesById[routeId];
|
|
try {
|
|
const headResult = executeHead(inner, matchId, route);
|
|
if (headResult) {
|
|
const head = await headResult;
|
|
inner.updateMatch(matchId, (prev) => ({
|
|
...prev,
|
|
...head
|
|
}));
|
|
}
|
|
} catch (err) {
|
|
console.error(`Error executing head for route ${routeId}:`, err);
|
|
}
|
|
}
|
|
const readyPromise = triggerOnReady(inner);
|
|
if (isPromise(readyPromise)) await readyPromise;
|
|
if (notFoundToThrow) throw notFoundToThrow;
|
|
if (inner.serialError && !inner.preload && !inner.onReady) throw inner.serialError;
|
|
return inner.matches;
|
|
}
|
|
function preloadRouteComponents(route, componentTypesToLoad) {
|
|
const preloads = componentTypesToLoad.map((type) => {
|
|
var _a, _b;
|
|
return (_b = (_a = route.options[type]) == null ? void 0 : _a.preload) == null ? void 0 : _b.call(_a);
|
|
}).filter(Boolean);
|
|
if (preloads.length === 0) return void 0;
|
|
return Promise.all(preloads);
|
|
}
|
|
function loadRouteChunk(route, componentTypesToLoad = componentTypes) {
|
|
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;
|
|
const runAfterLazy = () => route._componentsLoaded ? void 0 : componentTypesToLoad === componentTypes ? (() => {
|
|
if (route._componentsPromise === void 0) {
|
|
const componentsPromise = preloadRouteComponents(route, componentTypes);
|
|
if (componentsPromise) route._componentsPromise = componentsPromise.then(() => {
|
|
route._componentsLoaded = true;
|
|
route._componentsPromise = void 0;
|
|
});
|
|
else route._componentsLoaded = true;
|
|
}
|
|
return route._componentsPromise;
|
|
})() : preloadRouteComponents(route, componentTypesToLoad);
|
|
return route._lazyPromise ? route._lazyPromise.then(runAfterLazy) : runAfterLazy();
|
|
}
|
|
function makeMaybe(value, error) {
|
|
if (error) return {
|
|
status: "error",
|
|
error
|
|
};
|
|
return {
|
|
status: "success",
|
|
value
|
|
};
|
|
}
|
|
function routeNeedsPreload(route) {
|
|
var _a;
|
|
for (const componentType of componentTypes) if ((_a = route.options[componentType]) == null ? void 0 : _a.preload) return true;
|
|
return false;
|
|
}
|
|
var componentTypes = [
|
|
"component",
|
|
"errorComponent",
|
|
"pendingComponent",
|
|
"notFoundComponent"
|
|
];
|
|
|
|
// 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 }) => {
|
|
var _a, _b;
|
|
if ((navigateOpts == null ? void 0 : navigateOpts.ignoreBlocker) ?? false) {
|
|
task();
|
|
return;
|
|
}
|
|
const blockers = ((_a = opts.getBlockers) == null ? void 0 : _a.call(opts)) ?? [];
|
|
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);
|
|
if (await blocker.blockerFn({
|
|
currentLocation: location,
|
|
nextLocation,
|
|
action: actionInfo.type
|
|
})) {
|
|
(_b = opts.onBlocked) == null ? void 0 : _b.call(opts);
|
|
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 == null ? void 0 : navigateOpts.ignoreBlocker) ?? false);
|
|
handleIndexChange({ type: "BACK" });
|
|
},
|
|
navigateOpts,
|
|
type: "BACK"
|
|
});
|
|
},
|
|
forward: (navigateOpts) => {
|
|
tryNavigation({
|
|
task: () => {
|
|
opts.forward((navigateOpts == null ? void 0 : navigateOpts.ignoreBlocker) ?? false);
|
|
handleIndexChange({ type: "FORWARD" });
|
|
},
|
|
navigateOpts,
|
|
type: "FORWARD"
|
|
});
|
|
},
|
|
canGoBack: () => location.state[stateIndexKey] !== 0,
|
|
createHref: (str) => opts.createHref(str),
|
|
block: (blocker) => {
|
|
var _a;
|
|
if (!opts.setBlockers) return () => {
|
|
};
|
|
const blockers = ((_a = opts.getBlockers) == null ? void 0 : _a.call(opts)) ?? [];
|
|
opts.setBlockers([...blockers, blocker]);
|
|
return () => {
|
|
var _a2, _b;
|
|
const blockers2 = ((_a2 = opts.getBlockers) == null ? void 0 : _a2.call(opts)) ?? [];
|
|
(_b = opts.setBlockers) == null ? void 0 : _b.call(opts, blockers2.filter((b) => b !== blocker));
|
|
};
|
|
},
|
|
flush: () => {
|
|
var _a;
|
|
return (_a = opts.flush) == null ? void 0 : _a.call(opts);
|
|
},
|
|
destroy: () => {
|
|
var _a;
|
|
return (_a = opts.destroy) == null ? void 0 : _a.call(opts);
|
|
},
|
|
notify
|
|
};
|
|
}
|
|
function assignKeyAndIndex(index, state) {
|
|
if (!state) state = {};
|
|
const key = createRandomKey();
|
|
return {
|
|
...state,
|
|
key,
|
|
__TSR_key: key,
|
|
[stateIndexKey]: index
|
|
};
|
|
}
|
|
function createBrowserHistory(opts) {
|
|
var _a, _b;
|
|
const win = (opts == null ? void 0 : 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 == null ? void 0 : opts.createHref) ?? ((path) => path);
|
|
const parseLocation = (opts == null ? void 0 : opts.parseLocation) ?? (() => parseHref(`${win.location.pathname}${win.location.search}${win.location.hash}`, win.history.state));
|
|
if (!((_a = win.history.state) == null ? void 0 : _a.__TSR_key) && !((_b = win.history.state) == null ? void 0 : _b.key)) {
|
|
const addedKey = createRandomKey();
|
|
win.history.replaceState({
|
|
[stateIndexKey]: 0,
|
|
key: addedKey,
|
|
__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 flush2 = () => {
|
|
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 == null ? void 0 : next.isPush) || type === "push"
|
|
};
|
|
if (!scheduled) scheduled = Promise.resolve().then(() => flush2());
|
|
};
|
|
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) if (await blocker.blockerFn({
|
|
currentLocation,
|
|
nextLocation,
|
|
action
|
|
})) {
|
|
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 = "";
|
|
}
|
|
};
|
|
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: flush2,
|
|
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 createHashHistory(opts) {
|
|
const win = (opts == null ? void 0 : opts.window) ?? (typeof document !== "undefined" ? window : void 0);
|
|
return createBrowserHistory({
|
|
window: win,
|
|
parseLocation: () => {
|
|
const hashSplit = win.location.hash.split("#").slice(1);
|
|
const pathPart = hashSplit[0] ?? "/";
|
|
const searchPart = win.location.search;
|
|
const hashEntries = hashSplit.slice(1);
|
|
return parseHref(`${pathPart}${searchPart}${hashEntries.length === 0 ? "" : `#${hashEntries.join("#")}`}`, win.history.state);
|
|
},
|
|
createHref: (href) => `${win.location.pathname}${win.location.search}#${href}`
|
|
});
|
|
}
|
|
function createMemoryHistory(opts = { initialEntries: ["/"] }) {
|
|
const entries = opts.initialEntries;
|
|
let index = opts.initialIndex ? Math.min(Math.max(opts.initialIndex, 0), entries.length - 1) : entries.length - 1;
|
|
const states = entries.map((_entry, index2) => assignKeyAndIndex(index2, void 0));
|
|
const getLocation = () => parseHref(entries[index], states[index]);
|
|
let blockers = [];
|
|
const _getBlockers = () => blockers;
|
|
const _setBlockers = (newBlockers) => blockers = newBlockers;
|
|
return createHistory({
|
|
getLocation,
|
|
getLength: () => entries.length,
|
|
pushState: (path, state) => {
|
|
if (index < entries.length - 1) {
|
|
entries.splice(index + 1);
|
|
states.splice(index + 1);
|
|
}
|
|
states.push(state);
|
|
entries.push(path);
|
|
index = Math.max(entries.length - 1, 0);
|
|
},
|
|
replaceState: (path, state) => {
|
|
states[index] = state;
|
|
entries[index] = path;
|
|
},
|
|
back: () => {
|
|
index = Math.max(index - 1, 0);
|
|
},
|
|
forward: () => {
|
|
index = Math.min(index + 1, entries.length - 1);
|
|
},
|
|
go: (n) => {
|
|
index = Math.min(Math.max(index + n, 0), entries.length - 1);
|
|
},
|
|
createHref: (path) => path,
|
|
getBlockers: _getBlockers,
|
|
setBlockers: _setBlockers
|
|
});
|
|
}
|
|
function sanitizePath(path) {
|
|
let sanitized = path.replace(/[\x00-\x1f\x7f]/g, "");
|
|
if (sanitized.startsWith("//")) sanitized = "/" + sanitized.replace(/^\/+/, "");
|
|
return sanitized;
|
|
}
|
|
function parseHref(href, state) {
|
|
const sanitizedHref = sanitizePath(href);
|
|
const hashIndex = sanitizedHref.indexOf("#");
|
|
const searchIndex = sanitizedHref.indexOf("?");
|
|
const addedKey = createRandomKey();
|
|
return {
|
|
href: sanitizedHref,
|
|
pathname: sanitizedHref.substring(0, hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length),
|
|
hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
|
|
search: searchIndex > -1 ? sanitizedHref.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/router.js
|
|
function defaultSerializeError(err) {
|
|
if (err instanceof Error) {
|
|
const obj = {
|
|
name: err.name,
|
|
message: err.message
|
|
};
|
|
if (true) obj.stack = err.stack;
|
|
return obj;
|
|
}
|
|
return { data: err };
|
|
}
|
|
function getLocationChangeInfo(location, resolvedLocation) {
|
|
const fromLocation = resolvedLocation;
|
|
const toLocation = location;
|
|
return {
|
|
fromLocation,
|
|
toLocation,
|
|
pathChanged: (fromLocation == null ? void 0 : fromLocation.pathname) !== toLocation.pathname,
|
|
hrefChanged: (fromLocation == null ? void 0 : fromLocation.href) !== toLocation.href,
|
|
hashChanged: (fromLocation == null ? void 0 : fromLocation.hash) !== toLocation.hash
|
|
};
|
|
}
|
|
var RouterCore = class {
|
|
/**
|
|
* @deprecated Use the `createRouter` function instead
|
|
*/
|
|
constructor(options, getStoreConfig) {
|
|
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) => {
|
|
var _a;
|
|
if (true) {
|
|
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 == null ? void 0 : prevOptions.basepath) ?? "/";
|
|
const basepathWasUnset = this.basepath === void 0;
|
|
const prevRewriteOption = prevOptions == null ? void 0 : prevOptions.rewrite;
|
|
this.options = {
|
|
...prevOptions,
|
|
...newOptions
|
|
};
|
|
this.isServer = this.options.isServer ?? typeof document === "undefined";
|
|
this.protocolAllowlist = new Set(this.options.protocolAllowlist);
|
|
if (this.options.pathParamsAllowedCharacters) this.pathParamsDecoder = compileDecodeCharMap(this.options.pathParamsAllowedCharacters);
|
|
if (!this.history || this.options.history && this.options.history !== this.history) if (!this.options.history) {
|
|
if (!(isServer ?? this.isServer)) this.history = createBrowserHistory();
|
|
} else this.history = this.options.history;
|
|
this.origin = this.options.origin;
|
|
if (!this.origin) if (!(isServer ?? this.isServer) && (window == null ? void 0 : 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;
|
|
let processRouteTreeResult;
|
|
if ((isServer ?? this.isServer) && false) {
|
|
const cached = globalThis.__TSR_CACHE__;
|
|
this.resolvePathCache = cached.resolvePathCache;
|
|
processRouteTreeResult = cached.processRouteTreeResult;
|
|
} else {
|
|
this.resolvePathCache = createLRUCache(1e3);
|
|
processRouteTreeResult = this.buildRouteTree();
|
|
if ((isServer ?? this.isServer) && false) globalThis.__TSR_CACHE__ = {
|
|
routeTree: this.routeTree,
|
|
processRouteTreeResult,
|
|
resolvePathCache: this.resolvePathCache
|
|
};
|
|
}
|
|
this.setRoutes(processRouteTreeResult);
|
|
}
|
|
if (!this.stores && this.latestLocation) {
|
|
const config = this.getStoreConfig(this);
|
|
this.batch = config.batch;
|
|
this.stores = createRouterStores(getInitialRouterState(this.latestLocation), config);
|
|
if (!(isServer ?? this.isServer)) setupScrollRestoration(this);
|
|
}
|
|
let needsLocationUpdate = false;
|
|
const nextBasepath = this.options.basepath ?? "/";
|
|
const nextRewriteOption = this.options.rewrite;
|
|
if (basepathWasUnset || prevBasepath !== nextBasepath || prevRewriteOption !== nextRewriteOption) {
|
|
this.basepath = nextBasepath;
|
|
const rewrites = [];
|
|
const trimmed = trimPath(nextBasepath);
|
|
if (trimmed && trimmed !== "/") 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.stores) this.stores.location.set(this.latestLocation);
|
|
if (typeof window !== "undefined" && "CSS" in window && typeof ((_a = window.CSS) == null ? void 0 : _a.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 result = processRouteTree(this.routeTree, this.options.caseSensitive, (route, i) => {
|
|
route.init({ originalIndex: i });
|
|
});
|
|
if (this.options.routeMasks) processRouteMasks(this.options.routeMasks, result.processedTree);
|
|
return result;
|
|
};
|
|
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 = ({ pathname, search, hash, href, state }) => {
|
|
if (!this.rewrite && !/[ \x00-\x1f\x7f\u0080-\uffff]/.test(pathname)) {
|
|
const parsedSearch2 = this.options.parseSearch(search);
|
|
const searchStr2 = this.options.stringifySearch(parsedSearch2);
|
|
return {
|
|
href: pathname + searchStr2 + hash,
|
|
publicHref: pathname + searchStr2 + hash,
|
|
pathname: decodePath(pathname).path,
|
|
external: false,
|
|
searchStr: searchStr2,
|
|
search: nullReplaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch2),
|
|
hash: decodePath(hash.slice(1)).path,
|
|
state: replaceEqualDeep(previousLocation == null ? void 0 : previousLocation.state, 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;
|
|
return {
|
|
href: url.href.replace(url.origin, ""),
|
|
publicHref: href,
|
|
pathname: decodePath(url.pathname).path,
|
|
external: !!this.rewrite && url.origin !== this.origin,
|
|
searchStr,
|
|
search: nullReplaceEqualDeep(previousLocation == null ? void 0 : previousLocation.search, parsedSearch),
|
|
hash: decodePath(url.hash.slice(1)).path,
|
|
state: replaceEqualDeep(previousLocation == null ? void 0 : 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) => {
|
|
return resolvePath({
|
|
base: from,
|
|
to: cleanPath(path),
|
|
trailingSlash: this.options.trailingSlash,
|
|
cache: this.resolvePathCache
|
|
});
|
|
};
|
|
this.matchRoutes = (pathnameOrNext, locationSearchOrOpts, opts) => {
|
|
if (typeof pathnameOrNext === "string") return this.matchRoutesInternal({
|
|
pathname: pathnameOrNext,
|
|
search: locationSearchOrOpts
|
|
}, opts);
|
|
return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
|
|
};
|
|
this.getMatchedRoutes = (pathname) => {
|
|
return getMatchedRoutes({
|
|
pathname,
|
|
routesById: this.routesById,
|
|
processedTree: this.processedTree
|
|
});
|
|
};
|
|
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.stores.pendingIds.get().forEach((matchId) => {
|
|
this.cancelMatch(matchId);
|
|
});
|
|
this.stores.matchesId.get().forEach((matchId) => {
|
|
var _a;
|
|
if (this.stores.pendingMatchStores.has(matchId)) return;
|
|
const match = (_a = this.stores.matchStores.get(matchId)) == null ? void 0 : _a.get();
|
|
if (!match) return;
|
|
if (match.status === "pending" || match.isFetching === "loader") this.cancelMatch(matchId);
|
|
});
|
|
};
|
|
this.buildLocation = (opts) => {
|
|
const build = (dest = {}) => {
|
|
var _a, _b;
|
|
const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation;
|
|
const lightweightResult = this.matchRoutesLightweight(currentLocation);
|
|
if (dest.from && true && dest._isNavigate) {
|
|
const allFromMatches = this.getMatchedRoutes(dest.from).matchedRoutes;
|
|
const matchedFrom = findLast(lightweightResult.matchedRoutes, (d) => {
|
|
return comparePaths(d.fullPath, dest.from);
|
|
});
|
|
const matchedCurrent = findLast(allFromMatches, (d) => {
|
|
return comparePaths(d.fullPath, lightweightResult.fullPath);
|
|
});
|
|
if (!matchedFrom && !matchedCurrent) console.warn(`Could not find match for from: ${dest.from}`);
|
|
}
|
|
const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lightweightResult.fullPath;
|
|
const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
|
|
const fromSearch = lightweightResult.search;
|
|
const fromParams = Object.assign(/* @__PURE__ */ Object.create(null), lightweightResult.params);
|
|
const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
|
|
const nextParams = dest.params === false || dest.params === null ? /* @__PURE__ */ Object.create(null) : (dest.params ?? true) === true ? fromParams : Object.assign(fromParams, functionalUpdate(dest.params, fromParams));
|
|
const destMatchResult = this.getMatchedRoutes(nextTo);
|
|
let destRoutes = destMatchResult.matchedRoutes;
|
|
if ((!destMatchResult.foundRoute || destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"]) && this.options.notFoundRoute) destRoutes = [...destRoutes, this.options.notFoundRoute];
|
|
if (Object.keys(nextParams).length > 0) for (const route of destRoutes) {
|
|
const fn = ((_a = route.options.params) == null ? void 0 : _a.stringify) ?? route.options.stringifyParams;
|
|
if (fn) try {
|
|
Object.assign(nextParams, fn(nextParams));
|
|
} catch {
|
|
}
|
|
}
|
|
const nextPathname = opts.leaveParams ? nextTo : decodePath(interpolatePath({
|
|
path: nextTo,
|
|
params: nextParams,
|
|
decoder: this.pathParamsDecoder,
|
|
server: this.isServer
|
|
}).interpolatedPath).path;
|
|
let nextSearch = fromSearch;
|
|
if (opts._includeValidateSearch && ((_b = this.options.search) == null ? void 0 : _b.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 = nullReplaceEqualDeep(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}`;
|
|
let href;
|
|
let publicHref;
|
|
let external = false;
|
|
if (this.rewrite) {
|
|
const url = new URL(fullPath, this.origin);
|
|
const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
|
|
href = url.href.replace(url.origin, "");
|
|
if (rewrittenUrl.origin !== this.origin) {
|
|
publicHref = rewrittenUrl.href;
|
|
external = true;
|
|
} else publicHref = rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash;
|
|
} else {
|
|
href = encodePathLikeUrl(fullPath);
|
|
publicHref = href;
|
|
}
|
|
return {
|
|
publicHref,
|
|
href,
|
|
pathname: nextPathname,
|
|
search: nextSearch,
|
|
searchStr,
|
|
state: nextState,
|
|
hash: hash ?? "",
|
|
external,
|
|
unmaskOnReload: dest.unmaskOnReload
|
|
};
|
|
};
|
|
const buildWithMatches = (dest = {}, maskedDest) => {
|
|
const next = build(dest);
|
|
let maskedNext = maskedDest ? build(maskedDest) : void 0;
|
|
if (!maskedNext) {
|
|
const params = /* @__PURE__ */ Object.create(null);
|
|
if (this.options.routeMasks) {
|
|
const match = findFlatMatch(next.pathname, this.processedTree);
|
|
if (match) {
|
|
Object.assign(params, match.rawParams);
|
|
const { from: _from, params: maskParams, ...maskProps } = match.route;
|
|
const nextParams = maskParams === false || maskParams === null ? /* @__PURE__ */ Object.create(null) : (maskParams ?? true) === true ? params : Object.assign(params, functionalUpdate(maskParams, params));
|
|
maskedDest = {
|
|
from: opts.from,
|
|
...maskProps,
|
|
params: nextParams
|
|
};
|
|
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 = async ({ viewTransition, ignoreBlocker, ...next }) => {
|
|
const isSameState = () => {
|
|
const ignoredProps = [
|
|
"key",
|
|
"__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 = trimPathRight2(this.latestLocation.href) === trimPathRight2(next.href);
|
|
let previousCommitPromise = this.commitLocationPromise;
|
|
this.commitLocationPromise = createControlledPromise(() => {
|
|
previousCommitPromise == null ? void 0 : previousCommitPromise.resolve();
|
|
previousCommitPromise = void 0;
|
|
});
|
|
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
|
|
}
|
|
}
|
|
}
|
|
};
|
|
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 });
|
|
const hrefUrl = new URL(parsed.pathname, this.origin);
|
|
rest.to = executeRewriteInput(this.rewrite, hrefUrl).pathname;
|
|
rest.search = this.options.parseSearch(parsed.search);
|
|
rest.hash = parsed.hash.slice(1);
|
|
}
|
|
const location = this.buildLocation({
|
|
...rest,
|
|
_includeValidateSearch: true
|
|
});
|
|
this.pendingBuiltLocation = location;
|
|
const commitPromise = this.commitLocation({
|
|
...location,
|
|
viewTransition,
|
|
replace,
|
|
resetScroll,
|
|
hashScrollIntoView,
|
|
ignoreBlocker
|
|
});
|
|
Promise.resolve().then(() => {
|
|
if (this.pendingBuiltLocation === location) this.pendingBuiltLocation = void 0;
|
|
});
|
|
return commitPromise;
|
|
};
|
|
this.navigate = async ({ to, reloadDocument, href, publicHref, ...rest }) => {
|
|
var _a, _b;
|
|
let hrefIsUrl = false;
|
|
if (href) try {
|
|
new URL(`${href}`);
|
|
hrefIsUrl = true;
|
|
} catch {
|
|
}
|
|
if (hrefIsUrl && !reloadDocument) reloadDocument = true;
|
|
if (reloadDocument) {
|
|
if (to !== void 0 || !href) {
|
|
const location = this.buildLocation({
|
|
to,
|
|
...rest
|
|
});
|
|
href = href ?? location.publicHref;
|
|
publicHref = publicHref ?? location.publicHref;
|
|
}
|
|
const reloadHref = !hrefIsUrl && publicHref ? publicHref : href;
|
|
if (isDangerousProtocol(reloadHref, this.protocolAllowlist)) {
|
|
if (true) console.warn(`Blocked navigation to dangerous protocol: ${reloadHref}`);
|
|
return Promise.resolve();
|
|
}
|
|
if (!rest.ignoreBlocker) {
|
|
const blockers = ((_b = (_a = this.history).getBlockers) == null ? void 0 : _b.call(_a)) ?? [];
|
|
for (const blocker of blockers) if (blocker == null ? void 0 : blocker.blockerFn) {
|
|
if (await blocker.blockerFn({
|
|
currentLocation: this.latestLocation,
|
|
nextLocation: this.latestLocation,
|
|
action: "PUSH"
|
|
})) return Promise.resolve();
|
|
}
|
|
}
|
|
if (rest.replace) window.location.replace(reloadHref);
|
|
else window.location.href = reloadHref;
|
|
return Promise.resolve();
|
|
}
|
|
return this.buildAndCommitLocation({
|
|
...rest,
|
|
href,
|
|
to,
|
|
_isNavigate: true
|
|
});
|
|
};
|
|
this.beforeLoad = () => {
|
|
this.cancelMatches();
|
|
this.updateLatestLocation();
|
|
if (isServer ?? this.isServer) {
|
|
const nextLocation = this.buildLocation({
|
|
to: this.latestLocation.pathname,
|
|
search: true,
|
|
params: true,
|
|
hash: true,
|
|
state: true,
|
|
_includeValidateSearch: true
|
|
});
|
|
if (this.latestLocation.publicHref !== nextLocation.publicHref) {
|
|
const href = this.getParsedLocationHref(nextLocation);
|
|
if (nextLocation.external) throw redirect({ href });
|
|
else throw redirect({
|
|
href,
|
|
_builtLocation: nextLocation
|
|
});
|
|
}
|
|
}
|
|
const pendingMatches = this.matchRoutes(this.latestLocation);
|
|
const nextCachedMatches = this.stores.cachedMatches.get().filter((d) => !pendingMatches.some((e) => e.id === d.id));
|
|
this.batch(() => {
|
|
this.stores.status.set("pending");
|
|
this.stores.statusCode.set(200);
|
|
this.stores.isLoading.set(true);
|
|
this.stores.location.set(this.latestLocation);
|
|
this.stores.setPending(pendingMatches);
|
|
this.stores.setCached(nextCachedMatches);
|
|
});
|
|
};
|
|
this.load = async (opts) => {
|
|
let redirect2;
|
|
let notFound2;
|
|
let loadPromise;
|
|
const previousLocation = this.stores.resolvedLocation.get() ?? this.stores.location.get();
|
|
loadPromise = new Promise((resolve) => {
|
|
this.startTransition(async () => {
|
|
var _a;
|
|
try {
|
|
this.beforeLoad();
|
|
const next = this.latestLocation;
|
|
const locationChangeInfo = getLocationChangeInfo(next, this.stores.resolvedLocation.get());
|
|
if (!this.stores.redirect.get()) this.emit({
|
|
type: "onBeforeNavigate",
|
|
...locationChangeInfo
|
|
});
|
|
this.emit({
|
|
type: "onBeforeLoad",
|
|
...locationChangeInfo
|
|
});
|
|
await loadMatches({
|
|
router: this,
|
|
sync: opts == null ? void 0 : opts.sync,
|
|
forceStaleReload: previousLocation.href === next.href,
|
|
matches: this.stores.pendingMatches.get(),
|
|
location: next,
|
|
updateMatch: this.updateMatch,
|
|
onReady: async () => {
|
|
this.startTransition(() => {
|
|
this.startViewTransition(async () => {
|
|
var _a2, _b;
|
|
let exitingMatches = null;
|
|
let hookExitingMatches = null;
|
|
let hookEnteringMatches = null;
|
|
let hookStayingMatches = null;
|
|
this.batch(() => {
|
|
const pendingMatches = this.stores.pendingMatches.get();
|
|
const mountPending = pendingMatches.length;
|
|
const currentMatches = this.stores.matches.get();
|
|
exitingMatches = mountPending ? currentMatches.filter((match) => !this.stores.pendingMatchStores.has(match.id)) : null;
|
|
const pendingRouteIds = /* @__PURE__ */ new Set();
|
|
for (const s of this.stores.pendingMatchStores.values()) if (s.routeId) pendingRouteIds.add(s.routeId);
|
|
const activeRouteIds = /* @__PURE__ */ new Set();
|
|
for (const s of this.stores.matchStores.values()) if (s.routeId) activeRouteIds.add(s.routeId);
|
|
hookExitingMatches = mountPending ? currentMatches.filter((match) => !pendingRouteIds.has(match.routeId)) : null;
|
|
hookEnteringMatches = mountPending ? pendingMatches.filter((match) => !activeRouteIds.has(match.routeId)) : null;
|
|
hookStayingMatches = mountPending ? pendingMatches.filter((match) => activeRouteIds.has(match.routeId)) : currentMatches;
|
|
this.stores.isLoading.set(false);
|
|
this.stores.loadedAt.set(Date.now());
|
|
if (mountPending) {
|
|
this.stores.setMatches(pendingMatches);
|
|
this.stores.setPending([]);
|
|
this.stores.setCached([...this.stores.cachedMatches.get(), ...exitingMatches.filter((d) => d.status !== "error" && d.status !== "notFound" && d.status !== "redirected")]);
|
|
this.clearExpiredCache();
|
|
}
|
|
});
|
|
for (const [matches, hook] of [
|
|
[hookExitingMatches, "onLeave"],
|
|
[hookEnteringMatches, "onEnter"],
|
|
[hookStayingMatches, "onStay"]
|
|
]) {
|
|
if (!matches) continue;
|
|
for (const match of matches) (_b = (_a2 = this.looseRoutesById[match.routeId].options)[hook]) == null ? void 0 : _b.call(_a2, match);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
});
|
|
} catch (err) {
|
|
if (isRedirect(err)) {
|
|
redirect2 = err;
|
|
if (!(isServer ?? this.isServer)) this.navigate({
|
|
...redirect2.options,
|
|
replace: true,
|
|
ignoreBlocker: true
|
|
});
|
|
} else if (isNotFound(err)) notFound2 = err;
|
|
const nextStatusCode = redirect2 ? redirect2.status : notFound2 ? 404 : this.stores.matches.get().some((d) => d.status === "error") ? 500 : 200;
|
|
this.batch(() => {
|
|
this.stores.statusCode.set(nextStatusCode);
|
|
this.stores.redirect.set(redirect2);
|
|
});
|
|
}
|
|
if (this.latestLoadPromise === loadPromise) {
|
|
(_a = this.commitLocationPromise) == null ? void 0 : _a.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.stores.matches.get().some((d) => d.status === "error")) newStatusCode = 500;
|
|
if (newStatusCode !== void 0) this.stores.statusCode.set(newStatusCode);
|
|
};
|
|
this.startViewTransition = (fn) => {
|
|
const shouldViewTransition = this.shouldViewTransition ?? this.options.defaultViewTransition;
|
|
this.shouldViewTransition = void 0;
|
|
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.stores.resolvedLocation.get();
|
|
const resolvedViewTransitionTypes = typeof shouldViewTransition.types === "function" ? shouldViewTransition.types(getLocationChangeInfo(next, prevLocation)) : shouldViewTransition.types;
|
|
if (resolvedViewTransitionTypes === false) {
|
|
fn();
|
|
return;
|
|
}
|
|
startViewTransitionParams = {
|
|
update: fn,
|
|
types: resolvedViewTransitionTypes
|
|
};
|
|
} else startViewTransitionParams = fn;
|
|
document.startViewTransition(startViewTransitionParams);
|
|
} else fn();
|
|
};
|
|
this.updateMatch = (id, updater) => {
|
|
this.startTransition(() => {
|
|
const pendingMatch = this.stores.pendingMatchStores.get(id);
|
|
if (pendingMatch) {
|
|
pendingMatch.set(updater);
|
|
return;
|
|
}
|
|
const activeMatch = this.stores.matchStores.get(id);
|
|
if (activeMatch) {
|
|
activeMatch.set(updater);
|
|
return;
|
|
}
|
|
const cachedMatch = this.stores.cachedMatchStores.get(id);
|
|
if (cachedMatch) {
|
|
const next = updater(cachedMatch.get());
|
|
if (next.status === "redirected") {
|
|
if (this.stores.cachedMatchStores.delete(id)) this.stores.cachedIds.set((prev) => prev.filter((matchId) => matchId !== id));
|
|
} else cachedMatch.set(next);
|
|
}
|
|
});
|
|
};
|
|
this.getMatch = (matchId) => {
|
|
var _a, _b, _c;
|
|
return ((_a = this.stores.cachedMatchStores.get(matchId)) == null ? void 0 : _a.get()) ?? ((_b = this.stores.pendingMatchStores.get(matchId)) == null ? void 0 : _b.get()) ?? ((_c = this.stores.matchStores.get(matchId)) == null ? void 0 : _c.get());
|
|
};
|
|
this.invalidate = (opts) => {
|
|
const invalidate = (d) => {
|
|
var _a;
|
|
if (((_a = opts == null ? void 0 : opts.filter) == null ? void 0 : _a.call(opts, d)) ?? true) return {
|
|
...d,
|
|
invalid: true,
|
|
...(opts == null ? void 0 : opts.forcePending) || d.status === "error" || d.status === "notFound" ? {
|
|
status: "pending",
|
|
error: void 0
|
|
} : void 0
|
|
};
|
|
return d;
|
|
};
|
|
this.batch(() => {
|
|
this.stores.setMatches(this.stores.matches.get().map(invalidate));
|
|
this.stores.setCached(this.stores.cachedMatches.get().map(invalidate));
|
|
this.stores.setPending(this.stores.pendingMatches.get().map(invalidate));
|
|
});
|
|
this.shouldViewTransition = false;
|
|
return this.load({ sync: opts == null ? void 0 : opts.sync });
|
|
};
|
|
this.getParsedLocationHref = (location) => {
|
|
return location.publicHref || "/";
|
|
};
|
|
this.resolveRedirect = (redirect2) => {
|
|
const locationHeader = redirect2.headers.get("Location");
|
|
if (!redirect2.options.href || redirect2.options._builtLocation) {
|
|
const location = redirect2.options._builtLocation ?? this.buildLocation(redirect2.options);
|
|
const href = this.getParsedLocationHref(location);
|
|
redirect2.options.href = href;
|
|
redirect2.headers.set("Location", href);
|
|
} else if (locationHeader) try {
|
|
const url = new URL(locationHeader);
|
|
if (this.origin && url.origin === this.origin) {
|
|
const href = url.pathname + url.search + url.hash;
|
|
redirect2.options.href = href;
|
|
redirect2.headers.set("Location", href);
|
|
}
|
|
} catch {
|
|
}
|
|
if (redirect2.options.href && !redirect2.options._builtLocation && isDangerousProtocol(redirect2.options.href, this.protocolAllowlist)) throw new Error(true ? `Redirect blocked: unsafe protocol in href "${redirect2.options.href}". Allowed protocols: ${Array.from(this.protocolAllowlist).join(", ")}.` : "Redirect blocked: unsafe protocol");
|
|
if (!redirect2.headers.get("Location")) redirect2.headers.set("Location", redirect2.options.href);
|
|
return redirect2;
|
|
};
|
|
this.clearCache = (opts) => {
|
|
const filter = opts == null ? void 0 : opts.filter;
|
|
if (filter !== void 0) this.stores.setCached(this.stores.cachedMatches.get().filter((m) => !filter(m)));
|
|
else this.stores.setCached([]);
|
|
};
|
|
this.clearExpiredCache = () => {
|
|
const now = Date.now();
|
|
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) ?? 300 * 1e3;
|
|
if (d.status === "error") return true;
|
|
return now - d.updatedAt >= gcTime;
|
|
};
|
|
this.clearCache({ filter });
|
|
};
|
|
this.loadRouteChunk = loadRouteChunk;
|
|
this.preloadRoute = async (opts) => {
|
|
const next = opts._builtLocation ?? this.buildLocation(opts);
|
|
let matches = this.matchRoutes(next, {
|
|
throwOnError: true,
|
|
preload: true,
|
|
dest: opts
|
|
});
|
|
const activeMatchIds = /* @__PURE__ */ new Set([...this.stores.matchesId.get(), ...this.stores.pendingIds.get()]);
|
|
const loadedMatchIds = /* @__PURE__ */ new Set([...activeMatchIds, ...this.stores.cachedIds.get()]);
|
|
const matchesToCache = matches.filter((match) => !loadedMatchIds.has(match.id));
|
|
if (matchesToCache.length) {
|
|
const cachedMatches = this.stores.cachedMatches.get();
|
|
this.stores.setCached([...cachedMatches, ...matchesToCache]);
|
|
}
|
|
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;
|
|
return await this.preloadRoute({
|
|
...err.options,
|
|
_fromLocation: next
|
|
});
|
|
}
|
|
if (!isNotFound(err)) console.error(err);
|
|
return;
|
|
}
|
|
};
|
|
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 == null ? void 0 : opts.pending) && this.stores.status.get() !== "pending") return false;
|
|
const baseLocation = ((opts == null ? void 0 : opts.pending) === void 0 ? !this.stores.isLoading.get() : opts.pending) ? this.latestLocation : this.stores.resolvedLocation.get() || this.stores.location.get();
|
|
const match = findSingleMatch(next.pathname, (opts == null ? void 0 : opts.caseSensitive) ?? false, (opts == null ? void 0 : opts.fuzzy) ?? false, baseLocation.pathname, this.processedTree);
|
|
if (!match) return false;
|
|
if (location.params) {
|
|
if (!deepEqual(match.rawParams, location.params, { partial: true })) return false;
|
|
}
|
|
if ((opts == null ? void 0 : opts.includeSearch) ?? true) return deepEqual(baseLocation.search, next.search, { partial: true }) ? match.rawParams : false;
|
|
return match.rawParams;
|
|
};
|
|
this.hasNotFoundMatch = () => {
|
|
return this.stores.matches.get().some((d) => d.status === "notFound" || d.globalNotFound);
|
|
};
|
|
this.getStoreConfig = getStoreConfig;
|
|
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,
|
|
protocolAllowlist: options.protocolAllowlist ?? DEFAULT_PROTOCOL_ALLOWLIST
|
|
});
|
|
if (typeof document !== "undefined") self.__TSR_ROUTER__ = this;
|
|
}
|
|
isShell() {
|
|
return !!this.options.isShell;
|
|
}
|
|
isPrerendering() {
|
|
return !!this.options.isPrerendering;
|
|
}
|
|
get state() {
|
|
return this.stores.__store.get();
|
|
}
|
|
setRoutes({ routesById, routesByPath, processedTree }) {
|
|
this.routesById = routesById;
|
|
this.routesByPath = routesByPath;
|
|
this.processedTree = processedTree;
|
|
const notFoundRoute = this.options.notFoundRoute;
|
|
if (notFoundRoute) {
|
|
notFoundRoute.init({ originalIndex: 99999999999 });
|
|
this.routesById[notFoundRoute.id] = notFoundRoute;
|
|
}
|
|
}
|
|
get looseRoutesById() {
|
|
return this.routesById;
|
|
}
|
|
getParentContext(parentMatch) {
|
|
return !(parentMatch == null ? void 0 : parentMatch.id) ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
|
|
}
|
|
matchRoutesInternal(next, opts) {
|
|
var _a, _b;
|
|
const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
|
|
const { foundRoute, routeParams, parsedParams } = matchedRoutesResult;
|
|
let { matchedRoutes } = matchedRoutesResult;
|
|
let isGlobalNotFound = false;
|
|
if (foundRoute ? foundRoute.path !== "/" && routeParams["**"] : trimPathRight2(next.pathname)) if (this.options.notFoundRoute) matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
|
|
else isGlobalNotFound = true;
|
|
const globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
|
|
const matches = new Array(matchedRoutes.length);
|
|
const previousActiveMatchesByRouteId = /* @__PURE__ */ new Map();
|
|
for (const store of this.stores.matchStores.values()) if (store.routeId) previousActiveMatchesByRouteId.set(store.routeId, store.get());
|
|
for (let index = 0; index < matchedRoutes.length; index++) {
|
|
const route = matchedRoutes[index];
|
|
const parentMatch = matches[index - 1];
|
|
let preMatchSearch;
|
|
let strictMatchSearch;
|
|
let searchError;
|
|
{
|
|
const parentSearch = (parentMatch == null ? void 0 : parentMatch.search) ?? next.search;
|
|
const parentStrictSearch = (parentMatch == null ? void 0 : parentMatch._strictSearch) ?? void 0;
|
|
try {
|
|
const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? void 0;
|
|
preMatchSearch = {
|
|
...parentSearch,
|
|
...strictSearch
|
|
};
|
|
strictMatchSearch = {
|
|
...parentStrictSearch,
|
|
...strictSearch
|
|
};
|
|
searchError = void 0;
|
|
} catch (err) {
|
|
let searchParamError = err;
|
|
if (!(err instanceof SearchParamError)) searchParamError = new SearchParamError(err.message, { cause: err });
|
|
if (opts == null ? void 0 : opts.throwOnError) throw searchParamError;
|
|
preMatchSearch = parentSearch;
|
|
strictMatchSearch = {};
|
|
searchError = searchParamError;
|
|
}
|
|
}
|
|
const loaderDeps = ((_b = (_a = route.options).loaderDeps) == null ? void 0 : _b.call(_a, { search: preMatchSearch })) ?? "";
|
|
const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
|
|
const { interpolatedPath, usedParams } = interpolatePath({
|
|
path: route.fullPath,
|
|
params: routeParams,
|
|
decoder: this.pathParamsDecoder,
|
|
server: this.isServer
|
|
});
|
|
const matchId = route.id + interpolatedPath + loaderDepsHash;
|
|
const existingMatch = this.getMatch(matchId);
|
|
const previousMatch = previousActiveMatchesByRouteId.get(route.id);
|
|
const strictParams = (existingMatch == null ? void 0 : existingMatch._strictParams) ?? usedParams;
|
|
let paramsError = void 0;
|
|
if (!existingMatch) try {
|
|
extractStrictParams(route, usedParams, parsedParams, strictParams);
|
|
} catch (err) {
|
|
if (isNotFound(err) || isRedirect(err)) paramsError = err;
|
|
else paramsError = new PathParamError(err.message, { cause: err });
|
|
if (opts == null ? void 0 : opts.throwOnError) throw paramsError;
|
|
}
|
|
Object.assign(routeParams, strictParams);
|
|
const cause = previousMatch ? "stay" : "enter";
|
|
let match;
|
|
if (existingMatch) match = {
|
|
...existingMatch,
|
|
cause,
|
|
params: (previousMatch == null ? void 0 : previousMatch.params) ?? routeParams,
|
|
_strictParams: strictParams,
|
|
search: previousMatch ? nullReplaceEqualDeep(previousMatch.search, preMatchSearch) : nullReplaceEqualDeep(existingMatch.search, preMatchSearch),
|
|
_strictSearch: strictMatchSearch
|
|
};
|
|
else {
|
|
const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
|
|
match = {
|
|
id: matchId,
|
|
ssr: isServer ?? this.isServer ? void 0 : route.options.ssr,
|
|
index,
|
|
routeId: route.id,
|
|
params: (previousMatch == null ? void 0 : previousMatch.params) ?? routeParams,
|
|
_strictParams: strictParams,
|
|
pathname: interpolatedPath,
|
|
updatedAt: Date.now(),
|
|
search: previousMatch ? nullReplaceEqualDeep(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 == null ? void 0 : opts.preload)) match.globalNotFound = globalNotFoundRouteId === route.id;
|
|
match.searchError = searchError;
|
|
const parentContext = this.getParentContext(parentMatch);
|
|
match.context = {
|
|
...parentContext,
|
|
...match.__routeContext,
|
|
...match.__beforeLoadContext
|
|
};
|
|
matches[index] = match;
|
|
}
|
|
for (let index = 0; index < matches.length; index++) {
|
|
const match = matches[index];
|
|
const route = this.looseRoutesById[match.routeId];
|
|
const existingMatch = this.getMatch(match.id);
|
|
const previousMatch = previousActiveMatchesByRouteId.get(match.routeId);
|
|
match.params = previousMatch ? nullReplaceEqualDeep(previousMatch.params, routeParams) : routeParams;
|
|
if (!existingMatch) {
|
|
const parentMatch = matches[index - 1];
|
|
const parentContext = this.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,
|
|
routeId: route.id
|
|
};
|
|
match.__routeContext = route.options.context(contextFnContext) ?? void 0;
|
|
}
|
|
match.context = {
|
|
...parentContext,
|
|
...match.__routeContext,
|
|
...match.__beforeLoadContext
|
|
};
|
|
}
|
|
}
|
|
return matches;
|
|
}
|
|
/**
|
|
* Lightweight route matching for buildLocation.
|
|
* Only computes fullPath, accumulated search, and params - skipping expensive
|
|
* operations like AbortController, ControlledPromise, loaderDeps, and full match objects.
|
|
*/
|
|
matchRoutesLightweight(location) {
|
|
var _a;
|
|
const { matchedRoutes, routeParams, parsedParams } = this.getMatchedRoutes(location.pathname);
|
|
const lastRoute = last(matchedRoutes);
|
|
const accumulatedSearch = { ...location.search };
|
|
for (const route of matchedRoutes) try {
|
|
Object.assign(accumulatedSearch, validateSearch(route.options.validateSearch, accumulatedSearch));
|
|
} catch {
|
|
}
|
|
const lastStateMatchId = last(this.stores.matchesId.get());
|
|
const lastStateMatch = lastStateMatchId && ((_a = this.stores.matchStores.get(lastStateMatchId)) == null ? void 0 : _a.get());
|
|
const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && lastStateMatch.pathname === location.pathname;
|
|
let params;
|
|
if (canReuseParams) params = lastStateMatch.params;
|
|
else {
|
|
const strictParams = Object.assign(/* @__PURE__ */ Object.create(null), routeParams);
|
|
for (const route of matchedRoutes) try {
|
|
extractStrictParams(route, routeParams, parsedParams ?? {}, strictParams);
|
|
} catch {
|
|
}
|
|
params = strictParams;
|
|
}
|
|
return {
|
|
matchedRoutes,
|
|
fullPath: lastRoute.fullPath,
|
|
search: accumulatedSearch,
|
|
params
|
|
};
|
|
}
|
|
};
|
|
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 lazyFn(fn, key) {
|
|
return async (...args) => {
|
|
return (await fn())[key || "default"](...args);
|
|
};
|
|
}
|
|
function getInitialRouterState(location) {
|
|
return {
|
|
loadedAt: 0,
|
|
isLoading: false,
|
|
isTransitioning: false,
|
|
status: "idle",
|
|
resolvedLocation: void 0,
|
|
location,
|
|
matches: [],
|
|
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, routesById, processedTree }) {
|
|
const routeParams = /* @__PURE__ */ Object.create(null);
|
|
const trimmedPath = trimPathRight2(pathname);
|
|
let foundRoute = void 0;
|
|
let parsedParams = void 0;
|
|
const match = findRouteMatch(trimmedPath, processedTree, true);
|
|
if (match) {
|
|
foundRoute = match.route;
|
|
Object.assign(routeParams, match.rawParams);
|
|
parsedParams = Object.assign(/* @__PURE__ */ Object.create(null), match.parsedParams);
|
|
}
|
|
return {
|
|
matchedRoutes: (match == null ? void 0 : match.branch) || [routesById["__root__"]],
|
|
routeParams,
|
|
foundRoute,
|
|
parsedParams
|
|
};
|
|
}
|
|
function applySearchMiddleware({ search, dest, destRoutes, _includeValidateSearch }) {
|
|
return buildMiddlewareChain(destRoutes)(search, dest, _includeValidateSearch ?? false);
|
|
}
|
|
function buildMiddlewareChain(destRoutes) {
|
|
var _a;
|
|
const context = {
|
|
dest: null,
|
|
_includeValidateSearch: false,
|
|
middlewares: []
|
|
};
|
|
for (const route of destRoutes) {
|
|
if ("search" in route.options) {
|
|
if ((_a = route.options.search) == null ? void 0 : _a.middlewares) context.middlewares.push(...route.options.search.middlewares);
|
|
} else if (route.options.preSearchFilters || route.options.postSearchFilters) {
|
|
const legacyMiddleware = ({ search, next }) => {
|
|
let nextSearch = search;
|
|
if ("preSearchFilters" in route.options && route.options.preSearchFilters) nextSearch = route.options.preSearchFilters.reduce((prev, next2) => next2(prev), search);
|
|
const result = next(nextSearch);
|
|
if ("postSearchFilters" in route.options && route.options.postSearchFilters) return route.options.postSearchFilters.reduce((prev, next2) => next2(prev), result);
|
|
return result;
|
|
};
|
|
context.middlewares.push(legacyMiddleware);
|
|
}
|
|
if (route.options.validateSearch) {
|
|
const validate = ({ search, next }) => {
|
|
const result = next(search);
|
|
if (!context._includeValidateSearch) return result;
|
|
try {
|
|
return {
|
|
...result,
|
|
...validateSearch(route.options.validateSearch, result) ?? void 0
|
|
};
|
|
} catch {
|
|
return result;
|
|
}
|
|
};
|
|
context.middlewares.push(validate);
|
|
}
|
|
}
|
|
const final = ({ search }) => {
|
|
const dest = context.dest;
|
|
if (!dest.search) return {};
|
|
if (dest.search === true) return search;
|
|
return functionalUpdate(dest.search, search);
|
|
};
|
|
context.middlewares.push(final);
|
|
const applyNext = (index, currentSearch, middlewares) => {
|
|
if (index >= middlewares.length) return currentSearch;
|
|
const middleware = middlewares[index];
|
|
const next = (newSearch) => {
|
|
return applyNext(index + 1, newSearch, middlewares);
|
|
};
|
|
return middleware({
|
|
search: currentSearch,
|
|
next
|
|
});
|
|
};
|
|
return function middleware(search, dest, _includeValidateSearch) {
|
|
context.dest = dest;
|
|
context._includeValidateSearch = _includeValidateSearch;
|
|
return applyNext(0, search, context.middlewares);
|
|
};
|
|
}
|
|
function findGlobalNotFoundRouteId(notFoundMode, routes) {
|
|
if (notFoundMode !== "root") for (let i = routes.length - 1; i >= 0; i--) {
|
|
const route = routes[i];
|
|
if (route.children) return route.id;
|
|
}
|
|
return rootRouteId;
|
|
}
|
|
function extractStrictParams(route, referenceParams, parsedParams, accumulatedParams) {
|
|
var _a;
|
|
const parseParams = ((_a = route.options.params) == null ? void 0 : _a.parse) ?? route.options.parseParams;
|
|
if (parseParams) if (route.options.skipRouteOnParseError) {
|
|
for (const key in referenceParams) if (key in parsedParams) accumulatedParams[key] = parsedParams[key];
|
|
} else {
|
|
const result = parseParams(accumulatedParams);
|
|
Object.assign(accumulatedParams, result);
|
|
}
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/defer.js
|
|
var TSR_DEFERRED_PROMISE = Symbol.for("TSR_DEFERRED_PROMISE");
|
|
function defer(_promise, options) {
|
|
const promise = _promise;
|
|
if (promise[TSR_DEFERRED_PROMISE]) return promise;
|
|
promise[TSR_DEFERRED_PROMISE] = { status: "pending" };
|
|
promise.then((data) => {
|
|
promise[TSR_DEFERRED_PROMISE].status = "success";
|
|
promise[TSR_DEFERRED_PROMISE].data = data;
|
|
}).catch((error) => {
|
|
promise[TSR_DEFERRED_PROMISE].status = "error";
|
|
promise[TSR_DEFERRED_PROMISE].error = {
|
|
data: ((options == null ? void 0 : options.serializeError) ?? defaultSerializeError)(error),
|
|
__isServerError: true
|
|
};
|
|
});
|
|
return promise;
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/link.js
|
|
var preloadWarning = "Error preloading route! ☝️";
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/manifest.js
|
|
function getAssetCrossOrigin(assetCrossOrigin, kind) {
|
|
if (!assetCrossOrigin) return;
|
|
if (typeof assetCrossOrigin === "string") return assetCrossOrigin;
|
|
return assetCrossOrigin[kind];
|
|
}
|
|
function resolveManifestAssetLink(link2) {
|
|
if (typeof link2 === "string") return {
|
|
href: link2,
|
|
crossOrigin: void 0
|
|
};
|
|
return link2;
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/Matches.js
|
|
var isMatch = (match, path) => {
|
|
const parts = path.split(".");
|
|
let part;
|
|
let i = 0;
|
|
let value = match;
|
|
while ((part = parts[i++]) != null && value != null) value = value[part];
|
|
return value != null;
|
|
};
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/route.js
|
|
var BaseRoute = class {
|
|
get to() {
|
|
return this._to;
|
|
}
|
|
get id() {
|
|
return this._id;
|
|
}
|
|
get path() {
|
|
return this._path;
|
|
}
|
|
get fullPath() {
|
|
return this._fullPath;
|
|
}
|
|
constructor(options) {
|
|
this.init = (opts) => {
|
|
var _a, _b;
|
|
this.originalIndex = opts.originalIndex;
|
|
const options2 = this.options;
|
|
const isRoot = !(options2 == null ? void 0 : options2.path) && !(options2 == null ? void 0 : options2.id);
|
|
this.parentRoute = (_b = (_a = this.options).getParentRoute) == null ? void 0 : _b.call(_a);
|
|
if (isRoot) this._path = rootRouteId;
|
|
else if (!this.parentRoute) {
|
|
if (true) throw new Error(`Invariant failed: Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance.`);
|
|
invariant();
|
|
}
|
|
let path = isRoot ? rootRouteId : options2 == null ? void 0 : options2.path;
|
|
if (path && path !== "/") path = trimPathLeft(path);
|
|
const customId = (options2 == null ? void 0 : options2.id) || path;
|
|
let id = isRoot ? rootRouteId : joinPaths([this.parentRoute.id === "__root__" ? "" : this.parentRoute.id, customId]);
|
|
if (path === "__root__") path = "/";
|
|
if (id !== "__root__") id = joinPaths(["/", id]);
|
|
const fullPath = id === "__root__" ? "/" : joinPaths([this.parentRoute.fullPath, path]);
|
|
this._path = path;
|
|
this._id = id;
|
|
this._fullPath = fullPath;
|
|
this._to = trimPathRight2(fullPath);
|
|
};
|
|
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.redirect = (opts) => redirect({
|
|
from: this.fullPath,
|
|
...opts
|
|
});
|
|
this.options = options || {};
|
|
this.isRoot = !(options == null ? void 0 : options.getParentRoute);
|
|
if ((options == null ? void 0 : options.id) && (options == null ? void 0 : options.path)) throw new Error(`Route cannot have both an 'id' and a 'path' option.`);
|
|
}
|
|
};
|
|
var BaseRouteApi = class {
|
|
constructor({ id }) {
|
|
this.notFound = (opts) => {
|
|
return notFound({
|
|
routeId: this.id,
|
|
...opts
|
|
});
|
|
};
|
|
this.redirect = (opts) => redirect({
|
|
from: this.id,
|
|
...opts
|
|
});
|
|
this.id = id;
|
|
}
|
|
};
|
|
var BaseRootRoute = class extends BaseRoute {
|
|
constructor(options) {
|
|
super(options);
|
|
}
|
|
};
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/config.js
|
|
var createRouterConfig = (options) => {
|
|
return {
|
|
serializationAdapters: options.serializationAdapters,
|
|
defaultSsr: options.defaultSsr
|
|
};
|
|
};
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/searchMiddleware.js
|
|
function retainSearchParams(keys) {
|
|
return ({ search, next }) => {
|
|
const result = next(search);
|
|
if (keys === true) return {
|
|
...search,
|
|
...result
|
|
};
|
|
const copy = { ...result };
|
|
keys.forEach((key) => {
|
|
if (!(key in copy)) copy[key] = search[key];
|
|
});
|
|
return copy;
|
|
};
|
|
}
|
|
function stripSearchParams(input) {
|
|
return ({ search, next }) => {
|
|
if (input === true) return {};
|
|
const result = { ...next(search) };
|
|
if (Array.isArray(input)) input.forEach((key) => {
|
|
delete result[key];
|
|
});
|
|
else Object.entries(input).forEach(([key, value]) => {
|
|
if (deepEqual(result[key], value)) delete result[key];
|
|
});
|
|
return result;
|
|
};
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/hash-scroll.js
|
|
function handleHashScroll(router) {
|
|
if (typeof document !== "undefined" && document.querySelector) {
|
|
const location = router.stores.location.get();
|
|
const hashScrollIntoViewOptions = location.state.__hashScrollIntoViewOptions ?? true;
|
|
if (hashScrollIntoViewOptions && location.hash !== "") {
|
|
const el = document.getElementById(location.hash);
|
|
if (el) el.scrollIntoView(hashScrollIntoViewOptions);
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/seroval/dist/esm/development/index.mjs
|
|
var Feature = ((Feature2) => {
|
|
Feature2[Feature2["AggregateError"] = 1] = "AggregateError";
|
|
Feature2[Feature2["ArrowFunction"] = 2] = "ArrowFunction";
|
|
Feature2[Feature2["ErrorPrototypeStack"] = 4] = "ErrorPrototypeStack";
|
|
Feature2[Feature2["ObjectAssign"] = 8] = "ObjectAssign";
|
|
Feature2[Feature2["BigIntTypedArray"] = 16] = "BigIntTypedArray";
|
|
Feature2[Feature2["RegExp"] = 32] = "RegExp";
|
|
return Feature2;
|
|
})(Feature || {});
|
|
var ALL_ENABLED = 1 | 2 | 4 | 8 | 16 | 32;
|
|
var SYM_ASYNC_ITERATOR = Symbol.asyncIterator;
|
|
var SYM_HAS_INSTANCE = Symbol.hasInstance;
|
|
var SYM_IS_CONCAT_SPREADABLE = Symbol.isConcatSpreadable;
|
|
var SYM_ITERATOR = Symbol.iterator;
|
|
var SYM_MATCH = Symbol.match;
|
|
var SYM_MATCH_ALL = Symbol.matchAll;
|
|
var SYM_REPLACE = Symbol.replace;
|
|
var SYM_SEARCH = Symbol.search;
|
|
var SYM_SPECIES = Symbol.species;
|
|
var SYM_SPLIT = Symbol.split;
|
|
var SYM_TO_PRIMITIVE = Symbol.toPrimitive;
|
|
var SYM_TO_STRING_TAG = Symbol.toStringTag;
|
|
var SYM_UNSCOPABLES = Symbol.unscopables;
|
|
var INV_SYMBOL_REF = {
|
|
[SYM_ASYNC_ITERATOR]: 0,
|
|
[SYM_HAS_INSTANCE]: 1,
|
|
[SYM_IS_CONCAT_SPREADABLE]: 2,
|
|
[SYM_ITERATOR]: 3,
|
|
[SYM_MATCH]: 4,
|
|
[SYM_MATCH_ALL]: 5,
|
|
[SYM_REPLACE]: 6,
|
|
[SYM_SEARCH]: 7,
|
|
[SYM_SPECIES]: 8,
|
|
[SYM_SPLIT]: 9,
|
|
[SYM_TO_PRIMITIVE]: 10,
|
|
[SYM_TO_STRING_TAG]: 11,
|
|
[SYM_UNSCOPABLES]: 12
|
|
/* Unscopables */
|
|
};
|
|
var NIL = void 0;
|
|
var CONSTANT_VAL = {
|
|
[
|
|
2
|
|
/* True */
|
|
]: true,
|
|
[
|
|
3
|
|
/* False */
|
|
]: false,
|
|
[
|
|
1
|
|
/* Undefined */
|
|
]: NIL,
|
|
[
|
|
0
|
|
/* Null */
|
|
]: null,
|
|
[
|
|
4
|
|
/* NegZero */
|
|
]: -0,
|
|
[
|
|
5
|
|
/* Inf */
|
|
]: Number.POSITIVE_INFINITY,
|
|
[
|
|
6
|
|
/* NegInf */
|
|
]: Number.NEGATIVE_INFINITY,
|
|
[
|
|
7
|
|
/* Nan */
|
|
]: Number.NaN
|
|
};
|
|
function createSerovalNode(t, i, s, c, m, p, e, a, f, b, o, l) {
|
|
return {
|
|
t,
|
|
i,
|
|
s,
|
|
c,
|
|
m,
|
|
p,
|
|
e,
|
|
a,
|
|
f,
|
|
b,
|
|
o,
|
|
l
|
|
};
|
|
}
|
|
function createConstantNode(value) {
|
|
return createSerovalNode(
|
|
2,
|
|
NIL,
|
|
value,
|
|
NIL,
|
|
NIL,
|
|
NIL,
|
|
NIL,
|
|
NIL,
|
|
NIL,
|
|
NIL,
|
|
NIL,
|
|
NIL
|
|
);
|
|
}
|
|
var TRUE_NODE = createConstantNode(
|
|
2
|
|
/* True */
|
|
);
|
|
var FALSE_NODE = createConstantNode(
|
|
3
|
|
/* False */
|
|
);
|
|
var UNDEFINED_NODE = createConstantNode(
|
|
1
|
|
/* Undefined */
|
|
);
|
|
var NULL_NODE = createConstantNode(
|
|
0
|
|
/* Null */
|
|
);
|
|
var NEG_ZERO_NODE = createConstantNode(
|
|
4
|
|
/* NegZero */
|
|
);
|
|
var INFINITY_NODE = createConstantNode(
|
|
5
|
|
/* Inf */
|
|
);
|
|
var NEG_INFINITY_NODE = createConstantNode(
|
|
6
|
|
/* NegInf */
|
|
);
|
|
var NAN_NODE = createConstantNode(
|
|
7
|
|
/* Nan */
|
|
);
|
|
var REFERENCES_KEY = "__SEROVAL_REFS__";
|
|
var GLOBAL_CONTEXT_REFERENCES = "$R";
|
|
var GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;
|
|
var INV_REFERENCE = /* @__PURE__ */ new Map();
|
|
if (typeof globalThis !== "undefined") {
|
|
Object.defineProperty(globalThis, REFERENCES_KEY, {
|
|
value: INV_REFERENCE,
|
|
configurable: true,
|
|
writable: false,
|
|
enumerable: false
|
|
});
|
|
} else if (typeof window !== "undefined") {
|
|
Object.defineProperty(window, REFERENCES_KEY, {
|
|
value: INV_REFERENCE,
|
|
configurable: true,
|
|
writable: false,
|
|
enumerable: false
|
|
});
|
|
} else if (typeof self !== "undefined") {
|
|
Object.defineProperty(self, REFERENCES_KEY, {
|
|
value: INV_REFERENCE,
|
|
configurable: true,
|
|
writable: false,
|
|
enumerable: false
|
|
});
|
|
} else if (typeof global !== "undefined") {
|
|
Object.defineProperty(global, REFERENCES_KEY, {
|
|
value: INV_REFERENCE,
|
|
configurable: true,
|
|
writable: false,
|
|
enumerable: false
|
|
});
|
|
}
|
|
var { toString: objectToString } = Object.prototype;
|
|
var PROMISE_CONSTRUCTOR = () => {
|
|
const resolver = {
|
|
p: 0,
|
|
s: 0,
|
|
f: 0
|
|
};
|
|
resolver.p = new Promise((resolve, reject) => {
|
|
resolver.s = resolve;
|
|
resolver.f = reject;
|
|
});
|
|
return resolver;
|
|
};
|
|
var PROMISE_SUCCESS = (resolver, data) => {
|
|
resolver.s(data);
|
|
resolver.p.s = 1;
|
|
resolver.p.v = data;
|
|
};
|
|
var PROMISE_FAILURE = (resolver, data) => {
|
|
resolver.f(data);
|
|
resolver.p.s = 2;
|
|
resolver.p.v = data;
|
|
};
|
|
var SERIALIZED_PROMISE_CONSTRUCTOR = PROMISE_CONSTRUCTOR.toString();
|
|
var SERIALIZED_PROMISE_SUCCESS = PROMISE_SUCCESS.toString();
|
|
var SERIALIZED_PROMISE_FAILURE = PROMISE_FAILURE.toString();
|
|
var STREAM_CONSTRUCTOR = () => {
|
|
const buffer = [];
|
|
const listeners = [];
|
|
let alive = true;
|
|
let success = false;
|
|
let count = 0;
|
|
const flush2 = (value, mode, x) => {
|
|
for (x = 0; x < count; x++) {
|
|
if (listeners[x]) {
|
|
listeners[x][mode](value);
|
|
}
|
|
}
|
|
};
|
|
const up = (listener, x, z, current) => {
|
|
for (x = 0, z = buffer.length; x < z; x++) {
|
|
current = buffer[x];
|
|
if (!alive && x === z - 1) {
|
|
listener[success ? "return" : "throw"](current);
|
|
} else {
|
|
listener.next(current);
|
|
}
|
|
}
|
|
};
|
|
const on = (listener, temp) => {
|
|
if (alive) {
|
|
temp = count++;
|
|
listeners[temp] = listener;
|
|
}
|
|
up(listener);
|
|
return () => {
|
|
if (alive) {
|
|
listeners[temp] = listeners[count];
|
|
listeners[count--] = void 0;
|
|
}
|
|
};
|
|
};
|
|
return {
|
|
__SEROVAL_STREAM__: true,
|
|
on: (listener) => on(listener),
|
|
next: (value) => {
|
|
if (alive) {
|
|
buffer.push(value);
|
|
flush2(value, "next");
|
|
}
|
|
},
|
|
throw: (value) => {
|
|
if (alive) {
|
|
buffer.push(value);
|
|
flush2(value, "throw");
|
|
alive = false;
|
|
success = false;
|
|
listeners.length = 0;
|
|
}
|
|
},
|
|
return: (value) => {
|
|
if (alive) {
|
|
buffer.push(value);
|
|
flush2(value, "return");
|
|
alive = false;
|
|
success = true;
|
|
listeners.length = 0;
|
|
}
|
|
}
|
|
};
|
|
};
|
|
var SERIALIZED_STREAM_CONSTRUCTOR = STREAM_CONSTRUCTOR.toString();
|
|
var ITERATOR_CONSTRUCTOR = (symbol) => (sequence) => () => {
|
|
let index = 0;
|
|
const instance = {
|
|
[symbol]: () => instance,
|
|
next: () => {
|
|
if (index > sequence.d) {
|
|
return {
|
|
done: true,
|
|
value: void 0
|
|
};
|
|
}
|
|
const currentIndex = index++;
|
|
const data = sequence.v[currentIndex];
|
|
if (currentIndex === sequence.t) {
|
|
throw data;
|
|
}
|
|
return {
|
|
done: currentIndex === sequence.d,
|
|
value: data
|
|
};
|
|
}
|
|
};
|
|
return instance;
|
|
};
|
|
var SERIALIZED_ITERATOR_CONSTRUCTOR = ITERATOR_CONSTRUCTOR.toString();
|
|
var ASYNC_ITERATOR_CONSTRUCTOR = (symbol, createPromise) => (stream) => () => {
|
|
let count = 0;
|
|
let doneAt = -1;
|
|
let isThrow = false;
|
|
const buffer = [];
|
|
const pending = [];
|
|
const finalize = (i = 0, len = pending.length) => {
|
|
for (; i < len; i++) {
|
|
pending[i].s({
|
|
done: true,
|
|
value: void 0
|
|
});
|
|
}
|
|
};
|
|
stream.on({
|
|
next: (value) => {
|
|
const temp = pending.shift();
|
|
if (temp) {
|
|
temp.s({ done: false, value });
|
|
}
|
|
buffer.push(value);
|
|
},
|
|
throw: (value) => {
|
|
const temp = pending.shift();
|
|
if (temp) {
|
|
temp.f(value);
|
|
}
|
|
finalize();
|
|
doneAt = buffer.length;
|
|
isThrow = true;
|
|
buffer.push(value);
|
|
},
|
|
return: (value) => {
|
|
const temp = pending.shift();
|
|
if (temp) {
|
|
temp.s({ done: true, value });
|
|
}
|
|
finalize();
|
|
doneAt = buffer.length;
|
|
buffer.push(value);
|
|
}
|
|
});
|
|
const instance = {
|
|
[symbol]: () => instance,
|
|
next: () => {
|
|
if (doneAt === -1) {
|
|
const index2 = count++;
|
|
if (index2 >= buffer.length) {
|
|
const temp = createPromise();
|
|
pending.push(temp);
|
|
return temp.p;
|
|
}
|
|
return {
|
|
done: false,
|
|
value: buffer[index2]
|
|
};
|
|
}
|
|
if (count > doneAt) {
|
|
return {
|
|
done: true,
|
|
value: void 0
|
|
};
|
|
}
|
|
const index = count++;
|
|
const value = buffer[index];
|
|
if (index !== doneAt) {
|
|
return {
|
|
done: false,
|
|
value
|
|
};
|
|
}
|
|
if (isThrow) {
|
|
throw value;
|
|
}
|
|
return {
|
|
done: true,
|
|
value
|
|
};
|
|
}
|
|
};
|
|
return instance;
|
|
};
|
|
var SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR = ASYNC_ITERATOR_CONSTRUCTOR.toString();
|
|
var ARRAY_BUFFER_CONSTRUCTOR = (b64) => {
|
|
const decoded = atob(b64);
|
|
const length = decoded.length;
|
|
const arr = new Uint8Array(length);
|
|
for (let i = 0; i < length; i++) {
|
|
arr[i] = decoded.charCodeAt(i);
|
|
}
|
|
return arr.buffer;
|
|
};
|
|
var SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR = ARRAY_BUFFER_CONSTRUCTOR.toString();
|
|
var createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
|
|
function createStream() {
|
|
return STREAM_CONSTRUCTOR();
|
|
}
|
|
var createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(
|
|
SYM_ASYNC_ITERATOR,
|
|
PROMISE_CONSTRUCTOR
|
|
);
|
|
var SerovalMode = ((SerovalMode2) => {
|
|
SerovalMode2[SerovalMode2["Vanilla"] = 1] = "Vanilla";
|
|
SerovalMode2[SerovalMode2["Cross"] = 2] = "Cross";
|
|
return SerovalMode2;
|
|
})(SerovalMode || {});
|
|
function createPlugin(plugin) {
|
|
return plugin;
|
|
}
|
|
var RETURN = () => T;
|
|
var SERIALIZED_RETURN = RETURN.toString();
|
|
var IS_MODERN = /=>/.test(SERIALIZED_RETURN);
|
|
var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
|
|
var REF_START_CHARS_LEN = REF_START_CHARS.length;
|
|
var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
|
|
var REF_CHARS_LEN = REF_CHARS.length;
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/ssr/serializer/transformer.js
|
|
function createSerializationAdapter(opts) {
|
|
return opts;
|
|
}
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/ssr/serializer/RawStream.js
|
|
var RawStream = class {
|
|
constructor(stream, options) {
|
|
this.stream = stream;
|
|
this.hint = (options == null ? void 0 : options.hint) ?? "binary";
|
|
}
|
|
};
|
|
var BufferCtor = globalThis.Buffer;
|
|
var hasNodeBuffer = !!BufferCtor && typeof BufferCtor.from === "function";
|
|
function uint8ArrayToBase64(bytes) {
|
|
if (bytes.length === 0) return "";
|
|
if (hasNodeBuffer) return BufferCtor.from(bytes).toString("base64");
|
|
const CHUNK_SIZE = 32768;
|
|
const chunks = [];
|
|
for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
|
|
const chunk = bytes.subarray(i, i + CHUNK_SIZE);
|
|
chunks.push(String.fromCharCode.apply(null, chunk));
|
|
}
|
|
return btoa(chunks.join(""));
|
|
}
|
|
function base64ToUint8Array(base64) {
|
|
if (base64.length === 0) return new Uint8Array(0);
|
|
if (hasNodeBuffer) {
|
|
const buf = BufferCtor.from(base64, "base64");
|
|
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
|
|
}
|
|
const binary = atob(base64);
|
|
const bytes = new Uint8Array(binary.length);
|
|
for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
|
|
return bytes;
|
|
}
|
|
var RAW_STREAM_FACTORY_BINARY = /* @__PURE__ */ Object.create(null);
|
|
var RAW_STREAM_FACTORY_TEXT = /* @__PURE__ */ Object.create(null);
|
|
var RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY = (stream) => new ReadableStream({ start(controller) {
|
|
stream.on({
|
|
next(base64) {
|
|
try {
|
|
controller.enqueue(base64ToUint8Array(base64));
|
|
} catch {
|
|
}
|
|
},
|
|
throw(error) {
|
|
controller.error(error);
|
|
},
|
|
return() {
|
|
try {
|
|
controller.close();
|
|
} catch {
|
|
}
|
|
}
|
|
});
|
|
} });
|
|
var textEncoderForFactory = new TextEncoder();
|
|
var RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT = (stream) => {
|
|
return new ReadableStream({ start(controller) {
|
|
stream.on({
|
|
next(value) {
|
|
try {
|
|
if (typeof value === "string") controller.enqueue(textEncoderForFactory.encode(value));
|
|
else controller.enqueue(base64ToUint8Array(value.$b64));
|
|
} catch {
|
|
}
|
|
},
|
|
throw(error) {
|
|
controller.error(error);
|
|
},
|
|
return() {
|
|
try {
|
|
controller.close();
|
|
} catch {
|
|
}
|
|
}
|
|
});
|
|
} });
|
|
};
|
|
var FACTORY_BINARY = `(s=>new ReadableStream({start(c){s.on({next(b){try{const d=atob(b),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}catch(_){}},throw(e){c.error(e)},return(){try{c.close()}catch(_){}}})}}))`;
|
|
var FACTORY_TEXT = `(s=>{const e=new TextEncoder();return new ReadableStream({start(c){s.on({next(v){try{if(typeof v==='string'){c.enqueue(e.encode(v))}else{const d=atob(v.$b64),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}}catch(_){}},throw(x){c.error(x)},return(){try{c.close()}catch(_){}}})}})})`;
|
|
function toBinaryStream(readable) {
|
|
const stream = createStream();
|
|
const reader = readable.getReader();
|
|
(async () => {
|
|
try {
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) {
|
|
stream.return(void 0);
|
|
break;
|
|
}
|
|
stream.next(uint8ArrayToBase64(value));
|
|
}
|
|
} catch (error) {
|
|
stream.throw(error);
|
|
} finally {
|
|
reader.releaseLock();
|
|
}
|
|
})();
|
|
return stream;
|
|
}
|
|
function toTextStream(readable) {
|
|
const stream = createStream();
|
|
const reader = readable.getReader();
|
|
const decoder = new TextDecoder("utf-8", { fatal: true });
|
|
(async () => {
|
|
try {
|
|
while (true) {
|
|
const { done, value } = await reader.read();
|
|
if (done) {
|
|
try {
|
|
const remaining = decoder.decode();
|
|
if (remaining.length > 0) stream.next(remaining);
|
|
} catch {
|
|
}
|
|
stream.return(void 0);
|
|
break;
|
|
}
|
|
try {
|
|
const text = decoder.decode(value, { stream: true });
|
|
if (text.length > 0) stream.next(text);
|
|
} catch {
|
|
stream.next({ $b64: uint8ArrayToBase64(value) });
|
|
}
|
|
}
|
|
} catch (error) {
|
|
stream.throw(error);
|
|
} finally {
|
|
reader.releaseLock();
|
|
}
|
|
})();
|
|
return stream;
|
|
}
|
|
var RawStreamSSRPlugin = createPlugin({
|
|
tag: "tss/RawStream",
|
|
extends: [createPlugin({
|
|
tag: "tss/RawStreamFactory",
|
|
test(value) {
|
|
return value === RAW_STREAM_FACTORY_BINARY;
|
|
},
|
|
parse: {
|
|
sync(_value, _ctx, _data) {
|
|
return {};
|
|
},
|
|
async async(_value, _ctx, _data) {
|
|
return {};
|
|
},
|
|
stream(_value, _ctx, _data) {
|
|
return {};
|
|
}
|
|
},
|
|
serialize(_node, _ctx, _data) {
|
|
return FACTORY_BINARY;
|
|
},
|
|
deserialize(_node, _ctx, _data) {
|
|
return RAW_STREAM_FACTORY_BINARY;
|
|
}
|
|
}), createPlugin({
|
|
tag: "tss/RawStreamFactoryText",
|
|
test(value) {
|
|
return value === RAW_STREAM_FACTORY_TEXT;
|
|
},
|
|
parse: {
|
|
sync(_value, _ctx, _data) {
|
|
return {};
|
|
},
|
|
async async(_value, _ctx, _data) {
|
|
return {};
|
|
},
|
|
stream(_value, _ctx, _data) {
|
|
return {};
|
|
}
|
|
},
|
|
serialize(_node, _ctx, _data) {
|
|
return FACTORY_TEXT;
|
|
},
|
|
deserialize(_node, _ctx, _data) {
|
|
return RAW_STREAM_FACTORY_TEXT;
|
|
}
|
|
})],
|
|
test(value) {
|
|
return value instanceof RawStream;
|
|
},
|
|
parse: {
|
|
sync(value, ctx, _data) {
|
|
const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
|
|
return {
|
|
hint: ctx.parse(value.hint),
|
|
factory: ctx.parse(factory),
|
|
stream: ctx.parse(createStream())
|
|
};
|
|
},
|
|
async async(value, ctx, _data) {
|
|
const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
|
|
const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
|
|
return {
|
|
hint: await ctx.parse(value.hint),
|
|
factory: await ctx.parse(factory),
|
|
stream: await ctx.parse(encodedStream)
|
|
};
|
|
},
|
|
stream(value, ctx, _data) {
|
|
const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
|
|
const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
|
|
return {
|
|
hint: ctx.parse(value.hint),
|
|
factory: ctx.parse(factory),
|
|
stream: ctx.parse(encodedStream)
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx, _data) {
|
|
return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
|
|
},
|
|
deserialize(node, ctx, _data) {
|
|
const stream = ctx.deserialize(node.stream);
|
|
return ctx.deserialize(node.hint) === "text" ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream) : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream);
|
|
}
|
|
});
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/ssr/serializer/ShallowErrorPlugin.js
|
|
var ShallowErrorPlugin = createPlugin({
|
|
tag: "$TSR/Error",
|
|
test(value) {
|
|
return value instanceof Error;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return { message: ctx.parse(value.message) };
|
|
},
|
|
async async(value, ctx) {
|
|
return { message: await ctx.parse(value.message) };
|
|
},
|
|
stream(value, ctx) {
|
|
return { message: ctx.parse(value.message) };
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new Error(" + ctx.serialize(node.message) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new Error(ctx.deserialize(node.message));
|
|
}
|
|
});
|
|
|
|
// node_modules/seroval-plugins/dist/esm/development/web.mjs
|
|
var PROMISE_TO_ABORT_SIGNAL = (promise) => {
|
|
const controller = new AbortController();
|
|
const abort = controller.abort.bind(controller);
|
|
promise.then(abort, abort);
|
|
return controller;
|
|
};
|
|
function resolveAbortSignalResult(resolve) {
|
|
resolve(this.reason);
|
|
}
|
|
function resolveAbortSignal(resolve) {
|
|
this.addEventListener("abort", resolveAbortSignalResult.bind(this, resolve), {
|
|
once: true
|
|
});
|
|
}
|
|
function abortSignalToPromise(signal) {
|
|
return new Promise(resolveAbortSignal.bind(signal));
|
|
}
|
|
var ABORT_CONTROLLER = {};
|
|
var AbortControllerFactoryPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/AbortControllerFactoryPlugin",
|
|
test(value) {
|
|
return value === ABORT_CONTROLLER;
|
|
},
|
|
parse: {
|
|
sync() {
|
|
return ABORT_CONTROLLER;
|
|
},
|
|
async async() {
|
|
return await Promise.resolve(ABORT_CONTROLLER);
|
|
},
|
|
stream() {
|
|
return ABORT_CONTROLLER;
|
|
}
|
|
},
|
|
serialize() {
|
|
return PROMISE_TO_ABORT_SIGNAL.toString();
|
|
},
|
|
deserialize() {
|
|
return PROMISE_TO_ABORT_SIGNAL;
|
|
}
|
|
});
|
|
var AbortSignalPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/AbortSignal",
|
|
extends: [AbortControllerFactoryPlugin],
|
|
test(value) {
|
|
if (typeof AbortSignal === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof AbortSignal;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
if (value.aborted) {
|
|
return {
|
|
reason: ctx.parse(value.reason)
|
|
};
|
|
}
|
|
return {};
|
|
},
|
|
async async(value, ctx) {
|
|
if (value.aborted) {
|
|
return {
|
|
reason: await ctx.parse(value.reason)
|
|
};
|
|
}
|
|
const result = await abortSignalToPromise(value);
|
|
return {
|
|
reason: await ctx.parse(result)
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
if (value.aborted) {
|
|
return {
|
|
reason: ctx.parse(value.reason)
|
|
};
|
|
}
|
|
const promise = abortSignalToPromise(value);
|
|
return {
|
|
factory: ctx.parse(ABORT_CONTROLLER),
|
|
controller: ctx.parse(promise)
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
if (node.reason) {
|
|
return "AbortSignal.abort(" + ctx.serialize(node.reason) + ")";
|
|
}
|
|
if (node.controller && node.factory) {
|
|
return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.controller) + ").signal";
|
|
}
|
|
return "(new AbortController).signal";
|
|
},
|
|
deserialize(node, ctx) {
|
|
if (node.reason) {
|
|
return AbortSignal.abort(ctx.deserialize(node.reason));
|
|
}
|
|
if (node.controller) {
|
|
return PROMISE_TO_ABORT_SIGNAL(ctx.deserialize(node.controller)).signal;
|
|
}
|
|
const controller = new AbortController();
|
|
return controller.signal;
|
|
}
|
|
});
|
|
var BlobPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/Blob",
|
|
test(value) {
|
|
if (typeof Blob === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof Blob;
|
|
},
|
|
parse: {
|
|
async async(value, ctx) {
|
|
return {
|
|
type: await ctx.parse(value.type),
|
|
buffer: await ctx.parse(await value.arrayBuffer())
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new Blob([" + ctx.serialize(node.buffer) + "],{type:" + ctx.serialize(node.type) + "})";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new Blob([ctx.deserialize(node.buffer)], {
|
|
type: ctx.deserialize(node.type)
|
|
});
|
|
}
|
|
});
|
|
function createCustomEventOptions(current) {
|
|
return {
|
|
detail: current.detail,
|
|
bubbles: current.bubbles,
|
|
cancelable: current.cancelable,
|
|
composed: current.composed
|
|
};
|
|
}
|
|
var CustomEventPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/CustomEvent",
|
|
test(value) {
|
|
if (typeof CustomEvent === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof CustomEvent;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
type: ctx.parse(value.type),
|
|
options: ctx.parse(createCustomEventOptions(value))
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
type: await ctx.parse(value.type),
|
|
options: await ctx.parse(createCustomEventOptions(value))
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
type: ctx.parse(value.type),
|
|
options: ctx.parse(createCustomEventOptions(value))
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new CustomEvent(" + ctx.serialize(node.type) + "," + ctx.serialize(node.options) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new CustomEvent(
|
|
ctx.deserialize(node.type),
|
|
ctx.deserialize(node.options)
|
|
);
|
|
}
|
|
});
|
|
var DOMExceptionPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/DOMException",
|
|
test(value) {
|
|
if (typeof DOMException === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof DOMException;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
name: ctx.parse(value.name),
|
|
message: ctx.parse(value.message)
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
name: await ctx.parse(value.name),
|
|
message: await ctx.parse(value.message)
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
name: ctx.parse(value.name),
|
|
message: ctx.parse(value.message)
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new DOMException(" + ctx.serialize(node.message) + "," + ctx.serialize(node.name) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new DOMException(
|
|
ctx.deserialize(node.message),
|
|
ctx.deserialize(node.name)
|
|
);
|
|
}
|
|
});
|
|
function createEventOptions(current) {
|
|
return {
|
|
bubbles: current.bubbles,
|
|
cancelable: current.cancelable,
|
|
composed: current.composed
|
|
};
|
|
}
|
|
var EventPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/Event",
|
|
test(value) {
|
|
if (typeof Event === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof Event;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
type: ctx.parse(value.type),
|
|
options: ctx.parse(createEventOptions(value))
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
type: await ctx.parse(value.type),
|
|
options: await ctx.parse(createEventOptions(value))
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
type: ctx.parse(value.type),
|
|
options: ctx.parse(createEventOptions(value))
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new Event(" + ctx.serialize(node.type) + "," + ctx.serialize(node.options) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new Event(
|
|
ctx.deserialize(node.type),
|
|
ctx.deserialize(node.options)
|
|
);
|
|
}
|
|
});
|
|
var FilePlugin = createPlugin({
|
|
tag: "seroval-plugins/web/File",
|
|
test(value) {
|
|
if (typeof File === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof File;
|
|
},
|
|
parse: {
|
|
async async(value, ctx) {
|
|
return {
|
|
name: await ctx.parse(value.name),
|
|
options: await ctx.parse({
|
|
type: value.type,
|
|
lastModified: value.lastModified
|
|
}),
|
|
buffer: await ctx.parse(await value.arrayBuffer())
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new File([" + ctx.serialize(node.buffer) + "]," + ctx.serialize(node.name) + "," + ctx.serialize(node.options) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new File(
|
|
[ctx.deserialize(node.buffer)],
|
|
ctx.deserialize(node.name),
|
|
ctx.deserialize(node.options)
|
|
);
|
|
}
|
|
});
|
|
var file_default = FilePlugin;
|
|
function convertFormData(instance) {
|
|
const items = [];
|
|
instance.forEach((value, key) => {
|
|
items.push([key, value]);
|
|
});
|
|
return items;
|
|
}
|
|
var FORM_DATA_FACTORY = {};
|
|
var FORM_DATA_FACTORY_CONSTRUCTOR = (e, f = new FormData(), i = 0, s = e.length, t) => {
|
|
for (; i < s; i++) {
|
|
t = e[i];
|
|
f.append(t[0], t[1]);
|
|
}
|
|
return f;
|
|
};
|
|
var FormDataFactoryPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/FormDataFactory",
|
|
test(value) {
|
|
return value === FORM_DATA_FACTORY;
|
|
},
|
|
parse: {
|
|
sync() {
|
|
return FORM_DATA_FACTORY;
|
|
},
|
|
async async() {
|
|
return await Promise.resolve(FORM_DATA_FACTORY);
|
|
},
|
|
stream() {
|
|
return FORM_DATA_FACTORY;
|
|
}
|
|
},
|
|
serialize() {
|
|
return FORM_DATA_FACTORY_CONSTRUCTOR.toString();
|
|
},
|
|
deserialize() {
|
|
return FORM_DATA_FACTORY;
|
|
}
|
|
});
|
|
var FormDataPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/FormData",
|
|
extends: [file_default, FormDataFactoryPlugin],
|
|
test(value) {
|
|
if (typeof FormData === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof FormData;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
factory: ctx.parse(FORM_DATA_FACTORY),
|
|
entries: ctx.parse(convertFormData(value))
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
factory: await ctx.parse(FORM_DATA_FACTORY),
|
|
entries: await ctx.parse(convertFormData(value))
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
factory: ctx.parse(FORM_DATA_FACTORY),
|
|
entries: ctx.parse(convertFormData(value))
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.entries) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return FORM_DATA_FACTORY_CONSTRUCTOR(
|
|
ctx.deserialize(node.entries)
|
|
);
|
|
}
|
|
});
|
|
function convertHeaders(instance) {
|
|
const items = [];
|
|
instance.forEach((value, key) => {
|
|
items.push([key, value]);
|
|
});
|
|
return items;
|
|
}
|
|
var HeadersPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/Headers",
|
|
test(value) {
|
|
if (typeof Headers === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof Headers;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
value: ctx.parse(convertHeaders(value))
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
value: await ctx.parse(convertHeaders(value))
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
value: ctx.parse(convertHeaders(value))
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new Headers(" + ctx.serialize(node.value) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new Headers(ctx.deserialize(node.value));
|
|
}
|
|
});
|
|
var headers_default = HeadersPlugin;
|
|
var ImageDataPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/ImageData",
|
|
test(value) {
|
|
if (typeof ImageData === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof ImageData;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
data: ctx.parse(value.data),
|
|
width: ctx.parse(value.width),
|
|
height: ctx.parse(value.height),
|
|
options: ctx.parse({
|
|
colorSpace: value.colorSpace
|
|
})
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
data: await ctx.parse(value.data),
|
|
width: await ctx.parse(value.width),
|
|
height: await ctx.parse(value.height),
|
|
options: await ctx.parse({
|
|
colorSpace: value.colorSpace
|
|
})
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
data: ctx.parse(value.data),
|
|
width: ctx.parse(value.width),
|
|
height: ctx.parse(value.height),
|
|
options: ctx.parse({
|
|
colorSpace: value.colorSpace
|
|
})
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new ImageData(" + ctx.serialize(node.data) + "," + ctx.serialize(node.width) + "," + ctx.serialize(node.height) + "," + ctx.serialize(node.options) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new ImageData(
|
|
ctx.deserialize(node.data),
|
|
ctx.deserialize(node.width),
|
|
ctx.deserialize(node.height),
|
|
ctx.deserialize(node.options)
|
|
);
|
|
}
|
|
});
|
|
var READABLE_STREAM_FACTORY = {};
|
|
var READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream) => new ReadableStream({
|
|
start: (controller) => {
|
|
stream.on({
|
|
next: (value) => {
|
|
try {
|
|
controller.enqueue(value);
|
|
} catch (_error) {
|
|
}
|
|
},
|
|
throw: (value) => {
|
|
controller.error(value);
|
|
},
|
|
return: () => {
|
|
try {
|
|
controller.close();
|
|
} catch (_error) {
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
var ReadableStreamFactoryPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/ReadableStreamFactory",
|
|
test(value) {
|
|
return value === READABLE_STREAM_FACTORY;
|
|
},
|
|
parse: {
|
|
sync() {
|
|
return READABLE_STREAM_FACTORY;
|
|
},
|
|
async async() {
|
|
return await Promise.resolve(READABLE_STREAM_FACTORY);
|
|
},
|
|
stream() {
|
|
return READABLE_STREAM_FACTORY;
|
|
}
|
|
},
|
|
serialize() {
|
|
return READABLE_STREAM_FACTORY_CONSTRUCTOR.toString();
|
|
},
|
|
deserialize() {
|
|
return READABLE_STREAM_FACTORY;
|
|
}
|
|
});
|
|
function toStream(value) {
|
|
const stream = createStream();
|
|
const reader = value.getReader();
|
|
async function push() {
|
|
try {
|
|
const result = await reader.read();
|
|
if (result.done) {
|
|
stream.return(result.value);
|
|
} else {
|
|
stream.next(result.value);
|
|
await push();
|
|
}
|
|
} catch (error) {
|
|
stream.throw(error);
|
|
}
|
|
}
|
|
push().catch(() => {
|
|
});
|
|
return stream;
|
|
}
|
|
var ReadableStreamPlugin = createPlugin({
|
|
tag: "seroval/plugins/web/ReadableStream",
|
|
extends: [ReadableStreamFactoryPlugin],
|
|
test(value) {
|
|
if (typeof ReadableStream === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof ReadableStream;
|
|
},
|
|
parse: {
|
|
sync(_value, ctx) {
|
|
return {
|
|
factory: ctx.parse(READABLE_STREAM_FACTORY),
|
|
stream: ctx.parse(createStream())
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
factory: await ctx.parse(READABLE_STREAM_FACTORY),
|
|
stream: await ctx.parse(toStream(value))
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
factory: ctx.parse(READABLE_STREAM_FACTORY),
|
|
stream: ctx.parse(toStream(value))
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
const stream = ctx.deserialize(node.stream);
|
|
return READABLE_STREAM_FACTORY_CONSTRUCTOR(stream);
|
|
}
|
|
});
|
|
var readable_stream_default = ReadableStreamPlugin;
|
|
function createRequestOptions(current, body) {
|
|
return {
|
|
body,
|
|
cache: current.cache,
|
|
credentials: current.credentials,
|
|
headers: current.headers,
|
|
integrity: current.integrity,
|
|
keepalive: current.keepalive,
|
|
method: current.method,
|
|
mode: current.mode,
|
|
redirect: current.redirect,
|
|
referrer: current.referrer,
|
|
referrerPolicy: current.referrerPolicy
|
|
};
|
|
}
|
|
var RequestPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/Request",
|
|
extends: [readable_stream_default, headers_default],
|
|
test(value) {
|
|
if (typeof Request === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof Request;
|
|
},
|
|
parse: {
|
|
async async(value, ctx) {
|
|
return {
|
|
url: await ctx.parse(value.url),
|
|
options: await ctx.parse(
|
|
createRequestOptions(
|
|
value,
|
|
value.body && !value.bodyUsed ? await value.clone().arrayBuffer() : null
|
|
)
|
|
)
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
url: ctx.parse(value.url),
|
|
options: ctx.parse(
|
|
createRequestOptions(
|
|
value,
|
|
value.body && !value.bodyUsed ? value.clone().body : null
|
|
)
|
|
)
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new Request(" + ctx.serialize(node.url) + "," + ctx.serialize(node.options) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new Request(
|
|
ctx.deserialize(node.url),
|
|
ctx.deserialize(node.options)
|
|
);
|
|
}
|
|
});
|
|
function createResponseOptions(current) {
|
|
return {
|
|
headers: current.headers,
|
|
status: current.status,
|
|
statusText: current.statusText
|
|
};
|
|
}
|
|
var ResponsePlugin = createPlugin({
|
|
tag: "seroval-plugins/web/Response",
|
|
extends: [readable_stream_default, headers_default],
|
|
test(value) {
|
|
if (typeof Response === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof Response;
|
|
},
|
|
parse: {
|
|
async async(value, ctx) {
|
|
return {
|
|
body: await ctx.parse(
|
|
value.body && !value.bodyUsed ? await value.clone().arrayBuffer() : null
|
|
),
|
|
options: await ctx.parse(createResponseOptions(value))
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
body: ctx.parse(
|
|
value.body && !value.bodyUsed ? value.clone().body : null
|
|
),
|
|
options: ctx.parse(createResponseOptions(value))
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new Response(" + ctx.serialize(node.body) + "," + ctx.serialize(node.options) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new Response(
|
|
ctx.deserialize(node.body),
|
|
ctx.deserialize(node.options)
|
|
);
|
|
}
|
|
});
|
|
var URLPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/URL",
|
|
test(value) {
|
|
if (typeof URL === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof URL;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
value: ctx.parse(value.href)
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
value: await ctx.parse(value.href)
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
value: ctx.parse(value.href)
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new URL(" + ctx.serialize(node.value) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new URL(ctx.deserialize(node.value));
|
|
}
|
|
});
|
|
var URLSearchParamsPlugin = createPlugin({
|
|
tag: "seroval-plugins/web/URLSearchParams",
|
|
test(value) {
|
|
if (typeof URLSearchParams === "undefined") {
|
|
return false;
|
|
}
|
|
return value instanceof URLSearchParams;
|
|
},
|
|
parse: {
|
|
sync(value, ctx) {
|
|
return {
|
|
value: ctx.parse(value.toString())
|
|
};
|
|
},
|
|
async async(value, ctx) {
|
|
return {
|
|
value: await ctx.parse(value.toString())
|
|
};
|
|
},
|
|
stream(value, ctx) {
|
|
return {
|
|
value: ctx.parse(value.toString())
|
|
};
|
|
}
|
|
},
|
|
serialize(node, ctx) {
|
|
return "new URLSearchParams(" + ctx.serialize(node.value) + ")";
|
|
},
|
|
deserialize(node, ctx) {
|
|
return new URLSearchParams(ctx.deserialize(node.value));
|
|
}
|
|
});
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/awaited.js
|
|
var React$12 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
|
|
function useAwaited({ promise: _promise }) {
|
|
if (reactUse) return reactUse(_promise);
|
|
const promise = defer(_promise);
|
|
if (promise[TSR_DEFERRED_PROMISE].status === "pending") throw promise;
|
|
if (promise[TSR_DEFERRED_PROMISE].status === "error") throw promise[TSR_DEFERRED_PROMISE].error;
|
|
return promise[TSR_DEFERRED_PROMISE].data;
|
|
}
|
|
function Await(props) {
|
|
const inner = (0, import_jsx_runtime.jsx)(AwaitInner, { ...props });
|
|
if (props.fallback) return (0, import_jsx_runtime.jsx)(React$12.Suspense, {
|
|
fallback: props.fallback,
|
|
children: inner
|
|
});
|
|
return inner;
|
|
}
|
|
function AwaitInner(props) {
|
|
const data = useAwaited(props);
|
|
return props.children(data);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/CatchBoundary.js
|
|
var React$13 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
|
|
function CatchBoundary(props) {
|
|
const errorComponent = props.errorComponent ?? ErrorComponent;
|
|
return (0, import_jsx_runtime2.jsx)(CatchBoundaryImpl, {
|
|
getResetKey: props.getResetKey,
|
|
onCatch: props.onCatch,
|
|
children: ({ error, reset }) => {
|
|
if (error) return React$13.createElement(errorComponent, {
|
|
error,
|
|
reset
|
|
});
|
|
return props.children;
|
|
}
|
|
});
|
|
}
|
|
var CatchBoundaryImpl = class extends React$13.Component {
|
|
constructor(..._args) {
|
|
super(..._args);
|
|
this.state = { error: null };
|
|
}
|
|
static getDerivedStateFromProps(props, state) {
|
|
const resetKey = props.getResetKey();
|
|
if (state.error && state.resetKey !== resetKey) return {
|
|
resetKey,
|
|
error: null
|
|
};
|
|
return { resetKey };
|
|
}
|
|
static getDerivedStateFromError(error) {
|
|
return { error };
|
|
}
|
|
reset() {
|
|
this.setState({ error: null });
|
|
}
|
|
componentDidCatch(error, errorInfo) {
|
|
if (this.props.onCatch) this.props.onCatch(error, errorInfo);
|
|
}
|
|
render() {
|
|
return this.props.children({
|
|
error: this.state.error,
|
|
reset: () => {
|
|
this.reset();
|
|
}
|
|
});
|
|
}
|
|
};
|
|
function ErrorComponent({ error }) {
|
|
const [show, setShow] = React$13.useState(true);
|
|
return (0, import_jsx_runtime2.jsxs)("div", {
|
|
style: {
|
|
padding: ".5rem",
|
|
maxWidth: "100%"
|
|
},
|
|
children: [
|
|
(0, import_jsx_runtime2.jsxs)("div", {
|
|
style: {
|
|
display: "flex",
|
|
alignItems: "center",
|
|
gap: ".5rem"
|
|
},
|
|
children: [(0, import_jsx_runtime2.jsx)("strong", {
|
|
style: { fontSize: "1rem" },
|
|
children: "Something went wrong!"
|
|
}), (0, import_jsx_runtime2.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"
|
|
})]
|
|
}),
|
|
(0, import_jsx_runtime2.jsx)("div", { style: { height: ".25rem" } }),
|
|
show ? (0, import_jsx_runtime2.jsx)("div", { children: (0, import_jsx_runtime2.jsx)("pre", {
|
|
style: {
|
|
fontSize: ".7em",
|
|
border: "1px solid red",
|
|
borderRadius: ".25rem",
|
|
padding: ".3rem",
|
|
color: "red",
|
|
overflow: "auto"
|
|
},
|
|
children: error.message ? (0, import_jsx_runtime2.jsx)("code", { children: error.message }) : null
|
|
}) }) : null
|
|
]
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/ClientOnly.js
|
|
var import_react = __toESM(require_react(), 1);
|
|
var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
|
|
function ClientOnly({ children, fallback = null }) {
|
|
return useHydrated() ? (0, import_jsx_runtime3.jsx)(import_react.default.Fragment, { children }) : (0, import_jsx_runtime3.jsx)(import_react.default.Fragment, { children: fallback });
|
|
}
|
|
function useHydrated() {
|
|
return import_react.default.useSyncExternalStore(subscribe, () => true, () => false);
|
|
}
|
|
function subscribe() {
|
|
return () => {
|
|
};
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/routerContext.js
|
|
var React$14 = __toESM(require_react(), 1);
|
|
var routerContext = React$14.createContext(null);
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/useRouter.js
|
|
var React$15 = __toESM(require_react(), 1);
|
|
function useRouter(opts) {
|
|
const value = React$15.useContext(routerContext);
|
|
if (true) {
|
|
if (((opts == null ? void 0 : opts.warn) ?? true) && !value) console.warn("Warning: useRouter must be used inside a <RouterProvider> component!");
|
|
}
|
|
return value;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/matchContext.js
|
|
var React$16 = __toESM(require_react(), 1);
|
|
var matchContext = React$16.createContext(void 0);
|
|
var dummyMatchContext = React$16.createContext(void 0);
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/useMatch.js
|
|
var React$17 = __toESM(require_react(), 1);
|
|
|
|
// node_modules/@tanstack/store/dist/esm/alien.js
|
|
var ReactiveFlags = ((ReactiveFlags2) => {
|
|
ReactiveFlags2[ReactiveFlags2["None"] = 0] = "None";
|
|
ReactiveFlags2[ReactiveFlags2["Mutable"] = 1] = "Mutable";
|
|
ReactiveFlags2[ReactiveFlags2["Watching"] = 2] = "Watching";
|
|
ReactiveFlags2[ReactiveFlags2["RecursedCheck"] = 4] = "RecursedCheck";
|
|
ReactiveFlags2[ReactiveFlags2["Recursed"] = 8] = "Recursed";
|
|
ReactiveFlags2[ReactiveFlags2["Dirty"] = 16] = "Dirty";
|
|
ReactiveFlags2[ReactiveFlags2["Pending"] = 32] = "Pending";
|
|
return ReactiveFlags2;
|
|
})(ReactiveFlags || {});
|
|
function createReactiveSystem({
|
|
update,
|
|
notify,
|
|
unwatched
|
|
}) {
|
|
return {
|
|
link: link2,
|
|
unlink: unlink2,
|
|
propagate: propagate2,
|
|
checkDirty: checkDirty2,
|
|
shallowPropagate: shallowPropagate2
|
|
};
|
|
function link2(dep, sub, version) {
|
|
const prevDep = sub.depsTail;
|
|
if (prevDep !== void 0 && prevDep.dep === dep) {
|
|
return;
|
|
}
|
|
const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
|
|
if (nextDep !== void 0 && nextDep.dep === dep) {
|
|
nextDep.version = version;
|
|
sub.depsTail = nextDep;
|
|
return;
|
|
}
|
|
const prevSub = dep.subsTail;
|
|
if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) {
|
|
return;
|
|
}
|
|
const newLink = sub.depsTail = dep.subsTail = {
|
|
version,
|
|
dep,
|
|
sub,
|
|
prevDep,
|
|
nextDep,
|
|
prevSub,
|
|
nextSub: void 0
|
|
};
|
|
if (nextDep !== void 0) {
|
|
nextDep.prevDep = newLink;
|
|
}
|
|
if (prevDep !== void 0) {
|
|
prevDep.nextDep = newLink;
|
|
} else {
|
|
sub.deps = newLink;
|
|
}
|
|
if (prevSub !== void 0) {
|
|
prevSub.nextSub = newLink;
|
|
} else {
|
|
dep.subs = newLink;
|
|
}
|
|
}
|
|
function unlink2(link22, sub = link22.sub) {
|
|
const dep = link22.dep;
|
|
const prevDep = link22.prevDep;
|
|
const nextDep = link22.nextDep;
|
|
const nextSub = link22.nextSub;
|
|
const prevSub = link22.prevSub;
|
|
if (nextDep !== void 0) {
|
|
nextDep.prevDep = prevDep;
|
|
} else {
|
|
sub.depsTail = prevDep;
|
|
}
|
|
if (prevDep !== void 0) {
|
|
prevDep.nextDep = nextDep;
|
|
} else {
|
|
sub.deps = nextDep;
|
|
}
|
|
if (nextSub !== void 0) {
|
|
nextSub.prevSub = prevSub;
|
|
} else {
|
|
dep.subsTail = prevSub;
|
|
}
|
|
if (prevSub !== void 0) {
|
|
prevSub.nextSub = nextSub;
|
|
} else if ((dep.subs = nextSub) === void 0) {
|
|
unwatched(dep);
|
|
}
|
|
return nextDep;
|
|
}
|
|
function propagate2(link22) {
|
|
let next = link22.nextSub;
|
|
let stack;
|
|
top: do {
|
|
const sub = link22.sub;
|
|
let flags = sub.flags;
|
|
if (!(flags & (4 | 8 | 16 | 32))) {
|
|
sub.flags = flags | 32;
|
|
} else if (!(flags & (4 | 8))) {
|
|
flags = 0;
|
|
} else if (!(flags & 4)) {
|
|
sub.flags = flags & -9 | 32;
|
|
} else if (!(flags & (16 | 32)) && isValidLink(link22, sub)) {
|
|
sub.flags = flags | (8 | 32);
|
|
flags &= 1;
|
|
} else {
|
|
flags = 0;
|
|
}
|
|
if (flags & 2) {
|
|
notify(sub);
|
|
}
|
|
if (flags & 1) {
|
|
const subSubs = sub.subs;
|
|
if (subSubs !== void 0) {
|
|
const nextSub = (link22 = subSubs).nextSub;
|
|
if (nextSub !== void 0) {
|
|
stack = { value: next, prev: stack };
|
|
next = nextSub;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if ((link22 = next) !== void 0) {
|
|
next = link22.nextSub;
|
|
continue;
|
|
}
|
|
while (stack !== void 0) {
|
|
link22 = stack.value;
|
|
stack = stack.prev;
|
|
if (link22 !== void 0) {
|
|
next = link22.nextSub;
|
|
continue top;
|
|
}
|
|
}
|
|
break;
|
|
} while (true);
|
|
}
|
|
function checkDirty2(link22, sub) {
|
|
let stack;
|
|
let checkDepth = 0;
|
|
let dirty = false;
|
|
top: do {
|
|
const dep = link22.dep;
|
|
const flags = dep.flags;
|
|
if (sub.flags & 16) {
|
|
dirty = true;
|
|
} else if ((flags & (1 | 16)) === (1 | 16)) {
|
|
if (update(dep)) {
|
|
const subs = dep.subs;
|
|
if (subs.nextSub !== void 0) {
|
|
shallowPropagate2(subs);
|
|
}
|
|
dirty = true;
|
|
}
|
|
} else if ((flags & (1 | 32)) === (1 | 32)) {
|
|
if (link22.nextSub !== void 0 || link22.prevSub !== void 0) {
|
|
stack = { value: link22, prev: stack };
|
|
}
|
|
link22 = dep.deps;
|
|
sub = dep;
|
|
++checkDepth;
|
|
continue;
|
|
}
|
|
if (!dirty) {
|
|
const nextDep = link22.nextDep;
|
|
if (nextDep !== void 0) {
|
|
link22 = nextDep;
|
|
continue;
|
|
}
|
|
}
|
|
while (checkDepth--) {
|
|
const firstSub = sub.subs;
|
|
const hasMultipleSubs = firstSub.nextSub !== void 0;
|
|
if (hasMultipleSubs) {
|
|
link22 = stack.value;
|
|
stack = stack.prev;
|
|
} else {
|
|
link22 = firstSub;
|
|
}
|
|
if (dirty) {
|
|
if (update(sub)) {
|
|
if (hasMultipleSubs) {
|
|
shallowPropagate2(firstSub);
|
|
}
|
|
sub = link22.sub;
|
|
continue;
|
|
}
|
|
dirty = false;
|
|
} else {
|
|
sub.flags &= -33;
|
|
}
|
|
sub = link22.sub;
|
|
const nextDep = link22.nextDep;
|
|
if (nextDep !== void 0) {
|
|
link22 = nextDep;
|
|
continue top;
|
|
}
|
|
}
|
|
return dirty;
|
|
} while (true);
|
|
}
|
|
function shallowPropagate2(link22) {
|
|
do {
|
|
const sub = link22.sub;
|
|
const flags = sub.flags;
|
|
if ((flags & (32 | 16)) === 32) {
|
|
sub.flags = flags | 16;
|
|
if ((flags & (2 | 4)) === 2) {
|
|
notify(sub);
|
|
}
|
|
}
|
|
} while ((link22 = link22.nextSub) !== void 0);
|
|
}
|
|
function isValidLink(checkLink, sub) {
|
|
let link22 = sub.depsTail;
|
|
while (link22 !== void 0) {
|
|
if (link22 === checkLink) {
|
|
return true;
|
|
}
|
|
link22 = link22.prevDep;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// node_modules/@tanstack/store/dist/esm/atom.js
|
|
function toObserver(nextHandler, errorHandler, completionHandler) {
|
|
var _a, _b, _c;
|
|
const isObserver = typeof nextHandler === "object";
|
|
const self2 = isObserver ? nextHandler : void 0;
|
|
return {
|
|
next: (_a = isObserver ? nextHandler.next : nextHandler) == null ? void 0 : _a.bind(self2),
|
|
error: (_b = isObserver ? nextHandler.error : errorHandler) == null ? void 0 : _b.bind(self2),
|
|
complete: (_c = isObserver ? nextHandler.complete : completionHandler) == null ? void 0 : _c.bind(
|
|
self2
|
|
)
|
|
};
|
|
}
|
|
var queuedEffects = [];
|
|
var cycle = 0;
|
|
var { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
|
|
update(atom) {
|
|
return atom._update();
|
|
},
|
|
// eslint-disable-next-line no-shadow
|
|
notify(effect2) {
|
|
queuedEffects[queuedEffectsLength++] = effect2;
|
|
effect2.flags &= ~ReactiveFlags.Watching;
|
|
},
|
|
unwatched(atom) {
|
|
if (atom.depsTail !== void 0) {
|
|
atom.depsTail = void 0;
|
|
atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
|
|
purgeDeps(atom);
|
|
}
|
|
}
|
|
});
|
|
var notifyIndex = 0;
|
|
var queuedEffectsLength = 0;
|
|
var activeSub;
|
|
var batchDepth = 0;
|
|
function batch(fn) {
|
|
try {
|
|
++batchDepth;
|
|
fn();
|
|
} finally {
|
|
if (!--batchDepth) {
|
|
flush();
|
|
}
|
|
}
|
|
}
|
|
function purgeDeps(sub) {
|
|
const depsTail = sub.depsTail;
|
|
let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
|
|
while (dep !== void 0) {
|
|
dep = unlink(dep, sub);
|
|
}
|
|
}
|
|
function flush() {
|
|
if (batchDepth > 0) {
|
|
return;
|
|
}
|
|
while (notifyIndex < queuedEffectsLength) {
|
|
const effect2 = queuedEffects[notifyIndex];
|
|
queuedEffects[notifyIndex++] = void 0;
|
|
effect2.notify();
|
|
}
|
|
notifyIndex = 0;
|
|
queuedEffectsLength = 0;
|
|
}
|
|
function createAtom(valueOrFn, options) {
|
|
const isComputed = typeof valueOrFn === "function";
|
|
const getter = valueOrFn;
|
|
const atom = {
|
|
_snapshot: isComputed ? void 0 : valueOrFn,
|
|
subs: void 0,
|
|
subsTail: void 0,
|
|
deps: void 0,
|
|
depsTail: void 0,
|
|
flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
|
|
get() {
|
|
if (activeSub !== void 0) {
|
|
link(atom, activeSub, cycle);
|
|
}
|
|
return atom._snapshot;
|
|
},
|
|
subscribe(observerOrFn) {
|
|
const obs = toObserver(observerOrFn);
|
|
const observed = { current: false };
|
|
const e = effect(() => {
|
|
var _a;
|
|
atom.get();
|
|
if (!observed.current) {
|
|
observed.current = true;
|
|
} else {
|
|
(_a = obs.next) == null ? void 0 : _a.call(obs, atom._snapshot);
|
|
}
|
|
});
|
|
return {
|
|
unsubscribe: () => {
|
|
e.stop();
|
|
}
|
|
};
|
|
},
|
|
_update(getValue) {
|
|
const prevSub = activeSub;
|
|
const compare = (options == null ? void 0 : options.compare) ?? Object.is;
|
|
if (isComputed) {
|
|
activeSub = atom;
|
|
++cycle;
|
|
atom.depsTail = void 0;
|
|
} else if (getValue === void 0) {
|
|
return false;
|
|
}
|
|
if (isComputed) {
|
|
atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
|
|
}
|
|
try {
|
|
const oldValue = atom._snapshot;
|
|
const newValue = typeof getValue === "function" ? getValue(oldValue) : getValue === void 0 && isComputed ? getter(oldValue) : getValue;
|
|
if (oldValue === void 0 || !compare(oldValue, newValue)) {
|
|
atom._snapshot = newValue;
|
|
return true;
|
|
}
|
|
return false;
|
|
} finally {
|
|
activeSub = prevSub;
|
|
if (isComputed) {
|
|
atom.flags &= ~ReactiveFlags.RecursedCheck;
|
|
}
|
|
purgeDeps(atom);
|
|
}
|
|
}
|
|
};
|
|
if (isComputed) {
|
|
atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
|
|
atom.get = function() {
|
|
const flags = atom.flags;
|
|
if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(atom.deps, atom)) {
|
|
if (atom._update()) {
|
|
const subs = atom.subs;
|
|
if (subs !== void 0) {
|
|
shallowPropagate(subs);
|
|
}
|
|
}
|
|
} else if (flags & ReactiveFlags.Pending) {
|
|
atom.flags = flags & ~ReactiveFlags.Pending;
|
|
}
|
|
if (activeSub !== void 0) {
|
|
link(atom, activeSub, cycle);
|
|
}
|
|
return atom._snapshot;
|
|
};
|
|
} else {
|
|
atom.set = function(valueOrFn2) {
|
|
if (atom._update(valueOrFn2)) {
|
|
const subs = atom.subs;
|
|
if (subs !== void 0) {
|
|
propagate(subs);
|
|
shallowPropagate(subs);
|
|
flush();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
return atom;
|
|
}
|
|
function effect(fn) {
|
|
const run = () => {
|
|
const prevSub = activeSub;
|
|
activeSub = effectObj;
|
|
++cycle;
|
|
effectObj.depsTail = void 0;
|
|
effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
|
|
try {
|
|
return fn();
|
|
} finally {
|
|
activeSub = prevSub;
|
|
effectObj.flags &= ~ReactiveFlags.RecursedCheck;
|
|
purgeDeps(effectObj);
|
|
}
|
|
};
|
|
const effectObj = {
|
|
deps: void 0,
|
|
depsTail: void 0,
|
|
subs: void 0,
|
|
subsTail: void 0,
|
|
flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
|
|
notify() {
|
|
const flags = this.flags;
|
|
if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(this.deps, this)) {
|
|
run();
|
|
} else {
|
|
this.flags = ReactiveFlags.Watching;
|
|
}
|
|
},
|
|
stop() {
|
|
this.flags = ReactiveFlags.None;
|
|
this.depsTail = void 0;
|
|
purgeDeps(this);
|
|
}
|
|
};
|
|
run();
|
|
return effectObj;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-store/dist/esm/useStore.js
|
|
var import_react2 = __toESM(require_react(), 1);
|
|
var import_with_selector = __toESM(require_with_selector(), 1);
|
|
function defaultCompare(a, b) {
|
|
return a === b;
|
|
}
|
|
function useStore(atom, selector, compare = defaultCompare) {
|
|
const subscribe2 = (0, import_react2.useCallback)(
|
|
(handleStoreChange) => {
|
|
if (!atom) {
|
|
return () => {
|
|
};
|
|
}
|
|
const { unsubscribe } = atom.subscribe(handleStoreChange);
|
|
return unsubscribe;
|
|
},
|
|
[atom]
|
|
);
|
|
const boundGetSnapshot = (0, import_react2.useCallback)(() => atom == null ? void 0 : atom.get(), [atom]);
|
|
const selectedSnapshot = (0, import_with_selector.useSyncExternalStoreWithSelector)(
|
|
subscribe2,
|
|
boundGetSnapshot,
|
|
boundGetSnapshot,
|
|
selector,
|
|
compare
|
|
);
|
|
return selectedSnapshot;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/useMatch.js
|
|
var dummyStore = {
|
|
get: () => void 0,
|
|
subscribe: () => ({ unsubscribe: () => {
|
|
} })
|
|
};
|
|
function useMatch(opts) {
|
|
const router = useRouter();
|
|
const nearestMatchId = React$17.useContext(opts.from ? dummyMatchContext : matchContext);
|
|
const key = opts.from ?? nearestMatchId;
|
|
const matchStore = key ? opts.from ? router.stores.getRouteMatchStore(key) : router.stores.matchStores.get(key) : void 0;
|
|
if (isServer ?? router.isServer) {
|
|
const match = matchStore == null ? void 0 : matchStore.get();
|
|
if ((opts.shouldThrow ?? true) && !match) {
|
|
if (true) throw new Error(`Invariant failed: Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`);
|
|
invariant();
|
|
}
|
|
if (match === void 0) return;
|
|
return opts.select ? opts.select(match) : match;
|
|
}
|
|
const previousResult = React$17.useRef(void 0);
|
|
return useStore(matchStore ?? dummyStore, (match) => {
|
|
if ((opts.shouldThrow ?? true) && !match) {
|
|
if (true) throw new Error(`Invariant failed: Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`);
|
|
invariant();
|
|
}
|
|
if (match === void 0) return;
|
|
const selected = opts.select ? opts.select(match) : match;
|
|
if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {
|
|
const shared = replaceEqualDeep(previousResult.current, selected);
|
|
previousResult.current = shared;
|
|
return shared;
|
|
}
|
|
return selected;
|
|
});
|
|
}
|
|
|
|
// 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 React$18 = __toESM(require_react(), 1);
|
|
function useNavigate(_defaultOpts) {
|
|
const router = useRouter();
|
|
return React$18.useCallback((options) => {
|
|
return router.navigate({
|
|
...options,
|
|
from: options.from ?? (_defaultOpts == null ? void 0 : _defaultOpts.from)
|
|
});
|
|
}, [_defaultOpts == null ? void 0 : _defaultOpts.from, router]);
|
|
}
|
|
function Navigate(props) {
|
|
const router = useRouter();
|
|
const navigate = useNavigate();
|
|
const previousPropsRef = React$18.useRef(null);
|
|
useLayoutEffect2(() => {
|
|
if (previousPropsRef.current !== props) {
|
|
navigate(props);
|
|
previousPropsRef.current = props;
|
|
}
|
|
}, [
|
|
router,
|
|
props,
|
|
navigate
|
|
]);
|
|
return null;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/useRouteContext.js
|
|
function useRouteContext(opts) {
|
|
return useMatch({
|
|
...opts,
|
|
select: (match) => opts.select ? opts.select(match.context) : match.context
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/link.js
|
|
var React$19 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
|
|
var import_react_dom = __toESM(require_react_dom(), 1);
|
|
function useLinkProps(options, forwardedRef) {
|
|
const router = useRouter();
|
|
const innerRef = useForwardedRef(forwardedRef);
|
|
const _isServer = isServer ?? router.isServer;
|
|
const { activeProps, inactiveProps, activeOptions, to, preload: userPreload, preloadDelay: userPreloadDelay, preloadIntentProximity: _preloadIntentProximity, hashScrollIntoView, replace, startTransition: startTransition2, resetScroll, viewTransition, children, target, disabled, style, className, onClick, onBlur, onFocus, onMouseEnter, onMouseLeave, onTouchStart, ignoreBlocker, params: _params, search: _search, hash: _hash, state: _state, mask: _mask, reloadDocument: _reloadDocument, unsafeRelative: _unsafeRelative, from: _from, _fromLocation, ...propsSafeToSpread } = options;
|
|
if (_isServer) {
|
|
const safeInternal = isSafeInternal(to);
|
|
if (typeof to === "string" && !safeInternal && to.indexOf(":") > -1) try {
|
|
new URL(to);
|
|
if (isDangerousProtocol(to, router.protocolAllowlist)) {
|
|
if (true) console.warn(`Blocked Link with dangerous protocol: ${to}`);
|
|
return {
|
|
...propsSafeToSpread,
|
|
ref: innerRef,
|
|
href: void 0,
|
|
...children && { children },
|
|
...target && { target },
|
|
...disabled && { disabled },
|
|
...style && { style },
|
|
...className && { className }
|
|
};
|
|
}
|
|
return {
|
|
...propsSafeToSpread,
|
|
ref: innerRef,
|
|
href: to,
|
|
...children && { children },
|
|
...target && { target },
|
|
...disabled && { disabled },
|
|
...style && { style },
|
|
...className && { className }
|
|
};
|
|
} catch {
|
|
}
|
|
const next2 = router.buildLocation({
|
|
...options,
|
|
from: options.from
|
|
});
|
|
const hrefOption2 = getHrefOption(next2.maskedLocation ? next2.maskedLocation.publicHref : next2.publicHref, next2.maskedLocation ? next2.maskedLocation.external : next2.external, router.history, disabled);
|
|
const externalLink2 = (() => {
|
|
if (hrefOption2 == null ? void 0 : hrefOption2.external) {
|
|
if (isDangerousProtocol(hrefOption2.href, router.protocolAllowlist)) {
|
|
if (true) console.warn(`Blocked Link with dangerous protocol: ${hrefOption2.href}`);
|
|
return;
|
|
}
|
|
return hrefOption2.href;
|
|
}
|
|
if (safeInternal) return void 0;
|
|
if (typeof to === "string" && to.indexOf(":") > -1) try {
|
|
new URL(to);
|
|
if (isDangerousProtocol(to, router.protocolAllowlist)) {
|
|
if (true) console.warn(`Blocked Link with dangerous protocol: ${to}`);
|
|
return;
|
|
}
|
|
return to;
|
|
} catch {
|
|
}
|
|
})();
|
|
const isActive2 = (() => {
|
|
if (externalLink2) return false;
|
|
const currentLocation2 = router.stores.location.get();
|
|
const exact = (activeOptions == null ? void 0 : activeOptions.exact) ?? false;
|
|
if (exact) {
|
|
if (!exactPathTest(currentLocation2.pathname, next2.pathname, router.basepath)) return false;
|
|
} else {
|
|
const currentPathSplit = removeTrailingSlash(currentLocation2.pathname, router.basepath);
|
|
const nextPathSplit = removeTrailingSlash(next2.pathname, router.basepath);
|
|
if (!(currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/"))) return false;
|
|
}
|
|
if ((activeOptions == null ? void 0 : activeOptions.includeSearch) ?? true) {
|
|
if (currentLocation2.search !== next2.search) {
|
|
const currentSearchEmpty = !currentLocation2.search || typeof currentLocation2.search === "object" && Object.keys(currentLocation2.search).length === 0;
|
|
const nextSearchEmpty = !next2.search || typeof next2.search === "object" && Object.keys(next2.search).length === 0;
|
|
if (!(currentSearchEmpty && nextSearchEmpty)) {
|
|
if (!deepEqual(currentLocation2.search, next2.search, {
|
|
partial: !exact,
|
|
ignoreUndefined: !(activeOptions == null ? void 0 : activeOptions.explicitUndefined)
|
|
})) return false;
|
|
}
|
|
}
|
|
}
|
|
if (activeOptions == null ? void 0 : activeOptions.includeHash) return false;
|
|
return true;
|
|
})();
|
|
if (externalLink2) return {
|
|
...propsSafeToSpread,
|
|
ref: innerRef,
|
|
href: externalLink2,
|
|
...children && { children },
|
|
...target && { target },
|
|
...disabled && { disabled },
|
|
...style && { style },
|
|
...className && { className }
|
|
};
|
|
const resolvedActiveProps2 = isActive2 ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
|
|
const resolvedInactiveProps2 = isActive2 ? STATIC_EMPTY_OBJECT : functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT;
|
|
const resolvedStyle2 = (() => {
|
|
const baseStyle = style;
|
|
const activeStyle = resolvedActiveProps2.style;
|
|
const inactiveStyle = resolvedInactiveProps2.style;
|
|
if (!baseStyle && !activeStyle && !inactiveStyle) return;
|
|
if (baseStyle && !activeStyle && !inactiveStyle) return baseStyle;
|
|
if (!baseStyle && activeStyle && !inactiveStyle) return activeStyle;
|
|
if (!baseStyle && !activeStyle && inactiveStyle) return inactiveStyle;
|
|
return {
|
|
...baseStyle,
|
|
...activeStyle,
|
|
...inactiveStyle
|
|
};
|
|
})();
|
|
const resolvedClassName2 = (() => {
|
|
const baseClassName = className;
|
|
const activeClassName = resolvedActiveProps2.className;
|
|
const inactiveClassName = resolvedInactiveProps2.className;
|
|
if (!baseClassName && !activeClassName && !inactiveClassName) return "";
|
|
let out = "";
|
|
if (baseClassName) out = baseClassName;
|
|
if (activeClassName) out = out ? `${out} ${activeClassName}` : activeClassName;
|
|
if (inactiveClassName) out = out ? `${out} ${inactiveClassName}` : inactiveClassName;
|
|
return out;
|
|
})();
|
|
return {
|
|
...propsSafeToSpread,
|
|
...resolvedActiveProps2,
|
|
...resolvedInactiveProps2,
|
|
href: hrefOption2 == null ? void 0 : hrefOption2.href,
|
|
ref: innerRef,
|
|
disabled: !!disabled,
|
|
target,
|
|
...resolvedStyle2 && { style: resolvedStyle2 },
|
|
...resolvedClassName2 && { className: resolvedClassName2 },
|
|
...disabled && STATIC_DISABLED_PROPS,
|
|
...isActive2 && STATIC_ACTIVE_PROPS
|
|
};
|
|
}
|
|
const isHydrated = useHydrated();
|
|
const _options = React$19.useMemo(() => options, [
|
|
router,
|
|
options.from,
|
|
options._fromLocation,
|
|
options.hash,
|
|
options.to,
|
|
options.search,
|
|
options.params,
|
|
options.state,
|
|
options.mask,
|
|
options.unsafeRelative
|
|
]);
|
|
const currentLocation = useStore(router.stores.location, (l) => l, (prev, next2) => prev.href === next2.href);
|
|
const next = React$19.useMemo(() => {
|
|
const opts = {
|
|
_fromLocation: currentLocation,
|
|
..._options
|
|
};
|
|
return router.buildLocation(opts);
|
|
}, [
|
|
router,
|
|
currentLocation,
|
|
_options
|
|
]);
|
|
const hrefOptionPublicHref = next.maskedLocation ? next.maskedLocation.publicHref : next.publicHref;
|
|
const hrefOptionExternal = next.maskedLocation ? next.maskedLocation.external : next.external;
|
|
const hrefOption = React$19.useMemo(() => getHrefOption(hrefOptionPublicHref, hrefOptionExternal, router.history, disabled), [
|
|
disabled,
|
|
hrefOptionExternal,
|
|
hrefOptionPublicHref,
|
|
router.history
|
|
]);
|
|
const externalLink = React$19.useMemo(() => {
|
|
if (hrefOption == null ? void 0 : hrefOption.external) {
|
|
if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) {
|
|
if (true) console.warn(`Blocked Link with dangerous protocol: ${hrefOption.href}`);
|
|
return;
|
|
}
|
|
return hrefOption.href;
|
|
}
|
|
if (isSafeInternal(to)) return void 0;
|
|
if (typeof to !== "string" || to.indexOf(":") === -1) return void 0;
|
|
try {
|
|
new URL(to);
|
|
if (isDangerousProtocol(to, router.protocolAllowlist)) {
|
|
if (true) console.warn(`Blocked Link with dangerous protocol: ${to}`);
|
|
return;
|
|
}
|
|
return to;
|
|
} catch {
|
|
}
|
|
}, [
|
|
to,
|
|
hrefOption,
|
|
router.protocolAllowlist
|
|
]);
|
|
const isActive = React$19.useMemo(() => {
|
|
if (externalLink) return false;
|
|
if (activeOptions == null ? void 0 : activeOptions.exact) {
|
|
if (!exactPathTest(currentLocation.pathname, next.pathname, router.basepath)) return false;
|
|
} else {
|
|
const currentPathSplit = removeTrailingSlash(currentLocation.pathname, router.basepath);
|
|
const nextPathSplit = removeTrailingSlash(next.pathname, router.basepath);
|
|
if (!(currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/"))) return false;
|
|
}
|
|
if ((activeOptions == null ? void 0 : activeOptions.includeSearch) ?? true) {
|
|
if (!deepEqual(currentLocation.search, next.search, {
|
|
partial: !(activeOptions == null ? void 0 : activeOptions.exact),
|
|
ignoreUndefined: !(activeOptions == null ? void 0 : activeOptions.explicitUndefined)
|
|
})) return false;
|
|
}
|
|
if (activeOptions == null ? void 0 : activeOptions.includeHash) return isHydrated && currentLocation.hash === next.hash;
|
|
return true;
|
|
}, [
|
|
activeOptions == null ? void 0 : activeOptions.exact,
|
|
activeOptions == null ? void 0 : activeOptions.explicitUndefined,
|
|
activeOptions == null ? void 0 : activeOptions.includeHash,
|
|
activeOptions == null ? void 0 : activeOptions.includeSearch,
|
|
currentLocation,
|
|
externalLink,
|
|
isHydrated,
|
|
next.hash,
|
|
next.pathname,
|
|
next.search,
|
|
router.basepath
|
|
]);
|
|
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
|
|
};
|
|
const [isTransitioning, setIsTransitioning] = React$19.useState(false);
|
|
const hasRenderFetched = React$19.useRef(false);
|
|
const preload = options.reloadDocument || externalLink ? false : userPreload ?? router.options.defaultPreload;
|
|
const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
|
|
const doPreload = React$19.useCallback(() => {
|
|
router.preloadRoute({
|
|
..._options,
|
|
_builtLocation: next
|
|
}).catch((err) => {
|
|
console.warn(err);
|
|
console.warn(preloadWarning);
|
|
});
|
|
}, [
|
|
router,
|
|
_options,
|
|
next
|
|
]);
|
|
useIntersectionObserver(innerRef, React$19.useCallback((entry) => {
|
|
if (entry == null ? void 0 : entry.isIntersecting) doPreload();
|
|
}, [doPreload]), intersectionObserverOptions, { disabled: !!disabled || !(preload === "viewport") });
|
|
React$19.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 },
|
|
...onBlur && { onBlur },
|
|
...onFocus && { onFocus },
|
|
...onMouseEnter && { onMouseEnter },
|
|
...onMouseLeave && { onMouseLeave },
|
|
...onTouchStart && { onTouchStart }
|
|
};
|
|
const enqueueIntentPreload = (e) => {
|
|
if (disabled || preload !== "intent") return;
|
|
if (!preloadDelay) {
|
|
doPreload();
|
|
return;
|
|
}
|
|
const eventTarget = e.currentTarget;
|
|
if (timeoutMap.has(eventTarget)) return;
|
|
const id = setTimeout(() => {
|
|
timeoutMap.delete(eventTarget);
|
|
doPreload();
|
|
}, preloadDelay);
|
|
timeoutMap.set(eventTarget, id);
|
|
};
|
|
const handleTouchStart = (_) => {
|
|
if (disabled || preload !== "intent") return;
|
|
doPreload();
|
|
};
|
|
const handleLeave = (e) => {
|
|
if (disabled || !preload || !preloadDelay) return;
|
|
const eventTarget = e.currentTarget;
|
|
const id = timeoutMap.get(eventTarget);
|
|
if (id) {
|
|
clearTimeout(id);
|
|
timeoutMap.delete(eventTarget);
|
|
}
|
|
};
|
|
return {
|
|
...propsSafeToSpread,
|
|
...resolvedActiveProps,
|
|
...resolvedInactiveProps,
|
|
href: hrefOption == null ? void 0 : hrefOption.href,
|
|
ref: innerRef,
|
|
onClick: composeHandlers([onClick, handleClick]),
|
|
onBlur: composeHandlers([onBlur, handleLeave]),
|
|
onFocus: composeHandlers([onFocus, enqueueIntentPreload]),
|
|
onMouseEnter: composeHandlers([onMouseEnter, enqueueIntentPreload]),
|
|
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,
|
|
...isHydrated && 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 getHrefOption(publicHref, external, history, disabled) {
|
|
if (disabled) return void 0;
|
|
if (external) return {
|
|
href: publicHref,
|
|
external: true
|
|
};
|
|
return {
|
|
href: history.createHref(publicHref) || "/",
|
|
external: false
|
|
};
|
|
}
|
|
function isSafeInternal(to) {
|
|
if (typeof to !== "string") return false;
|
|
const zero = to.charCodeAt(0);
|
|
if (zero === 47) return to.charCodeAt(1) !== 47;
|
|
return zero === 46;
|
|
}
|
|
function createLink(Comp) {
|
|
return React$19.forwardRef(function CreatedLink(props, ref) {
|
|
return (0, import_jsx_runtime4.jsx)(Link, {
|
|
...props,
|
|
_asChild: Comp,
|
|
ref
|
|
});
|
|
});
|
|
}
|
|
var Link = React$19.forwardRef((props, ref) => {
|
|
const { _asChild, ...rest } = props;
|
|
const { type: _type, ...linkProps } = useLinkProps(rest, ref);
|
|
const children = typeof rest.children === "function" ? rest.children({ isActive: linkProps["data-status"] === "active" }) : rest.children;
|
|
if (!_asChild) {
|
|
const { disabled: _, ...rest2 } = linkProps;
|
|
return React$19.createElement("a", rest2, children);
|
|
}
|
|
return React$19.createElement(_asChild, linkProps, children);
|
|
});
|
|
function isCtrlEvent(e) {
|
|
return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
|
|
}
|
|
var linkOptions = (options) => {
|
|
return options;
|
|
};
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/route.js
|
|
var import_react3 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
|
|
function getRouteApi(id) {
|
|
return new RouteApi({ id });
|
|
}
|
|
var RouteApi = class extends BaseRouteApi {
|
|
/**
|
|
* @deprecated Use the `getRouteApi` function instead.
|
|
*/
|
|
constructor({ id }) {
|
|
super({ id });
|
|
this.useMatch = (opts) => {
|
|
return useMatch({
|
|
select: opts == null ? void 0 : opts.select,
|
|
from: this.id,
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
|
});
|
|
};
|
|
this.useRouteContext = (opts) => {
|
|
return useRouteContext({
|
|
...opts,
|
|
from: this.id
|
|
});
|
|
};
|
|
this.useSearch = (opts) => {
|
|
return useSearch({
|
|
select: opts == null ? void 0 : opts.select,
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
|
from: this.id
|
|
});
|
|
};
|
|
this.useParams = (opts) => {
|
|
return useParams({
|
|
select: opts == null ? void 0 : opts.select,
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
|
from: this.id
|
|
});
|
|
};
|
|
this.useLoaderDeps = (opts) => {
|
|
return useLoaderDeps({
|
|
...opts,
|
|
from: this.id,
|
|
strict: false
|
|
});
|
|
};
|
|
this.useLoaderData = (opts) => {
|
|
return useLoaderData({
|
|
...opts,
|
|
from: this.id,
|
|
strict: false
|
|
});
|
|
};
|
|
this.useNavigate = () => {
|
|
return useNavigate({ from: useRouter().routesById[this.id].fullPath });
|
|
};
|
|
this.notFound = (opts) => {
|
|
return notFound({
|
|
routeId: this.id,
|
|
...opts
|
|
});
|
|
};
|
|
this.Link = import_react3.default.forwardRef((props, ref) => {
|
|
const fullPath = useRouter().routesById[this.id].fullPath;
|
|
return (0, import_jsx_runtime5.jsx)(Link, {
|
|
ref,
|
|
from: fullPath,
|
|
...props
|
|
});
|
|
});
|
|
}
|
|
};
|
|
var Route = class extends BaseRoute {
|
|
/**
|
|
* @deprecated Use the `createRoute` function instead.
|
|
*/
|
|
constructor(options) {
|
|
super(options);
|
|
this.useMatch = (opts) => {
|
|
return useMatch({
|
|
select: opts == null ? void 0 : opts.select,
|
|
from: this.id,
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
|
});
|
|
};
|
|
this.useRouteContext = (opts) => {
|
|
return useRouteContext({
|
|
...opts,
|
|
from: this.id
|
|
});
|
|
};
|
|
this.useSearch = (opts) => {
|
|
return useSearch({
|
|
select: opts == null ? void 0 : opts.select,
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
|
from: this.id
|
|
});
|
|
};
|
|
this.useParams = (opts) => {
|
|
return useParams({
|
|
select: opts == null ? void 0 : opts.select,
|
|
structuralSharing: opts == null ? void 0 : 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 (0, import_jsx_runtime5.jsx)(Link, {
|
|
ref,
|
|
from: this.fullPath,
|
|
...props
|
|
});
|
|
});
|
|
}
|
|
};
|
|
function createRoute(options) {
|
|
return new Route(options);
|
|
}
|
|
function createRootRouteWithContext() {
|
|
return (options) => {
|
|
return createRootRoute(options);
|
|
};
|
|
}
|
|
var rootRouteWithContext = createRootRouteWithContext;
|
|
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 == null ? void 0 : opts.select,
|
|
from: this.id,
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
|
});
|
|
};
|
|
this.useRouteContext = (opts) => {
|
|
return useRouteContext({
|
|
...opts,
|
|
from: this.id
|
|
});
|
|
};
|
|
this.useSearch = (opts) => {
|
|
return useSearch({
|
|
select: opts == null ? void 0 : opts.select,
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing,
|
|
from: this.id
|
|
});
|
|
};
|
|
this.useParams = (opts) => {
|
|
return useParams({
|
|
select: opts == null ? void 0 : opts.select,
|
|
structuralSharing: opts == null ? void 0 : 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 (0, import_jsx_runtime5.jsx)(Link, {
|
|
ref,
|
|
from: this.fullPath,
|
|
...props
|
|
});
|
|
});
|
|
}
|
|
};
|
|
function createRootRoute(options) {
|
|
return new RootRoute(options);
|
|
}
|
|
function createRouteMask(opts) {
|
|
return opts;
|
|
}
|
|
var NotFoundRoute = class extends Route {
|
|
constructor(options) {
|
|
super({
|
|
...options,
|
|
id: "404"
|
|
});
|
|
}
|
|
};
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/fileRoute.js
|
|
function createFileRoute(path) {
|
|
return new FileRoute(path, { silent: true }).createRoute;
|
|
}
|
|
var FileRoute = class {
|
|
constructor(path, _opts) {
|
|
this.path = path;
|
|
this.createRoute = (options) => {
|
|
if (true) {
|
|
if (!this.silent) console.warn("Warning: 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 == null ? void 0 : _opts.silent;
|
|
}
|
|
};
|
|
function FileRouteLoader(_path) {
|
|
if (true) console.warn(`Warning: FileRouteLoader is deprecated and will be removed in the next major version. Please place the loader function in the the main route file, inside the \`createFileRoute('/path/to/file')(options)\` options`);
|
|
return (loaderFn) => loaderFn;
|
|
}
|
|
var LazyRoute = class {
|
|
constructor(opts) {
|
|
this.useMatch = (opts2) => {
|
|
return useMatch({
|
|
select: opts2 == null ? void 0 : opts2.select,
|
|
from: this.options.id,
|
|
structuralSharing: opts2 == null ? void 0 : opts2.structuralSharing
|
|
});
|
|
};
|
|
this.useRouteContext = (opts2) => {
|
|
return useRouteContext({
|
|
...opts2,
|
|
from: this.options.id
|
|
});
|
|
};
|
|
this.useSearch = (opts2) => {
|
|
return useSearch({
|
|
select: opts2 == null ? void 0 : opts2.select,
|
|
structuralSharing: opts2 == null ? void 0 : opts2.structuralSharing,
|
|
from: this.options.id
|
|
});
|
|
};
|
|
this.useParams = (opts2) => {
|
|
return useParams({
|
|
select: opts2 == null ? void 0 : opts2.select,
|
|
structuralSharing: opts2 == null ? void 0 : 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 = () => {
|
|
return useNavigate({ from: useRouter().routesById[this.options.id].fullPath });
|
|
};
|
|
this.options = opts;
|
|
}
|
|
};
|
|
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/lazyRouteComponent.js
|
|
var React$110 = __toESM(require_react(), 1);
|
|
function lazyRouteComponent(importer, exportName) {
|
|
let loadPromise;
|
|
let comp;
|
|
let error;
|
|
let reload;
|
|
const load = () => {
|
|
if (!loadPromise) loadPromise = importer().then((res) => {
|
|
loadPromise = void 0;
|
|
comp = res[exportName ?? "default"];
|
|
}).catch((err) => {
|
|
error = err;
|
|
if (isModuleNotFoundError(error)) {
|
|
if (error instanceof Error && typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
|
|
const storageKey2 = `tanstack_router_reload:${error.message}`;
|
|
if (!sessionStorage.getItem(storageKey2)) {
|
|
sessionStorage.setItem(storageKey2, "1");
|
|
reload = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return loadPromise;
|
|
};
|
|
const lazyComp = function Lazy(props) {
|
|
if (reload) {
|
|
window.location.reload();
|
|
throw new Promise(() => {
|
|
});
|
|
}
|
|
if (error) throw error;
|
|
if (!comp) if (reactUse) reactUse(load());
|
|
else throw load();
|
|
return React$110.createElement(comp, props);
|
|
};
|
|
lazyComp.preload = load;
|
|
return lazyComp;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/not-found.js
|
|
var import_react4 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
|
|
function CatchNotFound(props) {
|
|
const router = useRouter();
|
|
if (isServer ?? router.isServer) {
|
|
const resetKey2 = `not-found-${router.stores.location.get().pathname}-${router.stores.status.get()}`;
|
|
return (0, import_jsx_runtime6.jsx)(CatchBoundary, {
|
|
getResetKey: () => resetKey2,
|
|
onCatch: (error, errorInfo) => {
|
|
var _a;
|
|
if (isNotFound(error)) (_a = props.onCatch) == null ? void 0 : _a.call(props, error, errorInfo);
|
|
else throw error;
|
|
},
|
|
errorComponent: ({ error }) => {
|
|
var _a;
|
|
if (isNotFound(error)) return (_a = props.fallback) == null ? void 0 : _a.call(props, error);
|
|
else throw error;
|
|
},
|
|
children: props.children
|
|
});
|
|
}
|
|
const resetKey = `not-found-${useStore(router.stores.location, (location) => location.pathname)}-${useStore(router.stores.status, (status) => status)}`;
|
|
return (0, import_jsx_runtime6.jsx)(CatchBoundary, {
|
|
getResetKey: () => resetKey,
|
|
onCatch: (error, errorInfo) => {
|
|
var _a;
|
|
if (isNotFound(error)) (_a = props.onCatch) == null ? void 0 : _a.call(props, error, errorInfo);
|
|
else throw error;
|
|
},
|
|
errorComponent: ({ error }) => {
|
|
var _a;
|
|
if (isNotFound(error)) return (_a = props.fallback) == null ? void 0 : _a.call(props, error);
|
|
else throw error;
|
|
},
|
|
children: props.children
|
|
});
|
|
}
|
|
function DefaultGlobalNotFound() {
|
|
return (0, import_jsx_runtime6.jsx)("p", { children: "Not Found" });
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/ScriptOnce.js
|
|
var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
|
|
function ScriptOnce({ children }) {
|
|
var _a;
|
|
const router = useRouter();
|
|
if (!(isServer ?? router.isServer)) return null;
|
|
return (0, import_jsx_runtime7.jsx)("script", {
|
|
nonce: (_a = router.options.ssr) == null ? void 0 : _a.nonce,
|
|
dangerouslySetInnerHTML: { __html: children + ";document.currentScript.remove()" }
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/SafeFragment.js
|
|
var import_react5 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
|
|
function SafeFragment(props) {
|
|
return (0, import_jsx_runtime8.jsx)(import_jsx_runtime8.Fragment, { children: props.children });
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/renderRouteNotFound.js
|
|
var import_react6 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
|
|
function renderRouteNotFound(router, route, data) {
|
|
if (!route.options.notFoundComponent) {
|
|
if (router.options.defaultNotFoundComponent) return (0, import_jsx_runtime9.jsx)(router.options.defaultNotFoundComponent, { ...data });
|
|
if (true) {
|
|
if (!route.options.notFoundComponent) console.warn(`Warning: 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 (<p>Not Found</p>)`);
|
|
}
|
|
return (0, import_jsx_runtime9.jsx)(DefaultGlobalNotFound, {});
|
|
}
|
|
return (0, import_jsx_runtime9.jsx)(route.options.notFoundComponent, { ...data });
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js
|
|
var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
|
|
|
|
// node_modules/@tanstack/router-core/dist/esm/scroll-restoration-script/client.js
|
|
function getScrollRestorationScriptForRouter(_router) {
|
|
return null;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js
|
|
function ScrollRestoration() {
|
|
const script = getScrollRestorationScriptForRouter(useRouter());
|
|
if (!script) return null;
|
|
return (0, import_jsx_runtime10.jsx)(ScriptOnce, { children: script });
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/Match.js
|
|
var React$111 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
|
|
var Match = React$111.memo(function MatchImpl({ matchId }) {
|
|
var _a, _b;
|
|
const router = useRouter();
|
|
if (isServer ?? router.isServer) {
|
|
const match2 = (_a = router.stores.matchStores.get(matchId)) == null ? void 0 : _a.get();
|
|
if (!match2) {
|
|
if (true) throw new Error(`Invariant failed: Could not find match for matchId "${matchId}". Please file an issue!`);
|
|
invariant();
|
|
}
|
|
const routeId = match2.routeId;
|
|
const parentRouteId = (_b = router.routesById[routeId].parentRoute) == null ? void 0 : _b.id;
|
|
return (0, import_jsx_runtime11.jsx)(MatchView, {
|
|
router,
|
|
matchId,
|
|
resetKey: router.stores.loadedAt.get(),
|
|
matchState: {
|
|
routeId,
|
|
ssr: match2.ssr,
|
|
_displayPending: match2._displayPending,
|
|
parentRouteId
|
|
}
|
|
});
|
|
}
|
|
const matchStore = router.stores.matchStores.get(matchId);
|
|
if (!matchStore) {
|
|
if (true) throw new Error(`Invariant failed: Could not find match for matchId "${matchId}". Please file an issue!`);
|
|
invariant();
|
|
}
|
|
const resetKey = useStore(router.stores.loadedAt, (loadedAt) => loadedAt);
|
|
const match = useStore(matchStore, (value) => value);
|
|
return (0, import_jsx_runtime11.jsx)(MatchView, {
|
|
router,
|
|
matchId,
|
|
resetKey,
|
|
matchState: React$111.useMemo(() => {
|
|
var _a2;
|
|
const routeId = match.routeId;
|
|
const parentRouteId = (_a2 = router.routesById[routeId].parentRoute) == null ? void 0 : _a2.id;
|
|
return {
|
|
routeId,
|
|
ssr: match.ssr,
|
|
_displayPending: match._displayPending,
|
|
parentRouteId
|
|
};
|
|
}, [
|
|
match._displayPending,
|
|
match.routeId,
|
|
match.ssr,
|
|
router.routesById
|
|
])
|
|
});
|
|
});
|
|
function MatchView({ router, matchId, resetKey, matchState }) {
|
|
var _a, _b;
|
|
const route = router.routesById[matchState.routeId];
|
|
const PendingComponent = route.options.pendingComponent ?? router.options.defaultPendingComponent;
|
|
const pendingElement = PendingComponent ? (0, import_jsx_runtime11.jsx)(PendingComponent, {}) : null;
|
|
const routeErrorComponent = route.options.errorComponent ?? router.options.defaultErrorComponent;
|
|
const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch;
|
|
const routeNotFoundComponent = route.isRoot ? route.options.notFoundComponent ?? ((_a = router.options.notFoundRoute) == null ? void 0 : _a.options.component) : route.options.notFoundComponent;
|
|
const resolvedNoSsr = matchState.ssr === false || matchState.ssr === "data-only";
|
|
const ResolvedSuspenseBoundary = (!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) && (route.options.wrapInSuspense ?? PendingComponent ?? (((_b = route.options.errorComponent) == null ? void 0 : _b.preload) || resolvedNoSsr)) ? React$111.Suspense : SafeFragment;
|
|
const ResolvedCatchBoundary = routeErrorComponent ? CatchBoundary : SafeFragment;
|
|
const ResolvedNotFoundBoundary = routeNotFoundComponent ? CatchNotFound : SafeFragment;
|
|
return (0, import_jsx_runtime11.jsxs)(route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment, { children: [(0, import_jsx_runtime11.jsx)(matchContext.Provider, {
|
|
value: matchId,
|
|
children: (0, import_jsx_runtime11.jsx)(ResolvedSuspenseBoundary, {
|
|
fallback: pendingElement,
|
|
children: (0, import_jsx_runtime11.jsx)(ResolvedCatchBoundary, {
|
|
getResetKey: () => resetKey,
|
|
errorComponent: routeErrorComponent || ErrorComponent,
|
|
onCatch: (error, errorInfo) => {
|
|
if (isNotFound(error)) {
|
|
error.routeId ?? (error.routeId = matchState.routeId);
|
|
throw error;
|
|
}
|
|
if (true) console.warn(`Warning: Error in route match: ${matchId}`);
|
|
routeOnCatch == null ? void 0 : routeOnCatch(error, errorInfo);
|
|
},
|
|
children: (0, import_jsx_runtime11.jsx)(ResolvedNotFoundBoundary, {
|
|
fallback: (error) => {
|
|
error.routeId ?? (error.routeId = matchState.routeId);
|
|
if (!routeNotFoundComponent || error.routeId && error.routeId !== matchState.routeId || !error.routeId && !route.isRoot) throw error;
|
|
return React$111.createElement(routeNotFoundComponent, error);
|
|
},
|
|
children: resolvedNoSsr || matchState._displayPending ? (0, import_jsx_runtime11.jsx)(ClientOnly, {
|
|
fallback: pendingElement,
|
|
children: (0, import_jsx_runtime11.jsx)(MatchInner, { matchId })
|
|
}) : (0, import_jsx_runtime11.jsx)(MatchInner, { matchId })
|
|
})
|
|
})
|
|
})
|
|
}), matchState.parentRouteId === rootRouteId ? (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [(0, import_jsx_runtime11.jsx)(OnRendered, { resetKey }), router.options.scrollRestoration && (isServer ?? router.isServer) ? (0, import_jsx_runtime11.jsx)(ScrollRestoration, {}) : null] }) : null] });
|
|
}
|
|
function OnRendered({ resetKey }) {
|
|
const router = useRouter();
|
|
if (isServer ?? router.isServer) return null;
|
|
const prevHrefRef = React$111.useRef(void 0);
|
|
useLayoutEffect2(() => {
|
|
const currentHref = router.latestLocation.href;
|
|
if (prevHrefRef.current === void 0 || prevHrefRef.current !== currentHref) {
|
|
router.emit({
|
|
type: "onRendered",
|
|
...getLocationChangeInfo(router.stores.location.get(), router.stores.resolvedLocation.get())
|
|
});
|
|
prevHrefRef.current = currentHref;
|
|
}
|
|
}, [
|
|
router.latestLocation.state.__TSR_key,
|
|
resetKey,
|
|
router
|
|
]);
|
|
return null;
|
|
}
|
|
var MatchInner = React$111.memo(function MatchInnerImpl({ matchId }) {
|
|
var _a, _b;
|
|
const router = useRouter();
|
|
const getMatchPromise = (match2, key2) => {
|
|
var _a2;
|
|
return ((_a2 = router.getMatch(match2.id)) == null ? void 0 : _a2._nonReactive[key2]) ?? match2._nonReactive[key2];
|
|
};
|
|
if (isServer ?? router.isServer) {
|
|
const match2 = (_a = router.stores.matchStores.get(matchId)) == null ? void 0 : _a.get();
|
|
if (!match2) {
|
|
if (true) throw new Error(`Invariant failed: Could not find match for matchId "${matchId}". Please file an issue!`);
|
|
invariant();
|
|
}
|
|
const routeId2 = match2.routeId;
|
|
const route2 = router.routesById[routeId2];
|
|
const remountDeps = (_b = router.routesById[routeId2].options.remountDeps ?? router.options.defaultRemountDeps) == null ? void 0 : _b({
|
|
routeId: routeId2,
|
|
loaderDeps: match2.loaderDeps,
|
|
params: match2._strictParams,
|
|
search: match2._strictSearch
|
|
});
|
|
const key2 = remountDeps ? JSON.stringify(remountDeps) : void 0;
|
|
const Comp = route2.options.component ?? router.options.defaultComponent;
|
|
const out2 = Comp ? (0, import_jsx_runtime11.jsx)(Comp, {}, key2) : (0, import_jsx_runtime11.jsx)(Outlet, {});
|
|
if (match2._displayPending) throw getMatchPromise(match2, "displayPendingPromise");
|
|
if (match2._forcePending) throw getMatchPromise(match2, "minPendingPromise");
|
|
if (match2.status === "pending") throw getMatchPromise(match2, "loadPromise");
|
|
if (match2.status === "notFound") {
|
|
if (!isNotFound(match2.error)) {
|
|
if (true) throw new Error("Invariant failed: Expected a notFound error");
|
|
invariant();
|
|
}
|
|
return renderRouteNotFound(router, route2, match2.error);
|
|
}
|
|
if (match2.status === "redirected") {
|
|
if (!isRedirect(match2.error)) {
|
|
if (true) throw new Error("Invariant failed: Expected a redirect error");
|
|
invariant();
|
|
}
|
|
throw getMatchPromise(match2, "loadPromise");
|
|
}
|
|
if (match2.status === "error") return (0, import_jsx_runtime11.jsx)((route2.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent, {
|
|
error: match2.error,
|
|
reset: void 0,
|
|
info: { componentStack: "" }
|
|
});
|
|
return out2;
|
|
}
|
|
const matchStore = router.stores.matchStores.get(matchId);
|
|
if (!matchStore) {
|
|
if (true) throw new Error(`Invariant failed: Could not find match for matchId "${matchId}". Please file an issue!`);
|
|
invariant();
|
|
}
|
|
const match = useStore(matchStore, (value) => value);
|
|
const routeId = match.routeId;
|
|
const route = router.routesById[routeId];
|
|
const key = React$111.useMemo(() => {
|
|
var _a2;
|
|
const remountDeps = (_a2 = router.routesById[routeId].options.remountDeps ?? router.options.defaultRemountDeps) == null ? void 0 : _a2({
|
|
routeId,
|
|
loaderDeps: match.loaderDeps,
|
|
params: match._strictParams,
|
|
search: match._strictSearch
|
|
});
|
|
return remountDeps ? JSON.stringify(remountDeps) : void 0;
|
|
}, [
|
|
routeId,
|
|
match.loaderDeps,
|
|
match._strictParams,
|
|
match._strictSearch,
|
|
router.options.defaultRemountDeps,
|
|
router.routesById
|
|
]);
|
|
const out = React$111.useMemo(() => {
|
|
const Comp = route.options.component ?? router.options.defaultComponent;
|
|
if (Comp) return (0, import_jsx_runtime11.jsx)(Comp, {}, key);
|
|
return (0, import_jsx_runtime11.jsx)(Outlet, {});
|
|
}, [
|
|
key,
|
|
route.options.component,
|
|
router.options.defaultComponent
|
|
]);
|
|
if (match._displayPending) throw getMatchPromise(match, "displayPendingPromise");
|
|
if (match._forcePending) throw getMatchPromise(match, "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 (!(isServer ?? router.isServer)) {
|
|
const minPendingPromise = createControlledPromise();
|
|
routerMatch._nonReactive.minPendingPromise = minPendingPromise;
|
|
setTimeout(() => {
|
|
minPendingPromise.resolve();
|
|
routerMatch._nonReactive.minPendingPromise = void 0;
|
|
}, pendingMinMs);
|
|
}
|
|
}
|
|
}
|
|
throw getMatchPromise(match, "loadPromise");
|
|
}
|
|
if (match.status === "notFound") {
|
|
if (!isNotFound(match.error)) {
|
|
if (true) throw new Error("Invariant failed: Expected a notFound error");
|
|
invariant();
|
|
}
|
|
return renderRouteNotFound(router, route, match.error);
|
|
}
|
|
if (match.status === "redirected") {
|
|
if (!isRedirect(match.error)) {
|
|
if (true) throw new Error("Invariant failed: Expected a redirect error");
|
|
invariant();
|
|
}
|
|
throw getMatchPromise(match, "loadPromise");
|
|
}
|
|
if (match.status === "error") {
|
|
if (isServer ?? router.isServer) return (0, import_jsx_runtime11.jsx)((route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent, {
|
|
error: match.error,
|
|
reset: void 0,
|
|
info: { componentStack: "" }
|
|
});
|
|
throw match.error;
|
|
}
|
|
return out;
|
|
});
|
|
var Outlet = React$111.memo(function OutletImpl() {
|
|
var _a;
|
|
const router = useRouter();
|
|
const matchId = React$111.useContext(matchContext);
|
|
let routeId;
|
|
let parentGlobalNotFound = false;
|
|
let childMatchId;
|
|
if (isServer ?? router.isServer) {
|
|
const matches = router.stores.matches.get();
|
|
const parentIndex = matchId ? matches.findIndex((match) => match.id === matchId) : -1;
|
|
const parentMatch = parentIndex >= 0 ? matches[parentIndex] : void 0;
|
|
routeId = parentMatch == null ? void 0 : parentMatch.routeId;
|
|
parentGlobalNotFound = (parentMatch == null ? void 0 : parentMatch.globalNotFound) ?? false;
|
|
childMatchId = parentIndex >= 0 ? (_a = matches[parentIndex + 1]) == null ? void 0 : _a.id : void 0;
|
|
} else {
|
|
const parentMatchStore = matchId ? router.stores.matchStores.get(matchId) : void 0;
|
|
[routeId, parentGlobalNotFound] = useStore(parentMatchStore, (match) => [match == null ? void 0 : match.routeId, (match == null ? void 0 : match.globalNotFound) ?? false]);
|
|
childMatchId = useStore(router.stores.matchesId, (ids) => {
|
|
return ids[ids.findIndex((id) => id === matchId) + 1];
|
|
});
|
|
}
|
|
const route = routeId ? router.routesById[routeId] : void 0;
|
|
const pendingElement = router.options.defaultPendingComponent ? (0, import_jsx_runtime11.jsx)(router.options.defaultPendingComponent, {}) : null;
|
|
if (parentGlobalNotFound) {
|
|
if (!route) {
|
|
if (true) throw new Error("Invariant failed: Could not resolve route for Outlet render");
|
|
invariant();
|
|
}
|
|
return renderRouteNotFound(router, route, void 0);
|
|
}
|
|
if (!childMatchId) return null;
|
|
const nextMatch = (0, import_jsx_runtime11.jsx)(Match, { matchId: childMatchId });
|
|
if (routeId === rootRouteId) return (0, import_jsx_runtime11.jsx)(React$111.Suspense, {
|
|
fallback: pendingElement,
|
|
children: nextMatch
|
|
});
|
|
return nextMatch;
|
|
});
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/Transitioner.js
|
|
var React$112 = __toESM(require_react(), 1);
|
|
function Transitioner() {
|
|
const router = useRouter();
|
|
const mountLoadForRouter = React$112.useRef({
|
|
router,
|
|
mounted: false
|
|
});
|
|
const [isTransitioning, setIsTransitioning] = React$112.useState(false);
|
|
const isLoading = useStore(router.stores.isLoading, (value) => value);
|
|
const hasPending = useStore(router.stores.hasPending, (value) => value);
|
|
const previousIsLoading = usePrevious(isLoading);
|
|
const isAnyPending = isLoading || isTransitioning || hasPending;
|
|
const previousIsAnyPending = usePrevious(isAnyPending);
|
|
const isPagePending = isLoading || hasPending;
|
|
const previousIsPagePending = usePrevious(isPagePending);
|
|
router.startTransition = (fn) => {
|
|
setIsTransitioning(true);
|
|
React$112.startTransition(() => {
|
|
fn();
|
|
setIsTransitioning(false);
|
|
});
|
|
};
|
|
React$112.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 (trimPathRight2(router.latestLocation.publicHref) !== trimPathRight2(nextLocation.publicHref)) router.commitLocation({
|
|
...nextLocation,
|
|
replace: true
|
|
});
|
|
return () => {
|
|
unsub();
|
|
};
|
|
}, [router, router.history]);
|
|
useLayoutEffect2(() => {
|
|
if (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",
|
|
...getLocationChangeInfo(router.stores.location.get(), router.stores.resolvedLocation.get())
|
|
});
|
|
}, [
|
|
previousIsLoading,
|
|
router,
|
|
isLoading
|
|
]);
|
|
useLayoutEffect2(() => {
|
|
if (previousIsPagePending && !isPagePending) router.emit({
|
|
type: "onBeforeRouteMount",
|
|
...getLocationChangeInfo(router.stores.location.get(), router.stores.resolvedLocation.get())
|
|
});
|
|
}, [
|
|
isPagePending,
|
|
previousIsPagePending,
|
|
router
|
|
]);
|
|
useLayoutEffect2(() => {
|
|
if (previousIsAnyPending && !isAnyPending) {
|
|
const changeInfo = getLocationChangeInfo(router.stores.location.get(), router.stores.resolvedLocation.get());
|
|
router.emit({
|
|
type: "onResolved",
|
|
...changeInfo
|
|
});
|
|
batch(() => {
|
|
router.stores.status.set("idle");
|
|
router.stores.resolvedLocation.set(router.stores.location.get());
|
|
});
|
|
if (changeInfo.hrefChanged) handleHashScroll(router);
|
|
}
|
|
}, [
|
|
isAnyPending,
|
|
previousIsAnyPending,
|
|
router
|
|
]);
|
|
return null;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/Matches.js
|
|
var React$113 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
|
|
function Matches() {
|
|
const router = useRouter();
|
|
const PendingComponent = router.routesById[rootRouteId].options.pendingComponent ?? router.options.defaultPendingComponent;
|
|
const pendingElement = PendingComponent ? (0, import_jsx_runtime12.jsx)(PendingComponent, {}) : null;
|
|
const inner = (0, import_jsx_runtime12.jsxs)((isServer ?? router.isServer) || typeof document !== "undefined" && router.ssr ? SafeFragment : React$113.Suspense, {
|
|
fallback: pendingElement,
|
|
children: [!(isServer ?? router.isServer) && (0, import_jsx_runtime12.jsx)(Transitioner, {}), (0, import_jsx_runtime12.jsx)(MatchesInner, {})]
|
|
});
|
|
return router.options.InnerWrap ? (0, import_jsx_runtime12.jsx)(router.options.InnerWrap, { children: inner }) : inner;
|
|
}
|
|
function MatchesInner() {
|
|
const router = useRouter();
|
|
const _isServer = isServer ?? router.isServer;
|
|
const matchId = _isServer ? router.stores.firstId.get() : useStore(router.stores.firstId, (id) => id);
|
|
const resetKey = _isServer ? router.stores.loadedAt.get() : useStore(router.stores.loadedAt, (loadedAt) => loadedAt);
|
|
const matchComponent = matchId ? (0, import_jsx_runtime12.jsx)(Match, { matchId }) : null;
|
|
return (0, import_jsx_runtime12.jsx)(matchContext.Provider, {
|
|
value: matchId,
|
|
children: router.options.disableGlobalCatchBoundary ? matchComponent : (0, import_jsx_runtime12.jsx)(CatchBoundary, {
|
|
getResetKey: () => resetKey,
|
|
errorComponent: ErrorComponent,
|
|
onCatch: true ? (error) => {
|
|
console.warn(`Warning: The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!`);
|
|
console.warn(`Warning: ${error.message || error.toString()}`);
|
|
} : void 0,
|
|
children: matchComponent
|
|
})
|
|
});
|
|
}
|
|
function useMatchRoute() {
|
|
const router = useRouter();
|
|
if (!(isServer ?? router.isServer)) useStore(router.stores.matchRouteDeps, (d) => d);
|
|
return React$113.useCallback((opts) => {
|
|
const { pending, caseSensitive, fuzzy, includeSearch, ...rest } = opts;
|
|
return router.matchRoute(rest, {
|
|
pending,
|
|
caseSensitive,
|
|
fuzzy,
|
|
includeSearch
|
|
});
|
|
}, [router]);
|
|
}
|
|
function MatchRoute(props) {
|
|
const params = useMatchRoute()(props);
|
|
if (typeof props.children === "function") return props.children(params);
|
|
return params ? props.children : null;
|
|
}
|
|
function useMatches(opts) {
|
|
const router = useRouter();
|
|
const previousResult = React$113.useRef(void 0);
|
|
if (isServer ?? router.isServer) {
|
|
const matches = router.stores.matches.get();
|
|
return (opts == null ? void 0 : opts.select) ? opts.select(matches) : matches;
|
|
}
|
|
return useStore(router.stores.matches, (matches) => {
|
|
const selected = (opts == null ? void 0 : opts.select) ? opts.select(matches) : matches;
|
|
if ((opts == null ? void 0 : opts.structuralSharing) ?? router.options.defaultStructuralSharing) {
|
|
const shared = replaceEqualDeep(previousResult.current, selected);
|
|
previousResult.current = shared;
|
|
return shared;
|
|
}
|
|
return selected;
|
|
});
|
|
}
|
|
function useParentMatches(opts) {
|
|
const contextMatchId = React$113.useContext(matchContext);
|
|
return useMatches({
|
|
select: (matches) => {
|
|
matches = matches.slice(0, matches.findIndex((d) => d.id === contextMatchId));
|
|
return (opts == null ? void 0 : opts.select) ? opts.select(matches) : matches;
|
|
},
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
|
});
|
|
}
|
|
function useChildMatches(opts) {
|
|
const contextMatchId = React$113.useContext(matchContext);
|
|
return useMatches({
|
|
select: (matches) => {
|
|
matches = matches.slice(matches.findIndex((d) => d.id === contextMatchId) + 1);
|
|
return (opts == null ? void 0 : opts.select) ? opts.select(matches) : matches;
|
|
},
|
|
structuralSharing: opts == null ? void 0 : opts.structuralSharing
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/routerStores.js
|
|
var getStoreFactory = (opts) => {
|
|
if (isServer ?? opts.isServer) return {
|
|
createMutableStore: createNonReactiveMutableStore,
|
|
createReadonlyStore: createNonReactiveReadonlyStore,
|
|
batch: (fn) => fn()
|
|
};
|
|
return {
|
|
createMutableStore: createAtom,
|
|
createReadonlyStore: createAtom,
|
|
batch
|
|
};
|
|
};
|
|
|
|
// 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, getStoreFactory);
|
|
}
|
|
};
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/RouterProvider.js
|
|
var import_react7 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime13 = __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 provider = (0, import_jsx_runtime13.jsx)(routerContext.Provider, {
|
|
value: router,
|
|
children
|
|
});
|
|
if (router.options.Wrap) return (0, import_jsx_runtime13.jsx)(router.options.Wrap, { children: provider });
|
|
return provider;
|
|
}
|
|
function RouterProvider({ router, ...rest }) {
|
|
return (0, import_jsx_runtime13.jsx)(RouterContextProvider, {
|
|
router,
|
|
...rest,
|
|
children: (0, import_jsx_runtime13.jsx)(Matches, {})
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/ScrollRestoration.js
|
|
function useScrollRestoration() {
|
|
setupScrollRestoration(useRouter(), true);
|
|
}
|
|
function ScrollRestoration2(_props) {
|
|
useScrollRestoration();
|
|
if (true) console.warn("The ScrollRestoration component is deprecated. Use createRouter's `scrollRestoration` option instead.");
|
|
return null;
|
|
}
|
|
function useElementScrollRestoration(options) {
|
|
useScrollRestoration();
|
|
return getElementScrollRestorationEntry(useRouter(), options);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/useBlocker.js
|
|
var React$114 = __toESM(require_react(), 1);
|
|
function _resolveBlockerOpts(opts, condition) {
|
|
if (opts === void 0) return {
|
|
shouldBlockFn: () => true,
|
|
withResolver: false
|
|
};
|
|
if ("shouldBlockFn" in opts) return opts;
|
|
if (typeof opts === "function") {
|
|
const shouldBlock2 = Boolean(condition ?? true);
|
|
const _customBlockerFn2 = async () => {
|
|
if (shouldBlock2) return await opts();
|
|
return false;
|
|
};
|
|
return {
|
|
shouldBlockFn: _customBlockerFn2,
|
|
enableBeforeUnload: shouldBlock2,
|
|
withResolver: false
|
|
};
|
|
}
|
|
const shouldBlock = Boolean(opts.condition ?? true);
|
|
const fn = opts.blockerFn;
|
|
const _customBlockerFn = async () => {
|
|
if (shouldBlock && fn !== void 0) return await fn();
|
|
return shouldBlock;
|
|
};
|
|
return {
|
|
shouldBlockFn: _customBlockerFn,
|
|
enableBeforeUnload: shouldBlock,
|
|
withResolver: fn === void 0
|
|
};
|
|
}
|
|
function useBlocker(opts, condition) {
|
|
const { shouldBlockFn, enableBeforeUnload = true, disabled = false, withResolver = false } = _resolveBlockerOpts(opts, condition);
|
|
const router = useRouter();
|
|
const { history } = router;
|
|
const [resolver, setResolver] = React$114.useState({
|
|
status: "idle",
|
|
current: void 0,
|
|
next: void 0,
|
|
action: void 0,
|
|
proceed: void 0,
|
|
reset: void 0
|
|
});
|
|
React$114.useEffect(() => {
|
|
const blockerFnComposed = async (blockerFnArgs) => {
|
|
function getLocation(location) {
|
|
const parsedLocation = router.parseLocation(location);
|
|
const matchedRoutes = router.getMatchedRoutes(parsedLocation.pathname);
|
|
if (matchedRoutes.foundRoute === void 0) return {
|
|
routeId: "__notFound__",
|
|
fullPath: parsedLocation.pathname,
|
|
pathname: parsedLocation.pathname,
|
|
params: matchedRoutes.routeParams,
|
|
search: router.options.parseSearch(location.search)
|
|
};
|
|
return {
|
|
routeId: matchedRoutes.foundRoute.id,
|
|
fullPath: matchedRoutes.foundRoute.fullPath,
|
|
pathname: parsedLocation.pathname,
|
|
params: matchedRoutes.routeParams,
|
|
search: router.options.parseSearch(location.search)
|
|
};
|
|
}
|
|
const current = getLocation(blockerFnArgs.currentLocation);
|
|
const next = getLocation(blockerFnArgs.nextLocation);
|
|
if (current.routeId === "__notFound__" && next.routeId !== "__notFound__") return false;
|
|
const shouldBlock = await shouldBlockFn({
|
|
action: blockerFnArgs.action,
|
|
current,
|
|
next
|
|
});
|
|
if (!withResolver) return shouldBlock;
|
|
if (!shouldBlock) return false;
|
|
const canNavigateAsync = await new Promise((resolve) => {
|
|
setResolver({
|
|
status: "blocked",
|
|
current,
|
|
next,
|
|
action: blockerFnArgs.action,
|
|
proceed: () => resolve(false),
|
|
reset: () => resolve(true)
|
|
});
|
|
});
|
|
setResolver({
|
|
status: "idle",
|
|
current: void 0,
|
|
next: void 0,
|
|
action: void 0,
|
|
proceed: void 0,
|
|
reset: void 0
|
|
});
|
|
return canNavigateAsync;
|
|
};
|
|
return disabled ? void 0 : history.block({
|
|
blockerFn: blockerFnComposed,
|
|
enableBeforeUnload
|
|
});
|
|
}, [
|
|
shouldBlockFn,
|
|
enableBeforeUnload,
|
|
disabled,
|
|
withResolver,
|
|
history,
|
|
router
|
|
]);
|
|
return resolver;
|
|
}
|
|
var _resolvePromptBlockerArgs = (props) => {
|
|
if ("shouldBlockFn" in props) return { ...props };
|
|
const shouldBlock = Boolean(props.condition ?? true);
|
|
const fn = props.blockerFn;
|
|
const _customBlockerFn = async () => {
|
|
if (shouldBlock && fn !== void 0) return await fn();
|
|
return shouldBlock;
|
|
};
|
|
return {
|
|
shouldBlockFn: _customBlockerFn,
|
|
enableBeforeUnload: shouldBlock,
|
|
withResolver: fn === void 0
|
|
};
|
|
};
|
|
function Block(opts) {
|
|
const { children, ...rest } = opts;
|
|
const resolver = useBlocker(_resolvePromptBlockerArgs(rest));
|
|
return children ? typeof children === "function" ? children(resolver) : children : null;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/useRouterState.js
|
|
var import_react8 = __toESM(require_react(), 1);
|
|
function useRouterState(opts) {
|
|
const contextRouter = useRouter({ warn: (opts == null ? void 0 : opts.router) === void 0 });
|
|
const router = (opts == null ? void 0 : opts.router) || contextRouter;
|
|
if (isServer ?? router.isServer) {
|
|
const state = router.stores.__store.get();
|
|
return (opts == null ? void 0 : opts.select) ? opts.select(state) : state;
|
|
}
|
|
const previousResult = (0, import_react8.useRef)(void 0);
|
|
return useStore(router.stores.__store, (state) => {
|
|
if (opts == null ? void 0 : 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/useLocation.js
|
|
var import_react9 = __toESM(require_react(), 1);
|
|
function useLocation(opts) {
|
|
const router = useRouter();
|
|
if (isServer ?? router.isServer) {
|
|
const location = router.stores.location.get();
|
|
return (opts == null ? void 0 : opts.select) ? opts.select(location) : location;
|
|
}
|
|
const previousResult = (0, import_react9.useRef)(void 0);
|
|
return useStore(router.stores.location, (location) => {
|
|
const selected = (opts == null ? void 0 : opts.select) ? opts.select(location) : location;
|
|
if ((opts == null ? void 0 : opts.structuralSharing) ?? router.options.defaultStructuralSharing) {
|
|
const shared = replaceEqualDeep(previousResult.current, selected);
|
|
previousResult.current = shared;
|
|
return shared;
|
|
}
|
|
return selected;
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/useCanGoBack.js
|
|
function useCanGoBack() {
|
|
const router = useRouter();
|
|
if (isServer ?? router.isServer) return router.stores.location.get().state.__TSR_index !== 0;
|
|
return useStore(router.stores.location, (location) => location.state.__TSR_index !== 0);
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/Asset.js
|
|
var React$115 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
|
|
function Asset({ tag, attrs, children, nonce }) {
|
|
switch (tag) {
|
|
case "title":
|
|
return (0, import_jsx_runtime14.jsx)("title", {
|
|
...attrs,
|
|
suppressHydrationWarning: true,
|
|
children
|
|
});
|
|
case "meta":
|
|
return (0, import_jsx_runtime14.jsx)("meta", {
|
|
...attrs,
|
|
suppressHydrationWarning: true
|
|
});
|
|
case "link":
|
|
return (0, import_jsx_runtime14.jsx)("link", {
|
|
...attrs,
|
|
precedence: (attrs == null ? void 0 : attrs.precedence) ?? ((attrs == null ? void 0 : attrs.rel) === "stylesheet" ? "default" : void 0),
|
|
nonce,
|
|
suppressHydrationWarning: true
|
|
});
|
|
case "style":
|
|
return (0, import_jsx_runtime14.jsx)("style", {
|
|
...attrs,
|
|
dangerouslySetInnerHTML: { __html: children },
|
|
nonce
|
|
});
|
|
case "script":
|
|
return (0, import_jsx_runtime14.jsx)(Script, {
|
|
attrs,
|
|
children
|
|
});
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
function Script({ attrs, children }) {
|
|
const router = useRouter();
|
|
const hydrated = useHydrated();
|
|
const dataScript = typeof (attrs == null ? void 0 : attrs.type) === "string" && attrs.type !== "" && attrs.type !== "text/javascript" && attrs.type !== "module";
|
|
if ((attrs == null ? void 0 : attrs.src) && typeof children === "string" && children.trim().length) console.warn("[TanStack Router] <Script> received both `src` and `children`. The `children` content will be ignored. Remove `children` or remove `src`.");
|
|
React$115.useEffect(() => {
|
|
if (dataScript) return;
|
|
if (attrs == null ? void 0 : attrs.src) {
|
|
const normSrc = (() => {
|
|
try {
|
|
const base = document.baseURI || window.location.href;
|
|
return new URL(attrs.src, base).href;
|
|
} catch {
|
|
return attrs.src;
|
|
}
|
|
})();
|
|
if (Array.from(document.querySelectorAll("script[src]")).find((el) => el.src === normSrc)) return;
|
|
const script = document.createElement("script");
|
|
for (const [key, value] of Object.entries(attrs)) if (key !== "suppressHydrationWarning" && value !== void 0 && value !== false) script.setAttribute(key, typeof value === "boolean" ? "" : String(value));
|
|
document.head.appendChild(script);
|
|
return () => {
|
|
if (script.parentNode) script.parentNode.removeChild(script);
|
|
};
|
|
}
|
|
if (typeof children === "string") {
|
|
const typeAttr = typeof (attrs == null ? void 0 : attrs.type) === "string" ? attrs.type : "text/javascript";
|
|
const nonceAttr = typeof (attrs == null ? void 0 : attrs.nonce) === "string" ? attrs.nonce : void 0;
|
|
if (Array.from(document.querySelectorAll("script:not([src])")).find((el) => {
|
|
if (!(el instanceof HTMLScriptElement)) return false;
|
|
const sType = el.getAttribute("type") ?? "text/javascript";
|
|
const sNonce = el.getAttribute("nonce") ?? void 0;
|
|
return el.textContent === children && sType === typeAttr && sNonce === nonceAttr;
|
|
})) return;
|
|
const script = document.createElement("script");
|
|
script.textContent = children;
|
|
if (attrs) {
|
|
for (const [key, value] of Object.entries(attrs)) if (key !== "suppressHydrationWarning" && value !== void 0 && value !== false) script.setAttribute(key, typeof value === "boolean" ? "" : String(value));
|
|
}
|
|
document.head.appendChild(script);
|
|
return () => {
|
|
if (script.parentNode) script.parentNode.removeChild(script);
|
|
};
|
|
}
|
|
}, [
|
|
attrs,
|
|
children,
|
|
dataScript
|
|
]);
|
|
if (isServer ?? router.isServer) {
|
|
if (attrs == null ? void 0 : attrs.src) return (0, import_jsx_runtime14.jsx)("script", {
|
|
...attrs,
|
|
suppressHydrationWarning: true
|
|
});
|
|
if (typeof children === "string") return (0, import_jsx_runtime14.jsx)("script", {
|
|
...attrs,
|
|
dangerouslySetInnerHTML: { __html: children },
|
|
suppressHydrationWarning: true
|
|
});
|
|
return null;
|
|
}
|
|
if (dataScript && typeof children === "string") return (0, import_jsx_runtime14.jsx)("script", {
|
|
...attrs,
|
|
suppressHydrationWarning: true,
|
|
dangerouslySetInnerHTML: { __html: children }
|
|
});
|
|
if (!hydrated) {
|
|
if (attrs == null ? void 0 : attrs.src) return (0, import_jsx_runtime14.jsx)("script", {
|
|
...attrs,
|
|
suppressHydrationWarning: true
|
|
});
|
|
if (typeof children === "string") return (0, import_jsx_runtime14.jsx)("script", {
|
|
...attrs,
|
|
dangerouslySetInnerHTML: { __html: children },
|
|
suppressHydrationWarning: true
|
|
});
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/headContentUtils.js
|
|
var React$116 = __toESM(require_react(), 1);
|
|
function buildTagsFromMatches(router, nonce, matches, assetCrossOrigin) {
|
|
var _a;
|
|
const routeMeta = matches.map((match) => match.meta).filter(Boolean);
|
|
const resultMeta = [];
|
|
const metaByAttribute = {};
|
|
let title;
|
|
for (let i = routeMeta.length - 1; i >= 0; i--) {
|
|
const metas = routeMeta[i];
|
|
for (let j = metas.length - 1; j >= 0; j--) {
|
|
const m = metas[j];
|
|
if (!m) continue;
|
|
if (m.title) {
|
|
if (!title) title = {
|
|
tag: "title",
|
|
children: m.title
|
|
};
|
|
} else if ("script:ld+json" in m) try {
|
|
const json = JSON.stringify(m["script:ld+json"]);
|
|
resultMeta.push({
|
|
tag: "script",
|
|
attrs: { type: "application/ld+json" },
|
|
children: escapeHtml(json)
|
|
});
|
|
} catch {
|
|
}
|
|
else {
|
|
const attribute = m.name ?? m.property;
|
|
if (attribute) if (metaByAttribute[attribute]) continue;
|
|
else metaByAttribute[attribute] = true;
|
|
resultMeta.push({
|
|
tag: "meta",
|
|
attrs: {
|
|
...m,
|
|
nonce
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (title) resultMeta.push(title);
|
|
if (nonce) resultMeta.push({
|
|
tag: "meta",
|
|
attrs: {
|
|
property: "csp-nonce",
|
|
content: nonce
|
|
}
|
|
});
|
|
resultMeta.reverse();
|
|
const constructedLinks = matches.map((match) => match.links).filter(Boolean).flat(1).map((link2) => ({
|
|
tag: "link",
|
|
attrs: {
|
|
...link2,
|
|
nonce
|
|
}
|
|
}));
|
|
const manifest = (_a = router.ssr) == null ? void 0 : _a.manifest;
|
|
const assetLinks = matches.map((match) => {
|
|
var _a2;
|
|
return ((_a2 = manifest == null ? void 0 : manifest.routes[match.routeId]) == null ? void 0 : _a2.assets) ?? [];
|
|
}).filter(Boolean).flat(1).filter((asset) => asset.tag === "link").map((asset) => {
|
|
var _a2;
|
|
return {
|
|
tag: "link",
|
|
attrs: {
|
|
...asset.attrs,
|
|
crossOrigin: getAssetCrossOrigin(assetCrossOrigin, "stylesheet") ?? ((_a2 = asset.attrs) == null ? void 0 : _a2.crossOrigin),
|
|
suppressHydrationWarning: true,
|
|
nonce
|
|
}
|
|
};
|
|
});
|
|
const preloadLinks = [];
|
|
matches.map((match) => router.looseRoutesById[match.routeId]).forEach((route) => {
|
|
var _a2, _b, _c, _d;
|
|
return (_d = (_c = (_b = (_a2 = router.ssr) == null ? void 0 : _a2.manifest) == null ? void 0 : _b.routes[route.id]) == null ? void 0 : _c.preloads) == null ? void 0 : _d.filter(Boolean).forEach((preload) => {
|
|
const preloadLink = resolveManifestAssetLink(preload);
|
|
preloadLinks.push({
|
|
tag: "link",
|
|
attrs: {
|
|
rel: "modulepreload",
|
|
href: preloadLink.href,
|
|
crossOrigin: getAssetCrossOrigin(assetCrossOrigin, "modulepreload") ?? preloadLink.crossOrigin,
|
|
nonce
|
|
}
|
|
});
|
|
});
|
|
});
|
|
const styles = matches.map((match) => match.styles).flat(1).filter(Boolean).map(({ children, ...attrs }) => ({
|
|
tag: "style",
|
|
attrs: {
|
|
...attrs,
|
|
nonce
|
|
},
|
|
children
|
|
}));
|
|
const headScripts = matches.map((match) => match.headScripts).flat(1).filter(Boolean).map(({ children, ...script }) => ({
|
|
tag: "script",
|
|
attrs: {
|
|
...script,
|
|
nonce
|
|
},
|
|
children
|
|
}));
|
|
return uniqBy([
|
|
...resultMeta,
|
|
...preloadLinks,
|
|
...constructedLinks,
|
|
...assetLinks,
|
|
...styles,
|
|
...headScripts
|
|
], (d) => JSON.stringify(d));
|
|
}
|
|
var useTags = (assetCrossOrigin) => {
|
|
var _a;
|
|
const router = useRouter();
|
|
const nonce = (_a = router.options.ssr) == null ? void 0 : _a.nonce;
|
|
if (isServer ?? router.isServer) return buildTagsFromMatches(router, nonce, router.stores.matches.get(), assetCrossOrigin);
|
|
const routeMeta = useStore(router.stores.matches, (matches) => {
|
|
return matches.map((match) => match.meta).filter(Boolean);
|
|
}, deepEqual);
|
|
const meta = React$116.useMemo(() => {
|
|
const resultMeta = [];
|
|
const metaByAttribute = {};
|
|
let title;
|
|
for (let i = routeMeta.length - 1; i >= 0; i--) {
|
|
const metas = routeMeta[i];
|
|
for (let j = metas.length - 1; j >= 0; j--) {
|
|
const m = metas[j];
|
|
if (!m) continue;
|
|
if (m.title) {
|
|
if (!title) title = {
|
|
tag: "title",
|
|
children: m.title
|
|
};
|
|
} else if ("script:ld+json" in m) try {
|
|
const json = JSON.stringify(m["script:ld+json"]);
|
|
resultMeta.push({
|
|
tag: "script",
|
|
attrs: { type: "application/ld+json" },
|
|
children: escapeHtml(json)
|
|
});
|
|
} catch {
|
|
}
|
|
else {
|
|
const attribute = m.name ?? m.property;
|
|
if (attribute) if (metaByAttribute[attribute]) continue;
|
|
else metaByAttribute[attribute] = true;
|
|
resultMeta.push({
|
|
tag: "meta",
|
|
attrs: {
|
|
...m,
|
|
nonce
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (title) resultMeta.push(title);
|
|
if (nonce) resultMeta.push({
|
|
tag: "meta",
|
|
attrs: {
|
|
property: "csp-nonce",
|
|
content: nonce
|
|
}
|
|
});
|
|
resultMeta.reverse();
|
|
return resultMeta;
|
|
}, [routeMeta, nonce]);
|
|
const links = useStore(router.stores.matches, (matches) => {
|
|
var _a2;
|
|
const constructed = matches.map((match) => match.links).filter(Boolean).flat(1).map((link2) => ({
|
|
tag: "link",
|
|
attrs: {
|
|
...link2,
|
|
nonce
|
|
}
|
|
}));
|
|
const manifest = (_a2 = router.ssr) == null ? void 0 : _a2.manifest;
|
|
const assets = matches.map((match) => {
|
|
var _a3;
|
|
return ((_a3 = manifest == null ? void 0 : manifest.routes[match.routeId]) == null ? void 0 : _a3.assets) ?? [];
|
|
}).filter(Boolean).flat(1).filter((asset) => asset.tag === "link").map((asset) => {
|
|
var _a3;
|
|
return {
|
|
tag: "link",
|
|
attrs: {
|
|
...asset.attrs,
|
|
crossOrigin: getAssetCrossOrigin(assetCrossOrigin, "stylesheet") ?? ((_a3 = asset.attrs) == null ? void 0 : _a3.crossOrigin),
|
|
suppressHydrationWarning: true,
|
|
nonce
|
|
}
|
|
};
|
|
});
|
|
return [...constructed, ...assets];
|
|
}, deepEqual);
|
|
const preloadLinks = useStore(router.stores.matches, (matches) => {
|
|
const preloadLinks2 = [];
|
|
matches.map((match) => router.looseRoutesById[match.routeId]).forEach((route) => {
|
|
var _a2, _b, _c, _d;
|
|
return (_d = (_c = (_b = (_a2 = router.ssr) == null ? void 0 : _a2.manifest) == null ? void 0 : _b.routes[route.id]) == null ? void 0 : _c.preloads) == null ? void 0 : _d.filter(Boolean).forEach((preload) => {
|
|
const preloadLink = resolveManifestAssetLink(preload);
|
|
preloadLinks2.push({
|
|
tag: "link",
|
|
attrs: {
|
|
rel: "modulepreload",
|
|
href: preloadLink.href,
|
|
crossOrigin: getAssetCrossOrigin(assetCrossOrigin, "modulepreload") ?? preloadLink.crossOrigin,
|
|
nonce
|
|
}
|
|
});
|
|
});
|
|
});
|
|
return preloadLinks2;
|
|
}, deepEqual);
|
|
const styles = useStore(router.stores.matches, (matches) => matches.map((match) => match.styles).flat(1).filter(Boolean).map(({ children, ...attrs }) => ({
|
|
tag: "style",
|
|
attrs: {
|
|
...attrs,
|
|
nonce
|
|
},
|
|
children
|
|
})), deepEqual);
|
|
const headScripts = useStore(router.stores.matches, (matches) => matches.map((match) => match.headScripts).flat(1).filter(Boolean).map(({ children, ...script }) => ({
|
|
tag: "script",
|
|
attrs: {
|
|
...script,
|
|
nonce
|
|
},
|
|
children
|
|
})), deepEqual);
|
|
return uniqBy([
|
|
...meta,
|
|
...preloadLinks,
|
|
...links,
|
|
...styles,
|
|
...headScripts
|
|
], (d) => {
|
|
return JSON.stringify(d);
|
|
});
|
|
};
|
|
function uniqBy(arr, fn) {
|
|
const seen = /* @__PURE__ */ new Set();
|
|
return arr.filter((item) => {
|
|
const key = fn(item);
|
|
if (seen.has(key)) return false;
|
|
seen.add(key);
|
|
return true;
|
|
});
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/Scripts.js
|
|
var import_react10 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
|
|
var Scripts = () => {
|
|
var _a;
|
|
const router = useRouter();
|
|
const nonce = (_a = router.options.ssr) == null ? void 0 : _a.nonce;
|
|
const getAssetScripts = (matches) => {
|
|
var _a2;
|
|
const assetScripts2 = [];
|
|
const manifest = (_a2 = router.ssr) == null ? void 0 : _a2.manifest;
|
|
if (!manifest) return [];
|
|
matches.map((match) => router.looseRoutesById[match.routeId]).forEach((route) => {
|
|
var _a3, _b;
|
|
return (_b = (_a3 = manifest.routes[route.id]) == null ? void 0 : _a3.assets) == null ? void 0 : _b.filter((d) => d.tag === "script").forEach((asset) => {
|
|
assetScripts2.push({
|
|
tag: "script",
|
|
attrs: {
|
|
...asset.attrs,
|
|
nonce
|
|
},
|
|
children: asset.children
|
|
});
|
|
});
|
|
});
|
|
return assetScripts2;
|
|
};
|
|
const getScripts = (matches) => matches.map((match) => match.scripts).flat(1).filter(Boolean).map(({ children, ...script }) => ({
|
|
tag: "script",
|
|
attrs: {
|
|
...script,
|
|
suppressHydrationWarning: true,
|
|
nonce
|
|
},
|
|
children
|
|
}));
|
|
if (isServer ?? router.isServer) {
|
|
const activeMatches = router.stores.matches.get();
|
|
const assetScripts2 = getAssetScripts(activeMatches);
|
|
return renderScripts(router, getScripts(activeMatches), assetScripts2);
|
|
}
|
|
const assetScripts = useStore(router.stores.matches, getAssetScripts, deepEqual);
|
|
return renderScripts(router, useStore(router.stores.matches, getScripts, deepEqual), assetScripts);
|
|
};
|
|
function renderScripts(router, scripts, assetScripts) {
|
|
let serverBufferedScript = void 0;
|
|
if (router.serverSsr) serverBufferedScript = router.serverSsr.takeBufferedScripts();
|
|
const allScripts = [...scripts, ...assetScripts];
|
|
if (serverBufferedScript) allScripts.unshift(serverBufferedScript);
|
|
return (0, import_jsx_runtime15.jsx)(import_jsx_runtime15.Fragment, { children: allScripts.map((asset, i) => (0, import_react10.createElement)(Asset, {
|
|
...asset,
|
|
key: `tsr-scripts-${asset.tag}-${i}`
|
|
})) });
|
|
}
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/HeadContent.js
|
|
var import_react11 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
|
|
|
|
// node_modules/@tanstack/react-router/dist/esm/HeadContent.dev.js
|
|
var React$117 = __toESM(require_react(), 1);
|
|
var import_react12 = __toESM(require_react(), 1);
|
|
var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
|
|
var DEV_STYLES_ATTR = "data-tanstack-router-dev-styles";
|
|
function HeadContent2(props) {
|
|
var _a;
|
|
const tags = useTags(props.assetCrossOrigin);
|
|
const nonce = (_a = useRouter().options.ssr) == null ? void 0 : _a.nonce;
|
|
const hydrated = useHydrated();
|
|
React$117.useEffect(() => {
|
|
if (hydrated) document.querySelectorAll(`link[${DEV_STYLES_ATTR}]`).forEach((el) => el.remove());
|
|
}, [hydrated]);
|
|
return (0, import_jsx_runtime17.jsx)(import_jsx_runtime17.Fragment, { children: (hydrated ? tags.filter((tag) => {
|
|
var _a2;
|
|
return !((_a2 = tag.attrs) == null ? void 0 : _a2[DEV_STYLES_ATTR]);
|
|
}) : tags).map((tag) => (0, import_react12.createElement)(Asset, {
|
|
...tag,
|
|
key: `tsr-meta-${JSON.stringify(tag)}`,
|
|
nonce
|
|
})) });
|
|
}
|
|
export {
|
|
Asset,
|
|
Await,
|
|
Block,
|
|
CatchBoundary,
|
|
CatchNotFound,
|
|
ClientOnly,
|
|
DEFAULT_PROTOCOL_ALLOWLIST,
|
|
DefaultGlobalNotFound,
|
|
ErrorComponent,
|
|
FileRoute,
|
|
FileRouteLoader,
|
|
HeadContent2 as HeadContent,
|
|
LazyRoute,
|
|
Link,
|
|
Match,
|
|
MatchRoute,
|
|
Matches,
|
|
Navigate,
|
|
NotFoundRoute,
|
|
Outlet,
|
|
RootRoute,
|
|
Route,
|
|
RouteApi,
|
|
Router,
|
|
RouterContextProvider,
|
|
RouterProvider,
|
|
ScriptOnce,
|
|
Scripts,
|
|
ScrollRestoration2 as ScrollRestoration,
|
|
SearchParamError,
|
|
cleanPath,
|
|
composeRewrites,
|
|
createBrowserHistory,
|
|
createControlledPromise,
|
|
createFileRoute,
|
|
createHashHistory,
|
|
createHistory,
|
|
createLazyFileRoute,
|
|
createLazyRoute,
|
|
createLink,
|
|
createMemoryHistory,
|
|
createRootRoute,
|
|
createRootRouteWithContext,
|
|
createRoute,
|
|
createRouteMask,
|
|
createRouter,
|
|
createRouterConfig,
|
|
createSerializationAdapter,
|
|
deepEqual,
|
|
defaultParseSearch,
|
|
defaultStringifySearch,
|
|
defer,
|
|
functionalUpdate,
|
|
getRouteApi,
|
|
interpolatePath,
|
|
isMatch,
|
|
isNotFound,
|
|
isPlainArray,
|
|
isPlainObject,
|
|
isRedirect,
|
|
joinPaths,
|
|
lazyFn,
|
|
lazyRouteComponent,
|
|
linkOptions,
|
|
notFound,
|
|
parseSearchWith,
|
|
redirect,
|
|
replaceEqualDeep,
|
|
resolvePath,
|
|
retainSearchParams,
|
|
rootRouteId,
|
|
rootRouteWithContext,
|
|
stringifySearchWith,
|
|
stripSearchParams,
|
|
trimPath,
|
|
trimPathLeft,
|
|
trimPathRight2 as trimPathRight,
|
|
useAwaited,
|
|
useBlocker,
|
|
useCanGoBack,
|
|
useChildMatches,
|
|
useElementScrollRestoration,
|
|
useHydrated,
|
|
useLinkProps,
|
|
useLoaderData,
|
|
useLoaderDeps,
|
|
useLocation,
|
|
useMatch,
|
|
useMatchRoute,
|
|
useMatches,
|
|
useNavigate,
|
|
useParams,
|
|
useParentMatches,
|
|
useRouteContext,
|
|
useRouter,
|
|
useRouterState,
|
|
useSearch,
|
|
useTags
|
|
};
|
|
/*! Bundled license information:
|
|
|
|
use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
|
|
(**
|
|
* @license React
|
|
* use-sync-external-store-shim.development.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*)
|
|
|
|
use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js:
|
|
(**
|
|
* @license React
|
|
* use-sync-external-store-shim/with-selector.development.js
|
|
*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*)
|
|
*/
|
|
//# sourceMappingURL=@tanstack_react-router.js.map
|