hdoc-tools 0.60.0 → 0.61.0

package/hdoc-validate-config.js

@@ -13,6 +13,7 @@
 	const project_pdf_keys = Object.keys(project_schema.properties.pdfGeneration.properties);
 	const project_validation_keys = Object.keys(project_schema.properties.validation.properties);
 	const project_redirect_keys = Object.keys(project_schema.properties.redirects.items.properties);
+	const project_ai_keys = Object.keys(project_schema.properties.ai.properties);
 	const redirect_valid_codes = project_schema.properties.redirects.items.properties.code.enum;
 
 	// Reports any keys in obj that are not in the allowed set.
@@ -152,6 +153,31 @@
 					typeof config.validation.external_link_warnings !== 'boolean') {
 					errors.push(`${file}: "validation.external_link_warnings" must be a boolean`);
 				}
+				if (config.validation.spellcheckDictionary !== undefined) {
+					if (!Array.isArray(config.validation.spellcheckDictionary)) {
+						errors.push(`${file}: "validation.spellcheckDictionary" must be an array`);
+					} else {
+						for (let i = 0; i < config.validation.spellcheckDictionary.length; i++) {
+							if (typeof config.validation.spellcheckDictionary[i] !== 'string') {
+								errors.push(`${file}: "validation.spellcheckDictionary[${i}]" must be a string`);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		if (config.ai !== undefined) {
+			if (typeof config.ai !== 'object' || Array.isArray(config.ai) || config.ai === null) {
+				errors.push(`${file}: "ai" must be an object`);
+			} else {
+				check_extra_keys(config.ai, project_ai_keys, 'ai', file, errors);
+				if (config.ai.model !== undefined && typeof config.ai.model !== 'string') {
+					errors.push(`${file}: "ai.model" must be a string`);
+				}
+				if (config.ai.maxTokens !== undefined && !Number.isInteger(config.ai.maxTokens)) {
+					errors.push(`${file}: "ai.maxTokens" must be an integer`);
+				}
 			}
 		}
 

package/hdoc-validate-interbook.js

@@ -0,0 +1,321 @@
+// Inter-book link validation.
+//
+// When a GitHub token is supplied to build/validate, root-relative links that
+// point at OTHER Hornbill Docs books (e.g. /esp-config/some/article#anchor) —
+// and fully-qualified docs.hornbill.com links where those are permitted
+// (_inline content) — are validated instead of being skipped:
+//
+//   1. The target book must exist — either listed in the published library
+//      (https://docs.hornbill.com/_books/library.json) or as a repo under
+//      github.com/Hornbill-Docs/<docId>.
+//   2. The target article must exist in the book's GitHub repo (default
+//      branch): <docId>/<path>.md, <path>/index.md, <path>.html or <path>.htm.
+//      A path matched by the target book's redirects[] also passes.
+//   3. If the source link carries a #hash-anchor, a matching heading anchor
+//      must exist in the target article. Anchor ids are derived from h2/h3
+//      headings with the same hdoc.makeAnchorIdFriendly slug used at build.
+//
+// All lookups are cached as promises (per book, per article, per repo config)
+// so concurrent link checks for the same target collapse into one API call.
+// GitHub API calls go through hdoc.fetchWithRetry which throttles to
+// 1 request/800ms and honours rate-limit headers.
+//
+// Result levels:
+//   ok      - link verified (caller appends to validated-links.txt)
+//   skip    - could not verify by design (book has no public source) — logged
+//   warning - could not verify due to access/infra (401/403, library down)
+//   error   - target book/article/anchor definitively missing
+(() => {
+	const cheerio = require("cheerio");
+	const path = require("node:path");
+	const hdoc = require(path.join(__dirname, "hdoc-module.js"));
+
+	const LIBRARY_URL = "https://docs.hornbill.com/_books/library.json";
+	const GITHUB_ORG_FALLBACK = "https://github.com/Hornbill-Docs";
+
+	let git_token = "";
+	let library_promise = null;
+	const book_cache = {}; // docId -> promise of book resolution
+	const article_cache = {}; // docId|path -> promise of article fetch
+	const redirects_cache = {}; // repo url -> promise of redirect url set
+
+	const gh_headers = () => {
+		const headers = {
+			"User-Agent": "HornbillDocsBuild",
+			"Cache-Control": "no-cache",
+			Accept: "application/vnd.github.raw+json",
+		};
+		if (git_token !== "") headers.authorization = `Bearer ${git_token}`;
+		return headers;
+	};
+
+	// github.com/<owner>/<repo> -> api.github.com/repos/<owner>/<repo>
+	const repo_api_base = (repo_url) => {
+		const clean = repo_url.endsWith("/") ? repo_url.slice(0, -1) : repo_url;
+		return clean.replace(
+			"https://github.com/",
+			"https://api.github.com/repos/",
+		);
+	};
+
+	const get_library = () => {
+		if (library_promise === null) {
+			library_promise = (async () => {
+				const books = {};
+				const resp = await hdoc.fetchWithRetry(LIBRARY_URL, {
+					headers: { "User-Agent": "HornbillDocsBuild" },
+					timeoutMs: 10000,
+				});
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				const data = await resp.json();
+				for (const book of data.books || []) {
+					books[book.docId] = book;
+				}
+				return books;
+			})().catch((e) => {
+				// Cache the failure — one warning per run, not one per link
+				return { __error: `${e}` };
+			});
+		}
+		return library_promise;
+	};
+
+	// Resolve a docId to { exists, repo|null, unverifiable|undefined }
+	const resolve_book = (doc_id) => {
+		if (!book_cache[doc_id]) {
+			book_cache[doc_id] = (async () => {
+				const library = await get_library();
+				if (!library.__error && library[doc_id]) {
+					return {
+						exists: true,
+						repo: library[doc_id].publicSource || null,
+					};
+				}
+				// Not in the public library (internal book?) or library down —
+				// fall back to the conventional repo location.
+				const fallback_repo = `${GITHUB_ORG_FALLBACK}/${doc_id}`;
+				const details = await hdoc.get_github_repo_details(
+					repo_api_base(fallback_repo),
+					git_token,
+				);
+				if (details.success) return { exists: true, repo: fallback_repo };
+				// get_github_repo_details reports 404 as "Error: HTTP 404" (early
+				// return) or "404 : Not Found" (json branch) depending on path
+				const err = details.error instanceof Error ? details.error.message : `${details.error}`;
+				if (err.includes("404")) {
+					if (library.__error) {
+						// Library unreachable AND no fallback repo — can't be sure
+						return {
+							exists: false,
+							repo: null,
+							unverifiable: `book library unreachable (${library.__error}) and no repo at ${fallback_repo}`,
+						};
+					}
+					return { exists: false, repo: null };
+				}
+				// 401/403/network — repo may exist but we can't see it
+				return {
+					exists: false,
+					repo: null,
+					unverifiable: `GitHub lookup failed for ${fallback_repo}: ${err}`,
+				};
+			})();
+		}
+		return book_cache[doc_id];
+	};
+
+	// Fetch a repo file's raw content via the contents API.
+	// Returns { status, content } — content null unless status 200.
+	const fetch_repo_file = async (repo, file_path) => {
+		const encoded = file_path.split("/").map(encodeURIComponent).join("/");
+		const resp = await hdoc.fetchWithRetry(
+			`${repo_api_base(repo)}/contents/${encoded}`,
+			{ headers: gh_headers(), timeoutMs: 10000 },
+			2,
+		);
+		return {
+			status: resp.status,
+			content: resp.ok ? await resp.text() : null,
+		};
+	};
+
+	// The redirect urls declared in the target book's hdocbook-project.json —
+	// a link to a redirected path is valid (the published site serves 301/308).
+	const get_redirect_urls = (repo) => {
+		if (!redirects_cache[repo]) {
+			redirects_cache[repo] = (async () => {
+				const urls = {};
+				try {
+					const file = await fetch_repo_file(repo, "hdocbook-project.json");
+					if (file.status === 200) {
+						const project = JSON.parse(file.content);
+						for (const redirect of project.redirects || []) {
+							if (redirect.url) urls[redirect.url] = true;
+						}
+					}
+				} catch {
+					// Malformed/missing project file in target repo — no redirects
+				}
+				return urls;
+			})();
+		}
+		return redirects_cache[repo];
+	};
+
+	// Derive the set of hb-doc-anchor-* ids the build would generate for a
+	// target article. Markdown: h2/h3 ATX headings outside code fences, with
+	// [text](url) collapsed to text before slugging (matching rendered text).
+	// HTML: real h2/h3 elements via cheerio.
+	const extract_anchor_ids = (content, is_html) => {
+		const anchors = {};
+		if (is_html) {
+			const $ = cheerio.load(content);
+			$("h2, h3").each(function () {
+				anchors[hdoc.makeAnchorIdFriendly($(this).text().trim())] = true;
+			});
+			return anchors;
+		}
+		let in_fence = false;
+		for (const raw_line of content.split("\n")) {
+			const line = raw_line.trimEnd();
+			if (/^\s*(```|~~~)/.test(line)) {
+				in_fence = !in_fence;
+				continue;
+			}
+			if (in_fence) continue;
+			const match = line.match(/^(##|###)\s+(.*)$/);
+			if (!match) continue;
+			const text = match[2]
+				.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1") // md links -> link text
+				.replace(/[`*_]/g, "") // inline emphasis/code markers
+				.trim();
+			anchors[hdoc.makeAnchorIdFriendly(text)] = true;
+		}
+		return anchors;
+	};
+
+	// Locate an article inside a book repo, trying the same resolution order
+	// the published site uses. Returns
+	// { found, redirected, unverifiable, anchors } — anchors null when the
+	// article was matched via redirect (content not fetched).
+	const resolve_article = (repo, doc_id, article_path) => {
+		const cache_key = `${doc_id}|${article_path}`;
+		if (!article_cache[cache_key]) {
+			article_cache[cache_key] = (async () => {
+				const base = `${doc_id}/${article_path}`;
+				const candidates = [
+					{ file: `${base}.md`, html: false },
+					{ file: `${base}/index.md`, html: false },
+					{ file: `${base}.html`, html: true },
+					{ file: `${base}.htm`, html: true },
+				];
+				// Book-root link (/other-book) → the book's index page
+				if (article_path === "index") candidates.splice(1, 1);
+				for (const candidate of candidates) {
+					const file = await fetch_repo_file(repo, candidate.file);
+					if (file.status === 200) {
+						return {
+							found: true,
+							anchors: extract_anchor_ids(file.content, candidate.html),
+						};
+					}
+					if (file.status !== 404) {
+						return {
+							found: false,
+							unverifiable: `GitHub returned HTTP ${file.status} for ${candidate.file}`,
+						};
+					}
+				}
+				const redirect_urls = await get_redirect_urls(repo);
+				if (redirect_urls[`/${base}`]) {
+					return { found: true, redirected: true, anchors: null };
+				}
+				return { found: false };
+			})();
+		}
+		return article_cache[cache_key];
+	};
+
+	exports.init = (token) => {
+		git_token = token || "";
+	};
+
+	exports.enabled = () => git_token !== "";
+
+	// link: root-relative inter-book link, e.g. /esp-config/path/article#anchor
+	// Returns { level: 'ok'|'skip'|'warning'|'error', message }
+	exports.check_link = async (link) => {
+		const [link_path, hash_anchor] = link.split("#");
+		const segments = link_path.split("/").filter((s) => s !== "");
+		if (segments[0] === "_books") segments.shift();
+		const doc_id = segments.shift();
+		const article_path = segments.length > 0 ? segments.join("/") : "index";
+
+		let book;
+		try {
+			book = await resolve_book(doc_id);
+		} catch (e) {
+			return {
+				level: "warning",
+				message: `Unable to verify inter-book link [${link}]: ${e}`,
+			};
+		}
+		if (book.unverifiable) {
+			return {
+				level: "warning",
+				message: `Unable to verify inter-book link [${link}]: ${book.unverifiable}`,
+			};
+		}
+		if (!book.exists) {
+			return {
+				level: "error",
+				message: `Inter-book link target book does not exist: ${doc_id} [${link}]`,
+			};
+		}
+		if (!book.repo) {
+			// Generated books (API references) have no public source repo
+			return {
+				level: "skip",
+				message: `Inter-book link target book [${doc_id}] exists but has no source repo - article not verified: ${link}`,
+			};
+		}
+
+		let article;
+		try {
+			article = await resolve_article(book.repo, doc_id, article_path);
+		} catch (e) {
+			return {
+				level: "warning",
+				message: `Unable to verify inter-book link [${link}]: ${e}`,
+			};
+		}
+		if (article.unverifiable) {
+			return {
+				level: "warning",
+				message: `Unable to verify inter-book link [${link}]: ${article.unverifiable}`,
+			};
+		}
+		if (!article.found) {
+			return {
+				level: "error",
+				message: `Inter-book link target article does not exist in book [${doc_id}]: ${link}`,
+			};
+		}
+
+		if (hash_anchor) {
+			if (article.anchors === null) {
+				return {
+					level: "skip",
+					message: `Inter-book link resolves via redirect - hash anchor not verified: ${link}`,
+				};
+			}
+			if (!article.anchors[`hb-doc-anchor-${hash_anchor}`]) {
+				return {
+					level: "error",
+					message: `Inter-book link hash anchor not present in target article: ${link}`,
+				};
+			}
+		}
+		return { level: "ok", message: `Inter-book link verified: ${link}` };
+	};
+})();

package/hdoc-validate.js

@@ -1,12 +1,10 @@
-const e = require("express");
-const { error } = require("node:console");
-
 (() => {
 	const cheerio = require("cheerio");
 	const dns = require("node:dns");
 	const fs = require("node:fs");
 	const path = require("node:path");
 	const hdoc = require(path.join(__dirname, "hdoc-module.js"));
+	const interbook = require(path.join(__dirname, "hdoc-validate-interbook.js"));
 	const translator = require("american-british-english-translator");
 
 	const spellcheck_options = {
@@ -500,6 +498,24 @@ const { error } = require("node:console");
 		return resp.status;
 	};
 
+	// Map an inter-book check result onto errors/warnings/messages and the
+	// validated-links cache. 'ok' and 'skip' outcomes are stable, so they are
+	// appended to validated-links.txt like any other passing link.
+	const handleInterbookResult = (result, link, htmlFile, markdown_paths, markdown_content) => {
+		if (result.level === "error") {
+			errors[htmlFile.relativePath].push(
+				processErrorMessage(result.message, markdown_paths.relativePath, markdown_content, link),
+			);
+		} else if (result.level === "warning") {
+			warnings[htmlFile.relativePath].push(
+				processErrorMessage(result.message, markdown_paths.relativePath, markdown_content, link),
+			);
+		} else {
+			messages[htmlFile.relativePath].push(result.message);
+			fs.appendFileSync(skip_link_file, `${link}\n`);
+		}
+	};
+
 	const checkLinks = async (source_path, htmlFile, links, hdocbook_config, hdocbook_project, global_links_checked, output_links) => {
 		const markdown_paths = getMDPathFromHtmlPath(htmlFile);
 		const markdown_content = fs.readFileSync(markdown_paths.markdownPath, 'utf8');
@@ -545,9 +561,23 @@ const { error } = require("node:console");
 						errors[htmlFile.relativePath].push(error_message);
 					}
 
-					// Checking for internal links in other books - can't easily validate those here, returning
+					// Links into other books: verified against GitHub when a token
+					// was supplied, otherwise skipped (can't validate locally).
 					if ((link_segments.length > 1 && link_root !== hdocbook_config.docId) || (link_segments.length === 1 && link_root !== hdocbook_config.docId && link_root !== "index")) {
-						fs.appendFileSync(skip_link_file, `${links[i]}\n`);
+						if (interbook.enabled() && path.extname(links[i].split("#")[0]) === "") {
+							const link = links[i];
+							externalChecks.push(async () =>
+								handleInterbookResult(
+									await interbook.check_link(link),
+									link,
+									htmlFile,
+									markdown_paths,
+									markdown_content,
+								),
+							);
+						} else {
+							fs.appendFileSync(skip_link_file, `${links[i]}\n`);
+						}
 						continue;
 					}
 					isRelativePath(source_path, htmlFile, links[i]);
@@ -561,8 +591,10 @@ const { error } = require("node:console");
 				);
 
 				// Skip if it's the auto-generated edit url, as these could be part of a private repo which would return a 404
+				// publicSource must be truthy, not just defined - an empty string makes
+				// get_github_api_path return "" which has no edit_path
 				if (
-					hdocbook_config.publicSource !== undefined &&
+					hdocbook_config.publicSource &&
 					links[i] ===
 					hdoc
 					.get_github_api_path(
@@ -609,6 +641,29 @@ const { error } = require("node:console");
 					continue;
 				}
 
+				// Fully-qualified Hornbill Docs links (only permitted in _inline
+				// content — anything else errored above): with a GitHub token,
+				// validate book/article/anchor instead of a plain HTTP check.
+				const link_host = valid_url.hostname ? valid_url.hostname.toLowerCase() : "";
+				if (
+					interbook.enabled() &&
+					(link_host === "docs.hornbill.com" || link_host === "docs-internal.hornbill.com") &&
+					path.extname(valid_url.pathname) === ""
+				) {
+					const link = links[i];
+					const book_link = valid_url.pathname + valid_url.hash;
+					externalChecks.push(async () =>
+						handleInterbookResult(
+							await interbook.check_link(book_link),
+							link,
+							htmlFile,
+							markdown_paths,
+							markdown_content,
+						),
+					);
+					continue;
+				}
+
 				// Capture url in closure for the async check below
 				const url = links[i];
 				const isInternal = url.toLowerCase().includes("internal.hornbill.com");
@@ -838,7 +893,9 @@ const { error } = require("node:console");
 	};
 
 	const processErrorMessage = (message, md_path, content, search) => {
-		const link_location = hdoc.find_string_in_string(content, search);
+		// whole_link — a link that is a substring of a longer link elsewhere in
+		// the file must not be located at the longer link's position
+		const link_location = hdoc.find_string_in_string(content, search, true);
 		let error_message = message;
 		if (link_location !== null)
 			error_message = `${md_path}:${link_location.line}:${link_location.column} - ${error_message}`;
@@ -913,10 +970,16 @@ const { error } = require("node:console");
 		browser,
 		source_root_path,
 		output_links = true,
+		git_token = "",
 	) => {
 		console.log("Performing Validation and Building SEO Link List...");
 		redirects = gen_redirects;
 		private_repo = is_private;
+		interbook.init(git_token);
+		if (interbook.enabled())
+			console.log(
+				"GitHub token supplied - inter-book links will be validated against GitHub",
+			);
 
 		// Load the skip link validation file if it exists
 		loadSkipLinkValidation(source_root_path);
@@ -1130,6 +1193,18 @@ const { error } = require("node:console");
 		console.log("\r\n-----------------------");
 		console.log("   Validation Output   ");
 		console.log("-----------------------");
+		let warning_count = 0;
+		for (const key in warnings) {
+			if (Object.hasOwn(warnings, key) && warnings[key].length > 0) {
+				for (let i = 0; i < warnings[key].length; i++) {
+					console.info(`[WARNING] ${key} - ${warnings[key][i]}`);
+					warning_count++;
+				}
+			}
+		}
+		if (warning_count > 0) {
+			console.info(`\r\n${warning_count} Validation Warnings Found (non-fatal)\r\n`);
+		}
 		if (Object.keys(errors).length > 0) {
 			let error_count = 0;
 			for (const key in errors) {

package/hdoc-ver.js

@@ -1,43 +1,45 @@
-(() => {
-	const fs = require("node:fs");
-	const path = require("node:path");
-
-	exports.run = (source_path) => {
-		console.log("Retrieving book version...\n");
-
-		// Get document ID
-		const hdocbook_project_config_path = path.join(
-			source_path,
-			"hdocbook-project.json",
-		);
-		let hdocbook_project;
-		try {
-			hdocbook_project = require(hdocbook_project_config_path);
-		} catch (e) {
-			console.error("File not found: hdocbook-project.json:");
-			console.log(e, "\n");
-			console.error("hdoc ver needs to be run in the root of a HDoc Book.\n");
-			process.exit(1);
-		}
-		const doc_id = hdocbook_project.docId;
-
-		const book_path = path.join(source_path, doc_id);
-		const hdocbook_path = path.join(book_path, "hdocbook.json");
-
-		let hdocbook_config;
-		try {
-			hdocbook_config = require(hdocbook_path);
-		} catch (e) {
-			console.error("File not found: hdocbook.json");
-			console.log(e, "\n");
-			console.error("hdoc ver needs to be run in the root of a HDoc Book.\n");
-			process.exit(1);
-		}
-		if (hdocbook_config.version && hdocbook_config.version !== "") {
-			console.log(`Book version: ${hdocbook_config.version}\n`);
-		} else {
-			console.error("Error - this book has no version defined.\n");
-			process.exit(1);
-		}
-	};
-})();
+(() => {
+	const fs = require("node:fs");
+	const path = require("node:path");
+
+	exports.run = (source_path) => {
+		console.log("Retrieving book version...\n");
+
+		// Get document ID
+		const hdocbook_project_config_path = path.join(
+			source_path,
+			"hdocbook-project.json",
+		);
+		let hdocbook_project;
+		try {
+			hdocbook_project = JSON.parse(
+				fs.readFileSync(hdocbook_project_config_path, "utf8"),
+			);
+		} catch (e) {
+			console.error("File not found: hdocbook-project.json:");
+			console.log(e, "\n");
+			console.error("hdoc ver needs to be run in the root of a HDoc Book.\n");
+			process.exit(1);
+		}
+		const doc_id = hdocbook_project.docId;
+
+		const book_path = path.join(source_path, doc_id);
+		const hdocbook_path = path.join(book_path, "hdocbook.json");
+
+		let hdocbook_config;
+		try {
+			hdocbook_config = JSON.parse(fs.readFileSync(hdocbook_path, "utf8"));
+		} catch (e) {
+			console.error("File not found: hdocbook.json");
+			console.log(e, "\n");
+			console.error("hdoc ver needs to be run in the root of a HDoc Book.\n");
+			process.exit(1);
+		}
+		if (hdocbook_config.version && hdocbook_config.version !== "") {
+			console.log(`Book version: ${hdocbook_config.version}\n`);
+		} else {
+			console.error("Error - this book has no version defined.\n");
+			process.exit(1);
+		}
+	};
+})();

package/hdoc.js

@@ -162,7 +162,6 @@
 	let gen_exclude = false;
 	let bump_type = "patch"; // To generate spellcheck exclusions for all files
 	let output_links = true;
-	let onyx_index = false;
 	let build_embeddings = true;
 
 	// Get options from command args
@@ -211,8 +210,6 @@
 			console_color = false;
 		} else if (process.argv[x].toLowerCase() === "--no-links") {
 			output_links = false;
-		} else if (process.argv[x].toLowerCase() === "--onyx") {
-			onyx_index = true;
 		} else if (process.argv[x].toLowerCase() === "--no-embeddings") {
 			build_embeddings = false;
 		} else if (process.argv[x].toLowerCase() === "--quiet") {
@@ -247,15 +244,19 @@
 	}
 
 
-	// Add validated-links.txt to .gitignore if it doesn't exist
-	const gitignorePath = path.join(source_path, ".gitignore");
-	if (fs.existsSync(gitignorePath)) {
-		const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
-		if (!gitignoreContent.includes("validated-links.txt")) {
-			fs.appendFileSync(gitignorePath, "\nvalidated-links.txt\n");
-			console.info("Added validated-links.txt to .gitignore");
+	// build/validate write a validated-links.txt link cache into the book repo;
+	// make sure it's gitignored. Other commands don't touch the file, so they
+	// leave .gitignore alone.
+	if (["build", "validate"].includes(command.toLowerCase())) {
+		const gitignorePath = path.join(source_path, ".gitignore");
+		if (fs.existsSync(gitignorePath)) {
+			const gitignoreContent = fs.readFileSync(gitignorePath, "utf8");
+			if (!gitignoreContent.includes("validated-links.txt")) {
+				fs.appendFileSync(gitignorePath, "\nvalidated-links.txt\n");
+				console.info("Added validated-links.txt to .gitignore");
+			}
 		}
-	} 
+	}
 	
 	if (command.toLowerCase() === "serve") {
 		const server = require(path.join(__dirname, "hdoc-serve.js"));

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
 	"name": "hdoc-tools",
-	"version": "0.59.0",
+	"version": "0.61.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "hdoc-tools",
-			"version": "0.59.0",
+			"version": "0.61.0",
 			"hasInstallScript": true,
 			"license": "ISC",
 			"dependencies": {