@vezham/docs-core 1.0.1

package/dist/negotiation/index.js

@@ -0,0 +1,378 @@
+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/page-tree/index.d.ts

@@ -0,0 +1,3 @@
+import { a as Separator, i as Root, n as Item, r as Node, t as Folder } from "../definitions-CFOhwE1k.js";
+import { a as findSiblings, c as getPageTreeRoots, i as findProjection, l as visit, n as findParent, o as flattenTree, r as findPath, s as getPageTreePeers, t as findNeighbour } from "../index-E8Qh_yQs.js";
+export { Folder, Item, Node, Root, Separator, findNeighbour, findParent, findPath, findProjection, findSiblings, flattenTree, getPageTreePeers, getPageTreeRoots, visit };

package/dist/page-tree/index.js

@@ -0,0 +1,2 @@
+import { a as findSiblings, c as getPageTreeRoots, i as findProjection, l as visit, n as findParent, o as flattenTree, r as findPath, s as getPageTreePeers, t as findNeighbour } from "../utils-DEVq3cEC.js";
+export { findNeighbour, findParent, findPath, findProjection, findSiblings, flattenTree, getPageTreePeers, getPageTreeRoots, visit };

package/dist/path-1H5VzYiT.js

@@ -0,0 +1,75 @@
+import { n as __exportAll } from "./rolldown-runtime-DC62tzP2.js";
+//#region src/source/path.ts
+var path_exports = /* @__PURE__ */ __exportAll({
+	basename: () => basename,
+	dirname: () => dirname,
+	extname: () => extname,
+	joinPath: () => joinPath,
+	normalize: () => normalize,
+	slash: () => slash,
+	splitPath: () => splitPath
+});
+function basename(path, ext) {
+	const idx = path.lastIndexOf("/");
+	return path.substring(idx === -1 ? 0 : idx + 1, ext ? path.length - ext.length : path.length);
+}
+function extname(path) {
+	for (let i = path.length - 1; i >= 0; i--) {
+		const c = path[i];
+		if (c === ".") return path.substring(i);
+		if (c === "/") return "";
+	}
+	return "";
+}
+function dirname(path) {
+	const idx = path.lastIndexOf("/");
+	if (idx === -1) return "";
+	return path.substring(0, idx);
+}
+/**
+* Split path into segments, trailing/leading slashes are removed
+*/
+function splitPath(path) {
+	return path.split("/").filter((p) => p.length > 0);
+}
+/**
+* Resolve paths, slashes within the path will be ignored
+* @param paths - Paths to join
+* @example
+* ```
+* ['a','b'] // 'a/b'
+* ['/a'] // 'a'
+* ['a', '/b'] // 'a/b'
+* ['a', '../b/c'] // 'b/c'
+* ```
+*/
+function joinPath(...paths) {
+	const out = [];
+	for (const path of paths) for (const seg of path.split("/")) switch (seg) {
+		case "..":
+			out.pop();
+			break;
+		case "":
+		case ".": break;
+		default: out.push(seg);
+	}
+	return out.join("/");
+}
+function slash(path) {
+	if (path.startsWith("\\\\?\\")) return path;
+	return path.replaceAll("\\", "/");
+}
+/**
+* Convert (relative) file path to virtual file path.
+*
+* @param path - Relative path
+* @returns Normalized path, with no trailing/leading slashes
+* @throws Throws error if path starts with `./` or `../`
+*/
+function normalize(path) {
+	const segments = path.split(/\/|\\/).filter((v) => v.length > 0);
+	if (segments[0] === "." || segments[0] === "..") throw new Error("It must not start with './' or '../'");
+	return segments.join("/");
+}
+//#endregion
+export { normalize as a, joinPath as i, dirname as n, path_exports as o, extname as r, basename as t };

package/dist/rehype-code-D-RFJb9W.d.ts

@@ -0,0 +1,14 @@
+import { t as RehypeCodeOptionsCommon } from "./rehype-code.core-BjH1uHWj.js";
+//#region src/mdx-plugins/rehype-code.d.ts
+type RehypeCodeOptions = RehypeCodeOptionsCommon & {
+  /**
+   * The regex engine to use.
+   *
+   * @defaultValue 'js'
+   */
+  engine?: 'js' | 'oniguruma';
+};
+declare const rehypeCodeDefaultOptions: RehypeCodeOptions;
+declare const rehypeCode: (this: import("unified").Processor, _options?: Partial<RehypeCodeOptions> | undefined) => import("unified").Transformer<import("hast").Root, import("hast").Root>;
+//#endregion
+export { rehypeCode as n, rehypeCodeDefaultOptions as r, RehypeCodeOptions as t };