fumadocs-core 16.15.1 → 16.15.2

package/dist/i18n/middleware.js

@@ -1,4 +1,3 @@
-import { t as getNegotiator } from "../negotiation-DAsKgSvF.js";
 import { NextResponse } from "next/server.js";
 //#region ../../node_modules/.pnpm/@formatjs+fast-memoize@3.1.7/node_modules/@formatjs/fast-memoize/index.js
 function memoize(fn, options) {
@@ -3738,6 +3737,70 @@ function match(requestedLocales, availableLocales, defaultLocale, opts) {
 	return ResolveLocale(availableLocales, CanonicalizeLocaleList(requestedLocales), { localeMatcher: opts?.algorithm || "best fit" }, [], {}, () => defaultLocale).locale;
 }
 //#endregion
+//#region src/utils/accept-language.ts
+function parseAcceptLanguage(header) {
+	const specs = [];
+	for (const section of header.split(",")) {
+		const [rawTag, ...params] = section.split(";");
+		const full = rawTag.trim().toLowerCase();
+		if (full.length === 0) continue;
+		let quality = 1;
+		for (const param of params) {
+			const separator = param.indexOf("=");
+			if (separator === -1 || param.slice(0, separator).trim().toLowerCase() !== "q") continue;
+			const parsed = Number.parseFloat(param.slice(separator + 1));
+			if (!Number.isNaN(parsed)) quality = parsed;
+		}
+		const dash = full.indexOf("-");
+		specs.push({
+			prefix: dash === -1 ? full : full.slice(0, dash),
+			full,
+			quality,
+			order: specs.length
+		});
+	}
+	return specs;
+}
+function matchLanguage(language, specs) {
+	const full = language.trim().toLowerCase();
+	const dash = full.indexOf("-");
+	const prefix = dash === -1 ? full : full.slice(0, dash);
+	const best = {
+		language,
+		quality: 0,
+		specificity: 0,
+		order: -1
+	};
+	for (const spec of specs) {
+		let specificity;
+		if (spec.full === full) specificity = 4;
+		else if (spec.prefix === full) specificity = 2;
+		else if (spec.full === prefix) specificity = 1;
+		else if (spec.full === "*") specificity = 0;
+		else continue;
+		if ((specificity - best.specificity || spec.quality - best.quality || spec.order - best.order) > 0) {
+			best.quality = spec.quality;
+			best.specificity = specificity;
+			best.order = spec.order;
+		}
+	}
+	if (best.quality > 0) return best;
+}
+/**
+* Filter `available` down to the languages the `Accept-Language` header accepts, ordered by
+* client preference. A missing (`null`) header accepts everything.
+*/
+function negotiateLanguages(header, available) {
+	const specs = parseAcceptLanguage(header ?? "*");
+	const matches = [];
+	for (const language of available) {
+		const match = matchLanguage(language, specs);
+		if (match) matches.push(match);
+	}
+	matches.sort((a, b) => b.quality - a.quality || b.specificity - a.specificity || a.order - b.order);
+	return matches.map((match) => match.language);
+}
+//#endregion
 //#region src/i18n/middleware.ts
 const DefaultFormatter = {
 	get(url) {
@@ -3773,7 +3836,7 @@ function createI18nMiddleware({ languages, defaultLanguage, format = DefaultForm
 		if (pathLocale && !languages.includes(pathLocale)) pathLocale = void 0;
 		if (!pathLocale) {
 			if (hideLocale === "default-locale") return NextResponse.rewrite(formatter.add(url, defaultLanguage));
-			const preferred = match(getNegotiator(request).languages(languages), languages, defaultLanguage);
+			const preferred = match(negotiateLanguages(request.headers.get("accept-language"), languages), languages, defaultLanguage);
 			if (hideLocale === "always") {
 				const locale = request.cookies.get(cookieName)?.value ?? preferred;
 				return NextResponse.rewrite(formatter.add(url, locale));

package/dist/negotiation/index.d.ts

@@ -1,6 +1,4 @@
-import Negotiator from "negotiator";
 //#region src/negotiation/index.d.ts
-declare function getNegotiator(request: Request): Negotiator;
 /**
  * Rewrite incoming path matching the `source` pattern into the `destination` pattern.
  *
@@ -16,4 +14,4 @@ declare function isMarkdownPreferred(request: Request, options?: {
   markdownMediaTypes?: string[];
 }): boolean;
 //#endregion
-export { getNegotiator, isMarkdownPreferred, rewritePath };
+export { isMarkdownPreferred, rewritePath };

package/dist/negotiation/index.js

@@ -1,2 +1,378 @@
-import { n as isMarkdownPreferred, r as rewritePath, t as getNegotiator } from "../negotiation-DAsKgSvF.js";
-export { getNegotiator, isMarkdownPreferred, rewritePath };
+import { t as __commonJSMin } from "../rolldown-runtime-DC62tzP2.js";
+//#endregion
+//#region src/negotiation/index.ts
+var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.PathError = exports.TokenData = void 0;
+	exports.compile = compile;
+	exports.match = match;
+	const DEFAULT_DELIMITER = "/";
+	const NOOP_VALUE = (value) => value;
+	const ID_START = /^[$_\p{ID_Start}]$/u;
+	const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
+	/**
+	* Escape a regular expression string.
+	*/
+	function escape(str) {
+		return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+	}
+	/**
+	* Tokenized path instance.
+	*/
+	var TokenData = class {
+		constructor(tokens, originalPath) {
+			this.tokens = tokens;
+			this.originalPath = originalPath;
+		}
+	};
+	exports.TokenData = TokenData;
+	/**
+	* ParseError is thrown when there is an error processing the path.
+	*/
+	var PathError = class extends TypeError {
+		constructor(message, originalPath) {
+			let text = message;
+			if (originalPath) text += `: ${originalPath}`;
+			text += `; visit https://git.new/pathToRegexpError for info`;
+			super(text);
+			this.originalPath = originalPath;
+		}
+	};
+	exports.PathError = PathError;
+	/**
+	* Parse a string for the raw tokens.
+	*/
+	function parse(str, options = {}) {
+		const { encodePath = NOOP_VALUE } = options;
+		const chars = [...str];
+		let index = 0;
+		function consumeUntil(end) {
+			const output = [];
+			let path = "";
+			function writePath() {
+				if (!path) return;
+				output.push({
+					type: "text",
+					value: encodePath(path)
+				});
+				path = "";
+			}
+			while (index < chars.length) {
+				const value = chars[index++];
+				if (value === end) {
+					writePath();
+					return output;
+				}
+				if (value === "\\") {
+					if (index === chars.length) throw new PathError(`Unexpected end after \\ at index ${index}`, str);
+					path += chars[index++];
+					continue;
+				}
+				if (value === ":" || value === "*") {
+					const type = value === ":" ? "param" : "wildcard";
+					let name = "";
+					if (ID_START.test(chars[index])) do
+						name += chars[index++];
+					while (ID_CONTINUE.test(chars[index]));
+					else if (chars[index] === "\"") {
+						let quoteStart = index;
+						while (index < chars.length) {
+							if (chars[++index] === "\"") {
+								index++;
+								quoteStart = 0;
+								break;
+							}
+							if (chars[index] === "\\") index++;
+							name += chars[index];
+						}
+						if (quoteStart) throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+					}
+					if (!name) throw new PathError(`Missing parameter name at index ${index}`, str);
+					writePath();
+					output.push({
+						type,
+						name
+					});
+					continue;
+				}
+				if (value === "{") {
+					writePath();
+					output.push({
+						type: "group",
+						tokens: consumeUntil("}")
+					});
+					continue;
+				}
+				if (value === "}" || value === "(" || value === ")" || value === "[" || value === "]" || value === "+" || value === "?" || value === "!") throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
+				path += value;
+			}
+			if (end) throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
+			writePath();
+			return output;
+		}
+		return new TokenData(consumeUntil(""), str);
+	}
+	/**
+	* Compile a string to a template function for the path.
+	*/
+	function compile(path, options = {}) {
+		const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+		const fn = tokensToFunction((typeof path === "object" ? path : parse(path, options)).tokens, delimiter, encode);
+		return function path(params = {}) {
+			const missing = [];
+			const path = fn(params, missing);
+			if (missing.length) throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
+			return path;
+		};
+	}
+	function tokensToFunction(tokens, delimiter, encode) {
+		const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
+		return (data, missing) => {
+			let result = "";
+			for (const encoder of encoders) result += encoder(data, missing);
+			return result;
+		};
+	}
+	/**
+	* Convert a single token into a path building function.
+	*/
+	function tokenToFunction(token, delimiter, encode) {
+		if (token.type === "text") return () => token.value;
+		if (token.type === "group") {
+			const fn = tokensToFunction(token.tokens, delimiter, encode);
+			return (data, missing) => {
+				const len = missing.length;
+				const value = fn(data, missing);
+				if (missing.length === len) return value;
+				missing.length = len;
+				return "";
+			};
+		}
+		const encodeValue = encode || NOOP_VALUE;
+		if (token.type === "wildcard" && encode !== false) return (data, missing) => {
+			const value = data[token.name];
+			if (value == null) {
+				missing.push(token.name);
+				return "";
+			}
+			if (!Array.isArray(value) || value.length === 0) throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
+			let result = "";
+			for (let i = 0; i < value.length; i++) {
+				if (typeof value[i] !== "string") throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
+				if (i > 0) result += delimiter;
+				result += encodeValue(value[i]);
+			}
+			return result;
+		};
+		return (data, missing) => {
+			const value = data[token.name];
+			if (value == null) {
+				missing.push(token.name);
+				return "";
+			}
+			if (typeof value !== "string") throw new TypeError(`Expected "${token.name}" to be a string`);
+			return encodeValue(value);
+		};
+	}
+	/**
+	* Transform a path into a match function.
+	*/
+	function match(path, options = {}) {
+		const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+		const { regexp, keys } = pathToRegexp(path, options);
+		const decoders = keys.map((key) => {
+			if (decode === false) return NOOP_VALUE;
+			if (key.type === "param") return decode;
+			return (value) => value.split(delimiter).map(decode);
+		});
+		return function match(input) {
+			const m = regexp.exec(input);
+			if (!m) return false;
+			const path = m[0];
+			const params = Object.create(null);
+			for (let i = 1; i < m.length; i++) {
+				if (m[i] === void 0) continue;
+				const key = keys[i - 1];
+				const decoder = decoders[i - 1];
+				params[key.name] = decoder(m[i]);
+			}
+			return {
+				path,
+				params
+			};
+		};
+	}
+	/**
+	* Transform a path into a regular expression and capture keys.
+	*/
+	function pathToRegexp(path, options = {}) {
+		const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
+		const keys = [];
+		let source = "";
+		let combinations = 0;
+		function process(path) {
+			if (Array.isArray(path)) {
+				for (const p of path) process(p);
+				return;
+			}
+			const data = typeof path === "object" ? path : parse(path, options);
+			flatten(data.tokens, 0, [], (tokens) => {
+				if (combinations >= 256) throw new PathError("Too many path combinations", data.originalPath);
+				if (combinations > 0) source += "|";
+				source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+				combinations++;
+			});
+		}
+		process(path);
+		let pattern = `^(?:${source})`;
+		if (trailing) pattern += "(?:" + escape(delimiter) + "$)?";
+		pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
+		return {
+			regexp: new RegExp(pattern, sensitive ? "" : "i"),
+			keys
+		};
+	}
+	/**
+	* Generate a flat list of sequence tokens from the given tokens.
+	*/
+	function flatten(tokens, index, result, callback) {
+		while (index < tokens.length) {
+			const token = tokens[index++];
+			if (token.type === "group") {
+				const len = result.length;
+				flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+				result.length = len;
+				continue;
+			}
+			result.push(token);
+		}
+		callback(result);
+	}
+	/**
+	* Transform a flat sequence of tokens into a regular expression.
+	*/
+	function toRegExpSource(tokens, delimiter, keys, originalPath) {
+		let result = "";
+		let backtrack = "";
+		let wildcardBacktrack = "";
+		let prevCaptureType = 0;
+		let hasSegmentCapture = 0;
+		let index = 0;
+		function hasInSegment(index, type) {
+			while (index < tokens.length) {
+				const token = tokens[index++];
+				if (token.type === type) return true;
+				if (token.type === "text") {
+					if (token.value.includes(delimiter)) break;
+				}
+			}
+			return false;
+		}
+		function peekText(index) {
+			let result = "";
+			while (index < tokens.length) {
+				const token = tokens[index++];
+				if (token.type !== "text") break;
+				result += token.value;
+			}
+			return result;
+		}
+		while (index < tokens.length) {
+			const token = tokens[index++];
+			if (token.type === "text") {
+				result += escape(token.value);
+				backtrack += token.value;
+				if (prevCaptureType === 2) wildcardBacktrack += token.value;
+				if (token.value.includes(delimiter)) hasSegmentCapture = 0;
+				continue;
+			}
+			if (token.type === "param" || token.type === "wildcard") {
+				if (prevCaptureType && !backtrack) throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
+				if (token.type === "param") {
+					result += hasSegmentCapture & 2 ? `(${negate(delimiter, backtrack)}+)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+)` : hasSegmentCapture & 1 ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})` : `(${negate(delimiter, "")}+)`;
+					hasSegmentCapture |= prevCaptureType = 1;
+				} else {
+					result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
+					wildcardBacktrack = "";
+					hasSegmentCapture |= prevCaptureType = 2;
+				}
+				keys.push(token);
+				backtrack = "";
+				continue;
+			}
+			throw new TypeError(`Unknown token type: ${token.type}`);
+		}
+		return result;
+	}
+	/**
+	* Block backtracking on previous text/delimiter.
+	*/
+	function negate(a, b) {
+		if (b.length > a.length) return negate(b, a);
+		if (a === b) b = "";
+		if (b.length > 1) return `(?:(?!${escape(a)}|${escape(b)})[^])`;
+		if (a.length > 1) return `(?:(?!${escape(a)})[^${escape(b)}])`;
+		return `[^${escape(a + b)}]`;
+	}
+})))();
+/**
+* Rewrite incoming path matching the `source` pattern into the `destination` pattern.
+*
+* See [`path-to-regexp`](https://github.com/pillarjs/path-to-regexp) for accepted pattern formats.
+*
+* @param source - the original pattern of incoming paths
+* @param destination - the target pattern to convert into
+*/
+function rewritePath(source, destination) {
+	const matcher = (0, import_dist.match)(source, { decode: false });
+	const compiler = (0, import_dist.compile)(destination, { encode: false });
+	return { rewrite(pathname) {
+		const result = matcher(pathname);
+		if (!result) return false;
+		return compiler(result.params);
+	} };
+}
+/**
+* Parse an `Accept` header into its media types and quality values.
+*
+* Media types the client didn't rank explicitly default to `q=1`.
+*/
+function parseAccept(header) {
+	const entries = [];
+	for (const section of header.split(",")) {
+		const [rawMediaType, ...params] = section.split(";");
+		const mediaType = rawMediaType.trim().toLowerCase();
+		if (mediaType.length === 0) continue;
+		let quality = 1;
+		for (const param of params) {
+			const separator = param.indexOf("=");
+			if (separator === -1 || param.slice(0, separator).trim().toLowerCase() !== "q") continue;
+			const parsed = Number.parseFloat(param.slice(separator + 1));
+			if (!Number.isNaN(parsed)) quality = parsed;
+		}
+		entries.push({
+			mediaType,
+			quality
+		});
+	}
+	return entries;
+}
+function isMarkdownPreferred(request, options) {
+	const { markdownMediaTypes = [
+		"text/plain",
+		"text/markdown",
+		"text/x-markdown"
+	] } = options ?? {};
+	const accept = request.headers.get("accept");
+	if (!accept) return false;
+	let markdown = 0;
+	let html = 0;
+	for (const { mediaType, quality } of parseAccept(accept)) {
+		if (quality <= 0) continue;
+		if (markdownMediaTypes.includes(mediaType)) markdown = Math.max(markdown, quality);
+		else if (mediaType === "text/html" || mediaType === "text/*" || mediaType === "*/*") html = Math.max(html, quality);
+	}
+	return markdown > 0 && markdown >= html;
+}
+//#endregion
+export { isMarkdownPreferred, rewritePath };

package/dist/search/flexsearch.d.ts

@@ -1,8 +1,8 @@
 import { t as Awaitable } from "../types-D89QoQR-.js";
 import { n as I18nConfig } from "../index-DydiXvgS.js";
 import "../index-BM36H-xw.js";
-import { m as SharedIndex, n as SearchAPI, t as QueryOptions } from "../server-DRvCKdc_.js";
-import { b as LoaderOutput, v as LoaderConfig } from "../index-DQWu2opy2.js";
+import { m as SharedIndex, n as SearchAPI, t as QueryOptions } from "../server-BoDPRfLi.js";
+import { b as LoaderOutput, v as LoaderConfig } from "../index-DQWu2opy.js";
 import { DocumentData, DocumentOptions } from "flexsearch";
 //#region src/search/server/build-doc.d.ts
 interface SharedDocument {

package/dist/search/mixedbread.d.ts

@@ -1,5 +1,5 @@
 import { r as SortedResult } from "../index-BM36H-xw.js";
-import { n as SearchAPI } from "../server-DRvCKdc_.js";
+import { n as SearchAPI } from "../server-BoDPRfLi.js";
 import Mixedbread from "@mixedbread/sdk";
 import { StoreSearchResponse } from "@mixedbread/sdk/resources/stores";
 //#region src/search/mixedbread.d.ts

package/dist/search/server.d.ts

@@ -1,2 +1,2 @@
-import { a as AdvancedOptions, c as SimpleOptions, d as createSearchAPI, f as initAdvancedSearch, i as AdvancedIndex, l as createFromSource, n as SearchAPI, o as ExportedData, p as initSimpleSearch, r as SearchServer, s as Index, t as QueryOptions, u as createI18nSearchAPI } from "../server-DRvCKdc_.js";
+import { a as AdvancedOptions, c as SimpleOptions, d as createSearchAPI, f as initAdvancedSearch, i as AdvancedIndex, l as createFromSource, n as SearchAPI, o as ExportedData, p as initSimpleSearch, r as SearchServer, s as Index, t as QueryOptions, u as createI18nSearchAPI } from "../server-BoDPRfLi.js";
 export { AdvancedIndex, AdvancedOptions, ExportedData, Index, QueryOptions, SearchAPI, SearchServer, SimpleOptions, createFromSource, createI18nSearchAPI, createSearchAPI, initAdvancedSearch, initSimpleSearch };

package/dist/{server-DRvCKdc_.d.ts → server-BoDPRfLi.d.ts}

@@ -2,7 +2,7 @@ import { t as Awaitable } from "./types-D89QoQR-.js";
 import { i as StructuredData } from "./remark-structure-CnHwvNZr.js";
 import { n as I18nConfig } from "./index-DydiXvgS.js";
 import { r as SortedResult } from "./index-BM36H-xw.js";
-import { b as LoaderOutput, v as LoaderConfig } from "./index-DQWu2opy2.js";
+import { b as LoaderOutput, v as LoaderConfig } from "./index-DQWu2opy.js";
 import { Language, RawData, SearchParams, TypedDocument, ZBSearch, create } from "zbsearch";
 //#region src/search/zbsearch/create-db.d.ts
 type SimpleDocument = TypedDocument<ZBSearch<typeof simpleSchema>>;

package/dist/source/dynamic.d.ts

@@ -1,2 +1,2 @@
-import { h as dynamicLoader, m as DynamicLoaderConfig, p as DynamicLoader } from "../index-DQWu2opy2.js";
+import { h as dynamicLoader, m as DynamicLoaderConfig, p as DynamicLoader } from "../index-DQWu2opy.js";
 export { DynamicLoader, DynamicLoaderConfig, dynamicLoader };

package/dist/source/index.d.ts

@@ -1,2 +1,2 @@
-import { B as ContentStoragePageFile, C as Meta, D as loader, E as createGetUrl, F as PageTreeBuilderContext, I as PageTreeOptions, L as PageTreeTransformer, O as types_d_exports, P as PageTreeBuilder, R as ContentStorage, S as LoaderPluginOption, T as ResolvedLoaderConfig, V as FileSystem, _ as InferPageType, a as MetaData, b as LoaderOutput, c as SourceUnion, d as multiple, f as update, g as InferMetaType, h as dynamicLoader, i as DynamicSource, j as getSlugs, l as StaticSource, m as DynamicLoaderConfig, n as llms, o as PageData, p as DynamicLoader, r as path_d_exports, s as Source, t as LLMsConfig, u as VirtualFile, v as LoaderConfig, w as Page, x as LoaderPlugin, y as LoaderOptions, z as ContentStorageMetaFile } from "../index-DQWu2opy2.js";
+import { B as ContentStoragePageFile, C as Meta, D as loader, E as createGetUrl, F as PageTreeBuilderContext, I as PageTreeOptions, L as PageTreeTransformer, O as types_d_exports, P as PageTreeBuilder, R as ContentStorage, S as LoaderPluginOption, T as ResolvedLoaderConfig, V as FileSystem, _ as InferPageType, a as MetaData, b as LoaderOutput, c as SourceUnion, d as multiple, f as update, g as InferMetaType, h as dynamicLoader, i as DynamicSource, j as getSlugs, l as StaticSource, m as DynamicLoaderConfig, n as llms, o as PageData, p as DynamicLoader, r as path_d_exports, s as Source, t as LLMsConfig, u as VirtualFile, v as LoaderConfig, w as Page, x as LoaderPlugin, y as LoaderOptions, z as ContentStorageMetaFile } from "../index-DQWu2opy.js";
 export { type ContentStorage, type ContentStorageMetaFile, type ContentStoragePageFile, type DynamicLoader, type DynamicLoaderConfig, type DynamicSource, FileSystem, InferMetaType, InferPageType, LLMsConfig, LoaderConfig, LoaderOptions, LoaderOutput, LoaderPlugin, LoaderPluginOption, Meta, type MetaData, Page, type PageData, type PageTreeBuilder, type PageTreeBuilderContext, type PageTreeOptions, type PageTreeTransformer, path_d_exports as PathUtils, ResolvedLoaderConfig, type Source, type SourceUnion, type StaticSource, type VirtualFile, type types_d_exports as _Internal, createGetUrl, dynamicLoader, getSlugs, llms, loader, multiple, update };

package/dist/source/llms.d.ts

@@ -1,2 +1,2 @@
-import { n as llms, t as LLMsConfig } from "../index-DQWu2opy2.js";
+import { n as llms, t as LLMsConfig } from "../index-DQWu2opy.js";
 export { LLMsConfig, llms };

package/dist/source/plugins/lucide-icons.d.ts

@@ -1,4 +1,4 @@
-import { x as LoaderPlugin } from "../../index-DQWu2opy2.js";
+import { x as LoaderPlugin } from "../../index-DQWu2opy.js";
 import { icons } from "lucide-react";
 //#region src/source/plugins/lucide-icons.d.ts
 /**

package/dist/source/plugins/slugs.d.ts

@@ -1,2 +1,2 @@
-import { A as SlugsPluginOptions, M as slugsFromData, N as slugsPlugin, j as getSlugs, k as SlugFn } from "../../index-DQWu2opy2.js";
+import { A as SlugsPluginOptions, M as slugsFromData, N as slugsPlugin, j as getSlugs, k as SlugFn } from "../../index-DQWu2opy.js";
 export { SlugFn, SlugsPluginOptions, getSlugs, slugsFromData, slugsPlugin };

package/dist/source/plugins/status-badges.d.ts

@@ -1,5 +1,5 @@
 import { a as Separator$1, n as Item$1, t as Folder$1 } from "../../definitions-D8-KI7Uy.js";
-import { x as LoaderPlugin } from "../../index-DQWu2opy2.js";
+import { x as LoaderPlugin } from "../../index-DQWu2opy.js";
 import { ReactNode } from "react";
 //#region src/source/plugins/status-badges.d.ts
 interface Item extends Item$1 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-core",
-  "version": "16.15.1",
+  "version": "16.15.2",
   "description": "The React.js library for building a documentation website",
   "keywords": [
     "Docs",
@@ -130,19 +130,17 @@
     "@orama/core": "^1.2.19",
     "@oramacloud/client": "^2.1.4",
     "@shikijs/transformers": "^4.4.3",
-    "@tanstack/react-router": "1.170.27",
+    "@tanstack/react-router": "1.170.32",
     "@types/estree-jsx": "^1.0.5",
     "@types/hast": "^3.0.5",
     "@types/mdast": "^4.0.4",
-    "@types/negotiator": "^0.6.5",
-    "@types/node": "26.2.0",
+    "@types/node": "26.3.0",
     "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.4",
-    "algoliasearch": "5.56.0",
+    "@types/react-dom": "^19.2.5",
+    "algoliasearch": "5.57.0",
     "flexsearch": "^0.8.212",
-    "lucide-react": "^1.31.0",
-    "negotiator": "^1.0.0",
-    "next": "16.3.0",
+    "lucide-react": "^1.34.0",
+    "next": "16.3.2",
     "path-to-regexp": "^8.4.2",
     "react-router": "^8.3.0",
     "remark-directive": "^4.0.0",
@@ -150,7 +148,7 @@
     "remove-markdown": "^0.6.4",
     "tsdown": "0.22.14",
     "typescript": "^6.0.3",
-    "waku": "1.0.0-beta.9",
+    "waku": "1.0.0-rc.0",
     "zod": "4.4.3",
     "tsconfig": "0.0.0"
   },
@@ -234,7 +232,6 @@
     "@formatjs/fast-memoize": "3.1.7",
     "@formatjs/intl-localematcher": "0.8.13",
     "@shikijs/transformers": "4.4.3",
-    "negotiator": "1.0.0",
     "path-to-regexp": "8.4.2",
     "remove-markdown": "0.6.4"
   },