hdoc-tools 0.46.0 → 0.47.0

package/hdoc-create.js

@@ -1,5 +1,5 @@
 (() => {
-	const fs = require("fs-extra");
+	const fs = require("node:fs");
 	const path = require("node:path");
 	const hdoc = require(path.join(__dirname, "hdoc-module.js"));
 

package/hdoc-db.js

@@ -1,5 +1,4 @@
 (() => {
-	const html2text = require("html-to-text");
 	const path = require("node:path");
 	const hdoc = require(path.join(__dirname, "hdoc-module.js"));
 
@@ -69,31 +68,10 @@
 		response.fm_props = fm_headers.fm_properties;
 
 		// Convert HTML into plain text
-		response.text = html2text.convert(html_txt, {
-			ignoreHref: true,
-			ignoreImage: true,
-			uppercaseHeadings: false,
-			wordwrap: null,
-			selectors: [
-				{ selector: 'h2', format: 'blockString' },
-				{ selector: 'h3', format: 'blockString' },
-				{ selector: 'h4', format: 'blockString' }
-			  ]
-		});
+		response.text = hdoc.html_to_text(html_txt);
 
 		// Convert HTML into preview text
-		let preview = html2text.convert(html_txt, {
-			baseElement: "p",
-			ignoreHref: true,
-			ignoreImage: true,
-			uppercaseHeadings: false,
-			wordwrap: null,
-			selectors: [
-				{ selector: 'h2', format: 'blockString' },
-				{ selector: 'h3', format: 'blockString' },
-				{ selector: 'h4', format: 'blockString' }
-			  ]
-		});
+		let preview = hdoc.html_to_text(html_txt, { baseElement: "p" });
 		preview = hdoc
 			.truncate_string(preview, 200, true)
 			.replace(/(?:\r\n|\r|\n)/g, " ");

package/hdoc-init.js

@@ -1,11 +1,9 @@
 (() => {
 	// Required modules
-	const prompt = require("prompt");
-	const fs = require("fs-extra");
+	const readline = require("node:readline");
+	const fs = require("node:fs");
 	const path = require("node:path");
 
-	// Configure prompt module preferences
-	prompt.message = false;
 	const promptProps = [
 		{
 			name: "id",
@@ -40,6 +38,29 @@
 		},
 	];
 
+	// Asks a single question, re-prompting if the field is required and empty or if
+	// the value fails the validator regex. Shows the default value in the prompt label.
+	const askQuestion = (rl, field) => new Promise((resolve) => {
+		const label = field.default ? `${field.description} (${field.default}): ` : `${field.description}: `;
+		const ask = () => {
+			rl.question(label, (answer) => {
+				const value = answer.trim() || field.default || "";
+				if (field.required && !value) {
+					console.error("This field is required.");
+					ask();
+					return;
+				}
+				if (value && field.validator && !field.validator.test(value)) {
+					console.error(field.warning);
+					ask();
+					return;
+				}
+				resolve(value);
+			});
+		};
+		ask();
+	});
+
 	const createBook = (server_path, source_path, docProps) => {
 		console.log("\r\nCreating book with the following properties:\r\n");
 		console.log("           Doc ID:", docProps.id);
@@ -55,7 +76,7 @@
 		if (fs.existsSync(templatePath)) {
 			// If template path exists, do sync copy into book path
 			try {
-				fs.copySync(templatePath, source_path);
+				fs.cpSync(templatePath, source_path, { recursive: true });
 			} catch (e) {
 				console.error("Error copying template:\r\n", e);
 				process.exit(1);
@@ -155,7 +176,7 @@
 		}
 	};
 
-	exports.run = (server_path, source_path, md) => {
+	exports.run = async (server_path, source_path, md) => {
 		// GERRY: The init function should create a new starting point HDocBook folder structure
 		// ready to run the preview server and start editing.
 		//
@@ -168,14 +189,13 @@
 		const curr_dirs = source_path.split(path.sep);
 		const doc_id = curr_dirs[curr_dirs.length - 1];
 
-		prompt.start();
+		const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 		promptProps[0].default = doc_id;
-		prompt.get(promptProps, (err, result) => {
-			if (err) {
-				console.error(err);
-				return err;
-			}
-			createBook(server_path, source_path, result);
-		});
+		const result = {};
+		for (const field of promptProps) {
+			result[field.name] = await askQuestion(rl, field);
+		}
+		rl.close();
+		createBook(server_path, source_path, result);
 	};
 })();

package/hdoc-module.js

@@ -1,43 +1,53 @@
 (() => {
-	const axios = require("axios");
-	const axiosRetry = require("axios-retry").default;
 	const cheerio = require("cheerio");
+	const crypto = require("node:crypto");
 	const fs = require("node:fs");
-	const https = require("node:https");
-	const htmlentities = require("html-entities");
-	const html2text = require("html-to-text");
+	const os = require("node:os");
 	const { JSDOM } = require("jsdom");
 	const path = require("node:path");
-	const wordsCount = require("words-count").default;
 
 	const includesCache = {};
-	const agent = new https.Agent({
-		rejectUnauthorized: false,
-	});
 
 	let retried = false;
 
-	axiosRetry(axios, {
-		retries: 5,
-		shouldResetTimeout: true,
-		retryCondition(error) {
-			if (error.response && error.response.status) {
-				if (error.response.status >= 400 && error.response.status !== 401 && error.response.status !== 403) {
-					return true;
-				} else {
-					return false;
-				}
-			} else {
-				return false;
+	// Wraps the built-in fetch() with automatic retry for transient errors.
+	// Retries up to maxRetries times when the server returns an HTTP error status
+	// >= 400, except for 401 (Unauthorized) and 403 (Forbidden) which are auth
+	// failures that won't be resolved by retrying. Network errors (where fetch
+	// itself throws) are also retried. Sets the module-level `retried` flag so
+	// callers can detect and log a success-after-retry message.
+	//
+	// Pass `timeoutMs` inside options to apply a per-attempt timeout. A fresh
+	// AbortSignal is created for every attempt so that a timed-out first attempt
+	// does not leave an already-aborted signal in place for the retries.
+	const fetchWithRetry = async (url, options = {}, maxRetries = 5) => {
+		const { timeoutMs, ...fetchOptions } = options;
+		let retryCount = 0;
+		while (true) {
+			// Create a fresh signal for each attempt; reusing an already-aborted
+			// signal would cause every subsequent retry to abort immediately.
+			const attemptOptions = timeoutMs
+				? { ...fetchOptions, signal: AbortSignal.timeout(timeoutMs) }
+				: fetchOptions;
+			let response;
+			try {
+				response = await fetch(url, attemptOptions);
+			} catch (err) {
+				// Network-level error (DNS failure, connection refused, timeout, etc.)
+				retryCount++;
+				if (retryCount > maxRetries) throw err;
+				retried = true;
+				continue;
+			}
+			// Auth failures and successes are not retried
+			if (response.ok || response.status === 401 || response.status === 403) {
+				return response;
 			}
-		},
-		onRetry: (retryCount, error, requestConfig) => {
+			retryCount++;
+			if (retryCount > maxRetries) return response;
 			retried = true;
-			console.info(
-				`\n[WARNING] API call failed - ${error.message}\nEndpoint: ${requestConfig.url}\nRetrying: ${retryCount}`,
-			);
-		},
-	});
+		}
+	};
 
 	exports.content_type_for_ext = (ext) => {
 		switch (ext) {
@@ -169,13 +179,13 @@
 				}
 
 				try {
-					const file_response = await axios.get(link);
+					const file_response = await fetchWithRetry(link);
 					if (retried) {
 						retried = false;
 						console.log("API call retry success!");
 					}
 					if (file_response.status === 200) {
-						file_content = file_response.data;
+						file_content = await file_response.text();
 					} else {
 						throw `Unexpected Status ${file_response.status}`;
 					}
@@ -362,7 +372,11 @@
 									prop_val = prop_val.substring(1, prop_val.length - 1);
 								}
 								if (property_details[0].trim().toLowerCase() === "title") {
-									prop_val = htmlentities.decode(prop_val);
+									// Decode HTML entities in the title value: handles named entities
+									// (& < > " ' '), decimal numeric refs ({),
+									// and hex numeric refs ({).
+									prop_val = prop_val.replace(/&|<|>|"|'|'|&#(\d+);|&#x([0-9a-fA-F]+);/g,
+									(m, dec, hex) => dec ? String.fromCharCode(+dec) : hex ? String.fromCharCode(parseInt(hex, 16)) : ({ '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&#39;': "'", '&apos;': "'" })[m]);
 								}
 								response.fm_properties[
 									property_details[0].trim().toLowerCase()
@@ -392,12 +406,21 @@
 		}…`;
 	};
 
+	exports.html_to_text = (html, { baseElement } = {}) => {
+		const dom = new JSDOM(html);
+		const document = dom.window.document;
+		if (baseElement) {
+			return Array.from(document.querySelectorAll(baseElement))
+				.map((el) => el.textContent)
+				.join("\n");
+		}
+		return document.body ? document.body.textContent : "";
+	};
+
 	exports.get_html_read_time = (html) => {
 		// Get word count
-		const text = html2text.convert(html, {
-			wordwrap: null,
-		});
-		const word_count = wordsCount(text);
+		const text = exports.html_to_text(html);
+		const word_count = text.trim().split(/\s+/).filter(Boolean).length;
 		if (word_count === 0) return 0;
 
 		// Calculate the read time - divide the word count by 200
@@ -458,32 +481,34 @@
 		}
 
 		let github_response;
+		let github_data;
 		try {
-			github_response = await axios.get(github_url, request_options);
+			github_response = await fetchWithRetry(github_url, {
+				headers: request_options.headers,
+				timeoutMs: 5000,
+			});
 			if (retried) {
 				retried = false;
 				console.log("API call retry success!");
 			}
+			github_data = await github_response.json();
 		} catch (err) {
-			if (err.response) {
-				if (err.response.status !== 403 && err.response.status !== 401) {
-					response.error = err;
-					return response;
-				}
-				github_response = err.response;
-			} else {
-				response.error = `Unexpected response from GitHub for [${github_url}:\n${JSON.stringify(
-					err,
-				)}]`;
-			}
+			// Network-level failure (fetchWithRetry re-throws after exhausting retries)
+			response.error = `Unexpected response from GitHub for [${github_url}:\n${JSON.stringify(err)}]`;
+			return response;
+		}
+		// fetch does not throw on HTTP errors — return early for unexpected status codes
+		if (github_response.status !== 200 && github_response.status !== 401 && github_response.status !== 403) {
+			response.error = new Error(`HTTP ${github_response.status}`);
+			return response;
 		}
 		if (github_response.status === 200) {
 			response.success = true;
-			response.data = github_response.data;
-			response.private = github_response.data.private;
+			response.data = github_data;
+			response.private = github_data.private;
 		} else {
 			// Is it a 404 or 403?
-			response.error = `${github_response.status} : ${github_response.data.message}`;
+			response.error = `${github_response.status} : ${github_data.message}`;
 		}
 		return response;
 	};
@@ -515,28 +540,30 @@
 			request_options.headers.authorization = `Bearer ${github_api_token}`;
 		}
 		let github_response;
+		let github_data;
 		try {
-			github_response = await axios.get(github_url, request_options);
+			github_response = await fetchWithRetry(github_url, {
+				headers: request_options.headers,
+				timeoutMs: 5000,
+			});
 			if (retried) {
 				retried = false;
 				console.log("API call retry success!");
 			}
+			github_data = await github_response.json();
 		} catch (err) {
-			if (err.response) {
-				if (err.response.status !== 403 && err.response.status !== 401) {
-					response.error = err;
-					return response;
-				}
-				github_response = err.response;
-			} else {
-				response.error = `Unexpected response from GitHub for [${github_url}:\n${JSON.stringify(
-					err,
-				)}]`;
-			}
+			// Network-level failure (fetchWithRetry re-throws after exhausting retries)
+			response.error = `Unexpected response from GitHub for [${github_url}:\n${JSON.stringify(err)}]`;
+			return response;
+		}
+		// fetch does not throw on HTTP errors — return early for unexpected status codes
+		if (github_response.status !== 200 && github_response.status !== 401 && github_response.status !== 403) {
+			response.error = new Error(`HTTP ${github_response.status}`);
+			return response;
 		}
 		if (github_response.status === 200) {
 			response.success = true;
-			const commits = github_response.data;
+			const commits = github_data;
 			for (const commit of commits) {
 				if (
 					commit.committer?.type &&
@@ -589,26 +616,28 @@
 			// Private repo, fine-grained permissions don't yet support getting commits without content, get list from meta permissions
 			const contrib_url = get_github_contributors_path(repo).api_path;
 			try {
-				github_response = await axios.get(contrib_url, request_options);
+				github_response = await fetchWithRetry(contrib_url, {
+					headers: request_options.headers,
+					timeoutMs: 5000,
+				});
 				if (retried) {
 					retried = false;
 					console.log("API call retry success!");
 				}
+				github_data = await github_response.json();
 			} catch (err) {
-				if (err.response?.status) {
-					if (err.response.status !== 200) {
-						response.error = err;
-						return response;
-					}
-				} else {
-					response.error = `Unexpected response from GitHub for [${contrib_url}:\n${JSON.stringify(
-						err,
-					)}]`;
-				}
+				// Network-level failure (fetchWithRetry re-throws after exhausting retries)
+				response.error = `Unexpected response from GitHub for [${contrib_url}:\n${JSON.stringify(err)}]`;
+				return response;
+			}
+			// fetch does not throw on HTTP errors — return early if fallback request failed
+			if (github_response.status !== 200) {
+				response.error = new Error(`HTTP ${github_response.status}`);
+				return response;
 			}
 			if (github_response.status === 200) {
 				response.success = true;
-				const commits = github_response.data;
+				const commits = github_data;
 				for (const commit of commits) {
 					if (
 						commit.type &&
@@ -761,12 +790,11 @@
 		const prod_families_url = "https://docs.hornbill.com/_books/products.json";
 		for (let i = 1; i < 4; i++) {
 			try {
-				const prods = await axios.get(prod_families_url, {
-					httpsAgent: agent,
-					timeout: 5000,
+				const prods = await fetch(prod_families_url, {
+					signal: AbortSignal.timeout(5000),
 				});
 				if (prods.status === 200) {
-					response.prod_families = prods.data;
+					response.prod_families = await prods.json();
 					response.prods_supported = [];
 					for (let i = 0; i < response.prod_families.products.length; i++) {
 						response.prods_supported.push(
@@ -788,6 +816,191 @@
 		return response;
 	};
 
+	// Recursively walks a directory tree and invokes fileCallback(element) for each file.
+	// Mirrors the dree.scan API so existing options objects and callbacks work unchanged.
+	// Supported options:
+	//   extensions            - array of extensions to include (e.g. ["md","html"]); omit for all files
+	//   hash                  - compute MD5 hash of each file's content and set element.hash
+	//   normalize             - convert backslashes to forward slashes in all paths
+	//   sorted                - sort directory entries alphabetically before recursing
+	//   sizeInBytes / size    - include file size as element.sizeInBytes
+	//   stat                  - include the fs.Stats object as element.stat
+	//   depth                 - maximum recursion depth (default: unlimited)
+	//   excludeEmptyDirectories - skip directories that contain no entries
+	//   symbolicLinks         - set false to skip symbolic links (default: include them)
+	// Each element passed to the callback has: name, path (absolute), relativePath, and any
+	// optional fields enabled above.
+	exports.scan_dir = (dirPath, opts = {}, fileCallback) => {
+		const extensions = opts.extensions ? new Set(opts.extensions.map((e) => e.toLowerCase())) : null;
+		const maxDepth = opts.depth !== undefined ? opts.depth : Infinity;
+
+		const walk = (currentPath, depth) => {
+			if (depth > maxDepth) return;
+			let entries;
+			try {
+				entries = fs.readdirSync(currentPath, { withFileTypes: true });
+			} catch (_) { return; }
+
+			if (opts.sorted) entries = entries.slice().sort((a, b) => a.name.localeCompare(b.name));
+
+			for (const entry of entries) {
+				if (opts.symbolicLinks === false && entry.isSymbolicLink()) continue;
+				const fullPath = path.join(currentPath, entry.name);
+
+				if (entry.isDirectory()) {
+					if (opts.excludeEmptyDirectories) {
+						try { if (fs.readdirSync(fullPath).length === 0) continue; } catch (_) { continue; }
+					}
+					walk(fullPath, depth + 1);
+				} else if (entry.isFile()) {
+					const ext = path.extname(entry.name).slice(1).toLowerCase();
+					if (extensions && !extensions.has(ext)) continue;
+
+					const absPath = opts.normalize ? fullPath.replaceAll("\\", "/") : fullPath;
+					const relPath = opts.normalize
+						? path.relative(dirPath, fullPath).replaceAll("\\", "/")
+						: path.relative(dirPath, fullPath);
+
+					const element = { name: entry.name, path: absPath, relativePath: relPath, extension: ext };
+
+					if (opts.sizeInBytes || opts.size || opts.stat) {
+						const stat = fs.statSync(fullPath);
+						if (opts.sizeInBytes || opts.size) element.sizeInBytes = stat.size;
+						if (opts.stat) element.stat = stat;
+					}
+
+					if (opts.hash) {
+						element.hash = crypto.createHash("md5").update(fs.readFileSync(fullPath)).digest("hex");
+					}
+
+					fileCallback(element);
+				}
+			}
+		};
+
+		walk(dirPath, 1);
+	};
+
+	// Resolves the true on-disk casing of a file path by walking each path segment
+	// and doing a case-insensitive match against the actual directory listing.
+	// This is important on case-sensitive filesystems (Linux) to catch casing mismatches
+	// that would silently pass on macOS/Windows but break in CI or production.
+	// On Windows, the drive letter is normalised to uppercase and backslash delimiters are used.
+	exports.true_case_path_sync = (filePath) => {
+		const isWin = process.platform === "win32";
+		const delim = isWin ? "\\" : "/";
+		filePath = path.normalize(filePath);
+		const segments = filePath.split(delim).filter((s) => s !== "");
+		let base = path.isAbsolute(filePath) ? (isWin ? segments.shift().toUpperCase() : "") : process.cwd();
+		return segments.reduce((realPath, seg) => {
+			const entries = fs.readdirSync(realPath + delim);
+			// Escape any regex special chars in the segment name before building the pattern
+			const re = new RegExp(`^${seg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "i");
+			const match = entries.find((e) => re.test(e));
+			if (!match) throw new Error(`true_case_path_sync: no match for "${seg}" in "${realPath}"`);
+			return realPath + delim + match;
+		}, base);
+	};
+
+	// Creates an empty temporary file with a random name and optional file extension suffix
+	// (e.g. { postfix: ".mmd" }). Returns an object with:
+	//   name           - the absolute path to the temp file
+	//   removeCallback - call this to delete the file when done; errors are silently ignored
+	//                    so it is safe to call even if the file was already cleaned up.
+	exports.tmp_file_sync = (opts = {}) => {
+		const name = path.join(os.tmpdir(), `hdoc-${crypto.randomBytes(8).toString("hex")}${opts.postfix || ""}`);
+		fs.closeSync(fs.openSync(name, "w"));
+		return { name, removeCallback: () => { try { fs.unlinkSync(name); } catch (_) {} } };
+	};
+
+	// Parses a YAML string into a plain JS object. Designed for markdown frontmatter,
+	// which is always simple: scalar key/value pairs, block arrays (- item), and inline
+	// arrays ([a, b, c]). Does not support anchors, multi-line strings, or nested objects.
+	// parseVal handles type coercion: booleans, null, integers, floats, quoted strings,
+	// inline arrays, and plain strings (returned as-is).
+	exports.parse_yaml = (str) => {
+		const parseVal = (v) => {
+			if (v === "true") return true;
+			if (v === "false") return false;
+			if (v === "null" || v === "~") return null;
+			if (/^-?\d+$/.test(v)) return parseInt(v, 10);
+			if (/^-?\d*\.\d+$/.test(v)) return parseFloat(v);
+			if (/^['"].*['"]$/.test(v)) return v.slice(1, -1); // strip surrounding quotes
+			if (v.startsWith("[") && v.endsWith("]")) return v.slice(1, -1).split(",").map(i => parseVal(i.trim()));
+			return v;
+		};
+		const result = {};
+		let currentKey = null;
+		for (const line of str.split("\n")) {
+			if (!line.trim() || /^\s*#/.test(line)) continue;
+			// Block array item (indented dash): append to the current key's array
+			const arrMatch = line.match(/^\s+-\s+(.+)$/);
+			if (arrMatch && currentKey) {
+				if (!Array.isArray(result[currentKey])) result[currentKey] = [];
+				result[currentKey].push(parseVal(arrMatch[1].trim()));
+				continue;
+			}
+			// key: value pair — value may be empty (e.g. start of a block array)
+			const kvMatch = line.match(/^([^:]+):\s*(.*)$/);
+			if (kvMatch) {
+				currentKey = kvMatch[1].trim();
+				result[currentKey] = kvMatch[2].trim() ? parseVal(kvMatch[2].trim()) : null;
+			}
+		}
+		return result;
+	};
+
+	// Pretty-prints an XML string with configurable indentation and line endings.
+	// Tokenises the input using a regex that preserves CDATA sections, comments, and
+	// processing instructions as atomic units so their content is never re-indented.
+	// Options:
+	//   indentation   - string to use per indent level (default: two spaces)
+	//   lineSeparator - line ending to use (default: "\n")
+	//   collapseContent - when true (default), elements that contain only a single text
+	//                     node are kept on one line: <tag>text</tag> rather than split
+	//                     across three lines. Uses one-token lookahead to detect this.
+	exports.xml_format = (xml, opts = {}) => {
+		const ind = opts.indentation || "  ";
+		const sep = opts.lineSeparator || "\n";
+		const collapse = opts.collapseContent !== false;
+		// Match CDATA, comments, PIs, tags, and text nodes as individual tokens
+		const tokens = xml.trim().match(/(<!\[CDATA\[[\s\S]*?\]\]>|<!--[\s\S]*?-->|<[^>]+>|[^<]+)/g) || [];
+		let depth = 0;
+		let out = "";
+		for (let i = 0; i < tokens.length; i++) {
+			const t = tokens[i].trim();
+			if (!t) continue;
+			const isClose = t.startsWith("</");
+			const isSelf = t.startsWith("<") && t.endsWith("/>") && !t.startsWith("<?");
+			const isSpecial = t.startsWith("<?") || t.startsWith("<!--") || t.startsWith("<![");
+			const isOpen = t.startsWith("<") && !isClose && !isSelf && !isSpecial;
+			if (isClose) {
+				depth = Math.max(0, depth - 1);
+				out += ind.repeat(depth) + t + sep;
+			} else if (isSelf || isSpecial) {
+				out += ind.repeat(depth) + t + sep;
+			} else if (isOpen) {
+				// Collapse: if the very next token is text and the one after is the closing tag,
+				// emit all three on one line and skip those two tokens.
+				if (collapse && i + 2 < tokens.length) {
+					const nextTxt = tokens[i + 1] ? tokens[i + 1].trim() : "";
+					const nextClose = tokens[i + 2] ? tokens[i + 2].trim() : "";
+					if (nextTxt && !nextTxt.startsWith("<") && nextClose.startsWith("</")) {
+						out += ind.repeat(depth) + t + nextTxt + nextClose + sep;
+						i += 2;
+						continue;
+					}
+				}
+				out += ind.repeat(depth) + t + sep;
+				depth++;
+			} else {
+				// Plain text node
+				out += ind.repeat(depth) + t + sep;
+			}
+		}
+		return out.trimEnd();
+	};
+
 	exports.find_string_in_string = (fileContent, searchString) => {
 		const lines = fileContent.split('\n');
 	  

package/hdoc-serve.js

@@ -5,11 +5,9 @@
 	const hdoc = require(path.join(__dirname, "hdoc-module.js"));
 	const stream = require("node:stream");
 
-	const yaml = require("js-yaml");
-	const mdfm = require("markdown-it-front-matter");						
+	const mdfm = require("markdown-it-front-matter");
 
 	const { execSync } = require("child_process");
-	const tmp = require("tmp");
 
 	const mermaid_theme_path = path.resolve(
 		__dirname,
@@ -134,8 +132,8 @@
 				highlight: function (str, lang) {
 					if (lang === "mermaid") {
 						try {
-							const tmpInput = tmp.fileSync({ postfix: ".mmd" });
-							const tmpOutput = tmp.fileSync({ postfix: ".svg" });
+							const tmpInput = hdoc.tmp_file_sync({ postfix: ".mmd" });
+							const tmpOutput = hdoc.tmp_file_sync({ postfix: ".svg" });
 
 							if (!str.startsWith('---')) {
 								str = '---\n' + fs.readFileSync(mermaid_theme_path, {encoding: 'utf-8'}) + `\n---\n${str}`;
@@ -199,7 +197,7 @@ ${err.message}
 			const html_txt = md.render(md_txt.toString());
 
 			if (frontmatter_content.length) {
-				const obj = yaml.load(frontmatter_content);
+				const obj = hdoc.parse_yaml(frontmatter_content);
 				const buff = Buffer.from(JSON.stringify(obj), "utf-8");
 				const base64 = buff.toString("base64");
 				res.setHeader("X-frontmatter", base64);