hdoc-tools 0.19.8 → 0.21.0

package/hdoc-validate.js

@@ -1,717 +1,958 @@
-(function () {
-    'use strict';
-
-    const axios = require('axios'),
-        cheerio = require('cheerio'),
-        dree = require('dree'),
-        fs = require('fs'),
-        path = require('path'),
-        https = require('https'),
-        hdoc = require(path.join(__dirname, 'hdoc-module.js')),
-        translator = require('american-british-english-translator'),
-        { trueCasePathSync } = require('true-case-path');
-
-    const spellcheck_options = {
-        british: true,
-        spelling: true
-    },
-        regex_nav_paths = /[a-z0-9-\/]+[a-z0-9]+#{0,1}[a-z0-9-\/]+/,
-        agent = new https.Agent({
-            rejectUnauthorized: false
-        });
-
-    let errors = {},
-        messages = {},
-        warnings = {},
-        html_to_validate = [],
-        md_to_validate = [],
-        exclude_links = {},
-        exclude_spellcheck = {},
-        redirects = {},
-        exclude_h1_count = {},
-        exclude_spellcheck_output = [];
-
-    const excludeLink = async function (url) {
-        if (exclude_links[url]) return true;
-
-        for (let key in exclude_links) {
-            if (key.endsWith('*')) {
-                key = key.substring(0, key.length - 1);
-                if (url.startsWith(key)) return true;
-            }
-        }
-
-        return false;
-    };
-
-    const spellcheckContent = async function (sourceFile, excludes) {
-        let spelling_errors = {};
-        let words = [];
-        const text = fs.readFileSync(sourceFile.path, 'utf8');
-        const source_path = sourceFile.relativePath.replace('.' + sourceFile.extension, '');
-        const translate_output = translator.translate(text, spellcheck_options);
-        if (Object.keys(translate_output).length) {
-            for (const key in translate_output) {
-                if (translate_output.hasOwnProperty(key)) {
-                    let error_message = `Line ${key} - British spelling:`;
-                    for (let i = 0; i < translate_output[key].length; i++) {
-                        for (const spelling in translate_output[key][i]) {
-                            if (translate_output[key][i].hasOwnProperty(spelling) && (typeof translate_output[key][i][spelling].details === 'string')) {
-                                if (!excludes[source_path]) {
-                                    errors[sourceFile.relativePath].push(`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`);
-                                    spelling_errors[spelling] = true;
-                                } else if (!excludes[source_path].includes(spelling.toLowerCase())) {
-                                    errors[sourceFile.relativePath].push(`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`);
-                                    spelling_errors[spelling] = true;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        if (Object.keys(spelling_errors).length) {
-            let exclude_output = {
-                document_path: sourceFile.relativePath.replace(path.extname(sourceFile.relativePath), ''),
-                words: []
-            };
-            for (const word in spelling_errors) {
-                if (spelling_errors.hasOwnProperty(word)) {
-                    words.push(word);
-                    exclude_output.words.push(word);
-                }
-            }
-            exclude_spellcheck_output.push(exclude_output);
-        }
-        return words;
-    };
-
-    const checkInline = async function (source_path, inline, excludes) {
-        let inline_errors = [];
-        for (let i = 0; i < inline.length; i++) {
-            const title = inline[i].title,
-                link = inline[i].link;
-
-            // Validate link segment spellings
-            const paths = link.split('/');
-            for (let i = 0; i < paths.length; i++) {
-                const path_words = paths[i].split('-');
-                for (let j = 0; j < path_words.length; j++) {
-                    const translate_output = translator.translate(path_words[j], spellcheck_options);
-                    if (Object.keys(translate_output).length) {
-                        for (const spell_val in translate_output) {
-                            if (translate_output.hasOwnProperty(spell_val)) {
-                                for (const spelling in translate_output[spell_val][0]) {
-                                    if (translate_output[spell_val][0].hasOwnProperty(spelling)) {
-                                        if (!excludes[link]) {
-                                            inline_errors.push(`Inline Link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`);
-                                        } else if (!excludes[link].includes(spelling.toLowerCase())) {
-                                            inline_errors.push(`Inline Link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Validate display names
-            const translate_output = translator.translate(title, spellcheck_options);
-            if (Object.keys(translate_output).length) {
-                for (const spell_val in translate_output) {
-                    if (translate_output.hasOwnProperty(spell_val)) {
-                        for (let j = 0; j < translate_output[spell_val].length; j++) {
-                            for (const spelling in translate_output[spell_val][j]) {
-                                if (translate_output[spell_val][j].hasOwnProperty(spelling)) {
-                                    if (!excludes[link]) {
-                                        inline_errors.push(`Inline title for link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`);
-                                    } else if (!excludes[link].includes(spelling.toLowerCase())) {
-                                        inline_errors.push(`Inline title for link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Validate path exists - link should be a html file at this point as its after the content has been built
-            let file_exists = true;
-            let file_name = path.join(source_path, link + '.html');
-            if (!fs.existsSync(file_name)) {
-                file_name = path.join(source_path, link + '.htm');
-                if (!fs.existsSync(file_name)) {
-                    file_name = path.join(source_path, link, 'index.html');
-                    if (!fs.existsSync(file_name)) {
-                        file_name = path.join(source_path, link, 'index.htm');
-                        if (!fs.existsSync(file_name)) {
-                            file_exists = false;
-                            inline_errors.push(`Inline link [${link}] file does not exist.`);
-                        }
-                    }
-                }
-            }
-        }
-
-        return inline_errors;
-    };
-
-    const checkNavigation = async function (source_path, flat_nav, excludes) {
-        let nav_errors = [];
-        for (let key in flat_nav) {
-            if (flat_nav.hasOwnProperty(key)) {
-                // doc paths should only contain a-z - characters
-                const invalid_chars = key.replace(regex_nav_paths, '');
-                if (invalid_chars !== '') {
-                    nav_errors.push(`Navigation path [${key}] contains the following invalid characters: [${[...invalid_chars].join('] [')}]`);
-                }
-                const key_split = key.split('#');
-                const key_no_hash = key_split[0];
-
-                // See if there's a redirect in place
-                let redirected = false;
-                let redirect_errored = false;
-                const redir = checkRedirect(source_path, key_no_hash);
-
-                if (redir.exists && redir.error !== null) {
-                    nav_errors.push(redir.error);
-                    redirect_errored = true;
-                } else if (redir.exists && redir.error === null) {
-                    redirected = true;
-                }
-
-                // Validate path exists - key should be a html file at this point
-                let file_exists = true;
-                let file_name = path.join(source_path, key_no_hash + '.html');
-                if (!fs.existsSync(file_name)) {
-                    file_name = path.join(source_path, key_no_hash + '.htm');
-                    if (!fs.existsSync(file_name)) {
-                        file_name = path.join(source_path, key_no_hash, 'index.html');
-                        if (!fs.existsSync(file_name)) {
-                            file_name = path.join(source_path, key_no_hash, 'index.htm');
-                            if (!fs.existsSync(file_name)) {
-                                file_exists = false;
-                                if (!redirected && !redirect_errored)
-                                    nav_errors.push(`Navigation path [${key_no_hash}] file does not exist.`);
-                            }
-                        }
-                    }
-                }
-
-                if (file_exists) {
-                    // File exists - but is there a redirect? If so, we want to flag this as an error
-                    if (redirected)
-                        nav_errors.push(`Navigation path [${key_no_hash}] is redirected, but path still exists.`);
-
-                    // Check file path case match
-                    const true_file = trueCasePathSync(file_name).replace(source_path, '').replaceAll('\\', '/');
-                    const relative_file = file_name.replace(source_path, '').replaceAll('\\', '/');
-                    if (true_file !== relative_file) {
-                        nav_errors.push(`Navigation path [${key}] for filename [${relative_file}] does not match filename case [${true_file}].`);
-                    }
-                }
-
-                // Validate path spellings
-                const paths = key.split('/');
-                for (let i = 0; i < paths.length; i++) {
-                    const path_words = paths[i].split('-');
-                    for (let j = 0; j < path_words.length; j++) {
-                        const translate_output = translator.translate(path_words[j], spellcheck_options);
-                        if (Object.keys(translate_output).length) {
-                            for (const spell_val in translate_output) {
-                                if (translate_output.hasOwnProperty(spell_val)) {
-                                    for (const spelling in translate_output[spell_val][0]) {
-                                        if (translate_output[spell_val][0].hasOwnProperty(spelling)) {
-                                            if (!excludes[key]) {
-                                                nav_errors.push(`Navigation path [${key}] key contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`);
-                                            } else if (!excludes[key].includes(spelling.toLowerCase())) {
-                                                nav_errors.push(`Navigation path [${key}] key contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`);
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                // Validate display names/bookmarks
-                for (let i = 0; i < flat_nav[key].length; i++) {
-                    if (flat_nav[key][i].link === key) {
-                        const translate_output = translator.translate(flat_nav[key][i].text, spellcheck_options);
-                        if (Object.keys(translate_output).length) {
-                            for (const spell_val in translate_output) {
-                                if (translate_output.hasOwnProperty(spell_val)) {
-                                    for (let j = 0; j < translate_output[spell_val].length; j++) {
-                                        for (const spelling in translate_output[spell_val][j]) {
-                                            if (translate_output[spell_val][j].hasOwnProperty(spelling)) {
-                                                if (!excludes[key]) {
-                                                    nav_errors.push(`Navigation path [${key}] display text contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`);
-                                                } else if (!excludes[key].includes(spelling.toLowerCase())) {
-                                                    nav_errors.push(`Navigation path [${key}] display text contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`);
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-            }
-        }
-        return nav_errors;
-    };
-
-    const checkRedirects = async function (source_path) {
-        let errors = [];
-        for (const key in redirects) {
-            if (redirects.hasOwnProperty(key)) {
-                if (redirects[key].code !== 301 && redirects[key].code !== 308 && redirects[key].code !== 410 )
-                    errors.push(`Invalid redirect code: ${redirects[key].code}`);
-
-                if (redirects[key].location) {
-                    let redir_locations = [
-                        path.join(source_path, redirects[key].location + '.md'),
-                        path.join(source_path, redirects[key].location, 'index.md'),
-                        path.join(source_path, redirects[key].location + '.html'),
-                        path.join(source_path, redirects[key].location + '.htm'),
-                        path.join(source_path, redirects[key].location, 'index.html'),
-                        path.join(source_path, redirects[key].location, 'index.htm')
-                    ];
-                    let redir_location_ok = false;
-                    for (let i = 0; i < redir_locations.length; i++) {
-                        if (fs.existsSync(redir_locations[i])) {
-                            redir_location_ok = true;
-                            break;
-                        }
-                    }
-                    if (!redir_location_ok)
-                        errors.push(`Redirect location does not exist: ${redirects[key].location}`);
-                }
-            }
-        }
-        return errors;
-    };
-
-    const checkRedirect = function (source_path, nav_path) {
-        let response = {
-            exists: false,
-            error: null
-        }
-        if (redirects[nav_path]) {
-            response.exists = true;
-            if (redirects[nav_path].location) {
-                // We have a redirect, check if it's a valid location
-                let file_path = path.join(source_path, redirects[nav_path].location + '.html');
-                if (!fs.existsSync(file_path)) {
-                    file_path = path.join(source_path, redirects[nav_path].location + '.htm');
-                    if (!fs.existsSync(file_path)) {
-                        file_path = path.join(source_path, redirects[nav_path].location, 'index.html');
-                        if (!fs.existsSync(file_path)) {
-                            file_path = path.join(source_path, redirects[nav_path].location, 'index.htm');
-                            if (!fs.existsSync(file_path)) {
-                                response.error = `Redirect path for [${nav_path}] does not exist: ${redirects[nav_path].location}`;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return response;
-    }
-
-    const checkLinks = async function (source_path, htmlFile, links, hdocbook_config, redirects) {
-        for (let i = 0; i < links.length; i++) {
-
-            // Validate that link is a valid URL first
-            const valid_url = hdoc.valid_url(links[i]);
-            if (!valid_url) {
-                // Could be a relative path, check
-                if (links[i].startsWith('/')) {
-                    let link_root = links[i].split('/');
-                    link_root = link_root[0] !== '' ? link_root[0] : link_root[1];
-                    if (link_root !== hdocbook_config.docId) continue;
-                    isRelativePath(source_path, htmlFile, links[i]);
-                } else if (links[i].startsWith('#')) {
-                    //Anchor - do nothing
-                } else {
-                    errors[htmlFile.relativePath].push(`Root relative links should start with a forward-slash: ${links[i]}`);
-                }
-            } else {
-                messages[htmlFile.relativePath].push(`Link is a properly formatted external URL: ${links[i]}`);
-
-                // Skip if it's the auto-generated edit url, as these could be part of a private repo which would return a 404
-                if (hdocbook_config.publicSource !== undefined && links[i] === hdoc.get_github_api_path(hdocbook_config.publicSource, htmlFile.relativePath).edit_path.replace(path.extname(htmlFile.relativePath), '.md')) {
-                    continue;
-                }
-
-                if (valid_url.protocol === 'mailto:') {
-                    continue;
-                }
-
-                // Skip if the link is excluded in the project config
-                if (excludeLink(links[i])) {
-                    messages[htmlFile.relativePath].push(`Skipping link validation for: ${links[i]}`);
-                    continue;
-                }
-
-                if (links[i].toLowerCase().includes('docs.hornbill.com') || links[i].toLowerCase().includes('docs-internal.hornbill.com')) {
-                    errors[htmlFile.relativePath].push(`Links to Hornbill Docs should rooted and not fully-qualified: ${links[i]}`);
-                    continue;
-                }
-
-                try {
-                    await axios.get(links[i], {
-                        httpsAgent: agent
-                    });
-                    messages[htmlFile.relativePath].push(`Link is a valid external URL: ${links[i]}`);
-                } catch (e) {
-                    // Handle errors
-                    errors[htmlFile.relativePath].push(`Link is not responding: ${links[i]} - [${e.message}]`);
-                }
-            }
-        }
-    };
-
-    const checkImages = async function (source_path, htmlFile, links) {
-        for (let i = 0; i < links.length; i++) {
-
-            // Validate that image is a valid URL first
-            if (!hdoc.valid_url(links[i])) {
-                // Could be a relative path, check image exists
-                doesFileExist(source_path, htmlFile, links[i]);
-            } else {
-                messages[htmlFile.relativePath].push(`Image link is a properly formatted external URL: ${links[i]}`);
-                // Do a Get to the URL to see if it exists
-                try {
-                    const res = await axios.get(links[i]);
-                    messages[htmlFile.relativePath].push(`Image link is a valid external URL: ${links[i]}`);
-                } catch (e) {
-                    // Handle errors
-                    errors[htmlFile.relativePath].push(`Unexpected Error from external image link: ${links[i]} - ${e.message}`);
-                }
-            }
-        }
-    };
-
-    const checkTags = async function (htmlFile) {
-        // Check if file  is excluded from tag check
-        const file_no_ext = htmlFile.relativePath.replace(path.extname(htmlFile.relativePath), '');
-        if (exclude_h1_count[file_no_ext]) return;
-
-        // Check tags
-        const htmlBody = fs.readFileSync(htmlFile.path, 'utf8');
-        const $ = cheerio.load(htmlBody);
-
-        const h1_tags = $('h1').map(function () {
-            return $(this);
-        }).get();
-        if (h1_tags.length && h1_tags.length > 1) {
-            let error_msg = `${h1_tags.length} <h1> tags found in content: `;
-            for (let i = 0; i < h1_tags.length; i++) {
-                error_msg += h1_tags[i].text();
-                if (i < h1_tags.length - 1) error_msg += '; ';
-            }
-            errors[htmlFile.relativePath].push(error_msg);
-        }
-    };
-
-    const dreeOptions = {
-        descendants: true,
-        excludeEmptyDirectories: true,
-        extensions: ['htm', 'html', 'md'],
-        hash: false,
-        normalize: true,
-        size: false,
-        sizeInBytes: false,
-        stat: false,
-        symbolicLinks: false
-    };
-
-    // File scan callback for content type files
-    const fileContentCallback = function (element) {
-        if (element.extension.toLowerCase() === 'md') {
-            md_to_validate.push(element);
-        } else {
-            html_to_validate.push(element);
-        }
-    };
-
-    const isRelativePath = function (source_path, html_path, relative_path) {
-        const rel_path_ext = path.extname(relative_path);
-        let response = {
-            is_rel_path: false,
-            has_md_extension: rel_path_ext === '.md'
-        };
-
-        const supported_relpaths = [
-            path.sep + 'index.htm',
-            path.sep + 'index.html',
-            '.htm',
-            '.html',
-            '.md'
-        ];
-
-        // Remove explicit anchor links and _books prefix
-        relative_path = relative_path.split('#')[0].replace('_books/', '');
-
-        // Make full file path
-        const file_path = path.join(source_path, relative_path);
-
-        // Does path exist?
-        if (fs.existsSync(file_path)) {
-            response.is_rel_path = true;
-        } else {
-            // Path 
-            for (let i = 0; i < supported_relpaths.length; i++) {
-                if (fs.existsSync(`${file_path}${supported_relpaths[i]}`)) {
-                    response.is_rel_path = true;
-                    break;
-                }
-            }
-        }
-        if (response.has_md_extension) {
-            errors[html_path.relativePath].push(`Relative link contains MD extension, but should not: ${relative_path}`);
-        } else {
-            if (response.is_rel_path) {
-                messages[html_path.relativePath].push(`Relative path exists: ${relative_path}`);
-            } else {
-
-                // See if there's a redirect in place
-                const relpath = relative_path.indexOf('/') == 0 ? relative_path.substring(1) : relative_path;
-                const redir = checkRedirect(source_path, relpath);
-                if (redir.exists) {
-                    if (redir.error !== null)
-                        errors[html_path.relativePath].push(redir.error);
-                } else {
-                    errors[html_path.relativePath].push(`Link path does not exist: ${relative_path}`);
-                }
-            }
-        }
-    }
-
-    const doesFileExist = function (source_path, html_path, relative_path) {
-        // Remove explicit anchor links and _books prefix
-        relative_path = relative_path.split('#')[0].replace('_books/', '');
-        const file_path = path.join(source_path, relative_path);
-        if (!fs.existsSync(file_path) && !fs.existsSync(file_path + path.sep + 'index.htm') && !fs.existsSync(file_path + 'index.html') && !fs.existsSync(file_path + '.htm') && !fs.existsSync(file_path + '.html')) {
-            errors[html_path.relativePath].push(`Book resource does not exist: ${relative_path}`);
-            return false;
-        } else {
-            messages[html_path.relativePath].push(`Book resource exists: ${relative_path}`);
-        }
-        return true;
-    };
-
-    // Takes a dree element, returns an object with a pair of arrays
-    const getLinks = function (file) {
-        messages[file.relativePath].push('Parsing HTML file');
-        const htmlBody = fs.readFileSync(file.path, 'utf8');
-        let links = {
-            href: [],
-            img: []
-        };
-        const $ = cheerio.load(htmlBody);
-        const hrefs = $('a').map(function (i) {
-            return $(this).attr('href');
-        }).get();
-        const srcs = $('img').map(function (i) {
-            return $(this).attr('src');
-        }).get();
-        links.href.push(...hrefs);
-        links.img.push(...srcs);
-        return links;
-    };
-
-    exports.run = async function (source_path, doc_id, verbose, hdocbook_config, hdocbook_project, nav_items, prod_families, prods_supported, gen_exclude, gen_redirects) {
-        console.log(`Performing Validation and Building SEO Link List...`);
-        redirects = gen_redirects;
-
-        // Get a list of HTML files in source_path
-        dree.scan(source_path, dreeOptions, fileContentCallback);
-
-        // Check product family
-        let valid_product = false;
-        let meta_errors = [];
-        for (let i = 0; i < prod_families.products.length; i++) {
-            if (prod_families.products[i].id === hdocbook_config.productFamily) {
-                valid_product = true;
-            }
-        }
-        if (!valid_product) {
-            let val_prod_error = `Incorrect productFamily: ${hdocbook_config.productFamily}. Supported values:`;
-            for (let i = 0; i < prods_supported.length; i++) {
-                val_prod_error += `\n  - ${prods_supported[i]}`
-            }
-            meta_errors.push(val_prod_error)
-        }
-
-        if (hdocbook_config.publicSource && hdocbook_config.publicSource !== '') {
-            // Validate publicSource
-            if (hdocbook_config.publicSource.toLowerCase() === '--publicsource--') {
-                meta_errors.push(`Value for publicSource in book metadata is set to its default template value`);
-            } else {
-                // Check URL exists
-                if (!hdocbook_config.publicSource.startsWith('https://github.com') && !hdocbook_config.publicSource.startsWith('https://api.github.com')) {
-                    meta_errors.push(`Value for publicSource in book metadata is not a recognised GitHub URL: ${hdocbook_config.publicSource}`);
-                }
-            }
-        }
-
-        if (!hdocbook_config.audience || !(hdocbook_config.audience instanceof Array) || hdocbook_config.audience.length === 0) {
-            meta_errors.push(`Property audience of type array in book metadata is mandatory.`);
-        }
-        if (hdocbook_project.validation) {
-            if (hdocbook_project.validation.exclude_links && hdocbook_project.validation.exclude_links instanceof Array) {
-                hdocbook_project.validation.exclude_links.forEach(function (excl_link) {
-                    exclude_links[excl_link] = true;
-                });
-            }
-            if (hdocbook_project.validation.exclude_spellcheck && hdocbook_project.validation.exclude_spellcheck instanceof Array) {
-                hdocbook_project.validation.exclude_spellcheck.forEach(function (excl_sc) {
-                    exclude_spellcheck[excl_sc.document_path] = excl_sc.words;
-                });
-            }
-            if (hdocbook_project.validation.exclude_h1_count && hdocbook_project.validation.exclude_h1_count instanceof Array) {
-                hdocbook_project.validation.exclude_h1_count.forEach(function (excl_h1) {
-                    exclude_h1_count[excl_h1] = true;
-                });
-            }
-        }
-
-        // Check navigation spellings & paths exist
-        const nav_errors = await checkNavigation(source_path, nav_items, exclude_spellcheck);
-        if (nav_errors.length > 0) meta_errors.push(...nav_errors);
-
-        // Check inline content spellings & paths exist
-        if (hdocbook_config.inline && hdocbook_config.inline.length > 0) {
-            const inline_errors = await checkInline(source_path, hdocbook_config.inline, exclude_spellcheck);
-            if (inline_errors.length > 0) meta_errors.push(...inline_errors);
-        }
-
-        // Check redirects
-        const redirect_errors = await checkRedirects(source_path);
-        if (redirect_errors.length > 0) meta_errors.push(...redirect_errors);
-
-        if (meta_errors.length > 0) {
-            console.log('\r\n-----------------------');
-            console.log('   Validation Output   ');
-            console.log('-----------------------');
-            for (let i = 0; i < meta_errors.length; i++) {
-                console.error(`- ${meta_errors[i]}`);
-            }
-            console.error(`\r\n${meta_errors.length} Validation Errors Found`);
-            return false;
-        }
-
-
-        let excl_output = [];
-
-        // Do spellchecking on markdown files
-        let md_files_spellchecked = {};
-        let mdPromiseArray = [];
-        for (let i = 0; i < md_to_validate.length; i++) {
-            errors[md_to_validate[i].relativePath] = [];
-            messages[md_to_validate[i].relativePath] = [];
-            warnings[md_to_validate[i].relativePath] = [];
-            mdPromiseArray.push(md_to_validate[i]);
-        }
-        await Promise.all(mdPromiseArray.map(async (file) => {
-            // Initiate maps for errors and verbose messages for markdown file
-            const exclusions = await spellcheckContent(file, exclude_spellcheck);
-            if (gen_exclude && exclusions.length > 0) excl_output.push({ document_path: file.relativePath.replace('.' + file.extension, ''), words: exclusions });
-            md_files_spellchecked[file.relativePath.replace('.' + file.extension, '')] = true;
-        }));
-
-        // Perform rest of validation against HTML files
-        let listContent = '';
-        let htmlPromiseArray = [];
-        for (let i = 0; i < html_to_validate.length; i++) {
-            errors[html_to_validate[i].relativePath] = [];
-            messages[html_to_validate[i].relativePath] = [];
-            warnings[html_to_validate[i].relativePath] = [];
-            htmlPromiseArray.push(html_to_validate[i]);
-        }
-        await Promise.all(htmlPromiseArray.map(async (file) => {
-            // Check for British spellings in static HTML content
-            if (!md_files_spellchecked[file.relativePath.replace('.' + file.extension, '')]) {
-                const exclusions = await spellcheckContent(file, exclude_spellcheck);
-                if (gen_exclude && exclusions.length > 0) excl_output.push({ document_path: file.relativePath.replace('.' + file.extension, ''), words: exclusions });
-            }
-
-            const links = getLinks(file);
-            if (links.href.length === 0) {
-                messages[file.relativePath].push('No links found in file');
-            } else {
-                await checkLinks(source_path, file, links.href, hdocbook_config);
-            }
-            if (links.img.length === 0) {
-                messages[file.relativePath].push('No images found in file');
-            } else {
-                await checkImages(source_path, file, links.img);
-            }
-
-            // Check for multiple H1 tags
-            await checkTags(file);
-
-            // Build list content for Google 
-            listContent += `/${file.relativePath.replace(path.extname(file.relativePath), '')}`;
-            listContent += '\r\n';
-        }));
-
-        if (gen_exclude) console.log(JSON.stringify(excl_output, null, 2));
-
-        try {
-            // Write list
-            const listFile = path.join(source_path, doc_id, 'links.txt');
-            fs.writeFileSync(listFile, listContent);
-            console.log(`\r\nLink list text file created successfully: ${listFile}`);
-        } catch (err) {
-            console.error(err);
-        }
-
-        if (verbose) {
-            console.log('\r\n-------------');
-            console.log('   Verbose   ');
-            console.log('-------------');
-            for (const key in messages) {
-                if (messages.hasOwnProperty(key) && messages[key].length > 0) {
-                    console.log(`\r\nMessage output for ${key}`);
-                    for (let i = 0; i < messages[key].length; i++) {
-                        console.log(` - ${messages[key][i]}`);
-                    }
-                }
-            }
-        }
-
-        console.log('\r\n-----------------------');
-        console.log('   Validation Output   ');
-        console.log('-----------------------');
-        if (Object.keys(errors).length > 0) {
-            let error_count = 0;
-            for (const key in errors) {
-                if (errors.hasOwnProperty(key) && errors[key].length > 0) {
-                    console.error(`\r\n${errors[key].length} error(s) in ${key}`);
-                    for (let i = 0; i < errors[key].length; i++) {
-                        console.error(` - ${errors[key][i]}`);
-                        error_count++
-                    }
-                }
-            }
-            if (error_count > 0) {
-                console.error(`\r\n${error_count} Validation Errors Found`);
-                if (verbose) {
-                    console.log(`\n`);
-                    console.error(JSON.stringify(exclude_spellcheck_output, null, 2));
-                }
-                return false;
-            }
-        }
-
-        console.log(`\r\nNo Validation Errors Found!\n`);
-        return true;
-    };
-})();
+(() => {
+	const axios = require("axios");
+	const cheerio = require("cheerio");
+	const dree = require("dree");
+	const fs = require("node:fs");
+	const path = require("node:path");
+	const https = require("node:https");
+	const hdoc = require(path.join(__dirname, "hdoc-module.js"));
+	const translator = require("american-british-english-translator");
+	const { trueCasePathSync } = require("true-case-path");
+
+	const spellcheck_options = {
+		british: true,
+		spelling: true,
+	};
+	const regex_nav_paths = /[a-z0-9-\/]+[a-z0-9]+#{0,1}[a-z0-9-\/]+/;
+	const agent = new https.Agent({
+		rejectUnauthorized: false,
+	});
+
+	const errors = {};
+	const messages = {};
+	const warnings = {};
+	const html_to_validate = [];
+	const md_to_validate = [];
+	const exclude_links = {};
+	const exclude_spellcheck = {};
+	let redirects = {};
+	const exclude_h1_count = {};
+	const exclude_spellcheck_output = [];
+
+	const excludeLink = async (url) => {
+		if (exclude_links[url]) return true;
+
+		for (let key in exclude_links) {
+			if (key.endsWith("*")) {
+				key = key.substring(0, key.length - 1);
+				if (url.startsWith(key)) return true;
+			}
+		}
+
+		return false;
+	};
+
+	const spellcheckContent = async (sourceFile, excludes) => {
+		const spelling_errors = {};
+		const words = [];
+		const text = fs.readFileSync(sourceFile.path, "utf8");
+		const source_path = sourceFile.relativePath.replace(
+			`.${sourceFile.extension}`,
+			"",
+		);
+		const translate_output = translator.translate(text, spellcheck_options);
+		if (Object.keys(translate_output).length) {
+			for (const key in translate_output) {
+				if (Object.hasOwn(translate_output, key)) {
+					const error_message = `Line ${key} - British spelling:`;
+					for (let i = 0; i < translate_output[key].length; i++) {
+						for (const spelling in translate_output[key][i]) {
+							if (
+								Object.hasOwn(translate_output[key][i], spelling) &&
+								typeof translate_output[key][i][spelling].details === "string"
+							) {
+								if (!excludes[source_path]) {
+									errors[sourceFile.relativePath].push(
+										`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`,
+									);
+									spelling_errors[spelling] = true;
+								} else if (
+									!excludes[source_path].includes(spelling.toLowerCase())
+								) {
+									errors[sourceFile.relativePath].push(
+										`${error_message} ${spelling} should be ${translate_output[key][i][spelling].details}`,
+									);
+									spelling_errors[spelling] = true;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		if (Object.keys(spelling_errors).length) {
+			const exclude_output = {
+				document_path: sourceFile.relativePath.replace(
+					path.extname(sourceFile.relativePath),
+					"",
+				),
+				words: [],
+			};
+			for (const word in spelling_errors) {
+				if (Object.hasOwn(spelling_errors, word)) {
+					words.push(word);
+					exclude_output.words.push(word);
+				}
+			}
+			exclude_spellcheck_output.push(exclude_output);
+		}
+		return words;
+	};
+
+	const checkInline = async (source_path, inline, excludes) => {
+		const inline_errors = [];
+		for (let i = 0; i < inline.length; i++) {
+			const title = inline[i].title;
+			const link = inline[i].link;
+
+			// Validate link segment spellings
+			const paths = link.split("/");
+			for (let i = 0; i < paths.length; i++) {
+				const path_words = paths[i].split("-");
+				for (let j = 0; j < path_words.length; j++) {
+					const translate_output = translator.translate(
+						path_words[j],
+						spellcheck_options,
+					);
+					if (Object.keys(translate_output).length) {
+						for (const spell_val in translate_output) {
+							if (Object.hasOwn(translate_output, spell_val)) {
+								for (const spelling in translate_output[spell_val][0]) {
+									if (Object.hasOwn(translate_output[spell_val][0], spelling)) {
+										if (!excludes[link]) {
+											inline_errors.push(
+												`Inline Link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`,
+											);
+										} else if (
+											!excludes[link].includes(spelling.toLowerCase())
+										) {
+											inline_errors.push(
+												`Inline Link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`,
+											);
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+
+			// Validate display names
+			const translate_output = translator.translate(title, spellcheck_options);
+			if (Object.keys(translate_output).length) {
+				for (const spell_val in translate_output) {
+					if (Object.hasOwn(translate_output, spell_val)) {
+						for (let j = 0; j < translate_output[spell_val].length; j++) {
+							for (const spelling in translate_output[spell_val][j]) {
+								if (Object.hasOwn(translate_output[spell_val][j], spelling)) {
+									if (!excludes[link]) {
+										inline_errors.push(
+											`Inline title for link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`,
+										);
+									} else if (!excludes[link].includes(spelling.toLowerCase())) {
+										inline_errors.push(
+											`Inline title for link [${link}] contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`,
+										);
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+
+			// Validate path exists - link should be a html file at this point as its after the content has been built
+			let file_exists = true;
+			let file_name = path.join(source_path, `${link}.html`);
+			if (!fs.existsSync(file_name)) {
+				file_name = path.join(source_path, `${link}.htm`);
+				if (!fs.existsSync(file_name)) {
+					file_name = path.join(source_path, link, "index.html");
+					if (!fs.existsSync(file_name)) {
+						file_name = path.join(source_path, link, "index.htm");
+						if (!fs.existsSync(file_name)) {
+							file_exists = false;
+							inline_errors.push(`Inline link [${link}] file does not exist.`);
+						}
+					}
+				}
+			}
+		}
+
+		return inline_errors;
+	};
+
+	const checkNavigation = async (source_path, flat_nav, excludes, draft_links) => {
+		const nav_errors = [];
+		for (const key in flat_nav) {
+			if (Object.hasOwn(flat_nav, key)) {
+				// doc paths should only contain a-z - characters
+				const invalid_chars = key.replace(regex_nav_paths, "");
+				if (invalid_chars !== "") {
+					nav_errors.push(
+						`Navigation path [${key}] contains the following invalid characters: [${[...invalid_chars].join("] [")}]`,
+					);
+				}
+				const key_split = key.split("#");
+				const key_no_hash = key_split[0];
+
+				// See if there's a redirect in place
+				let redirected = false;
+				let redirect_errored = false;
+				const redir = checkRedirect(source_path, key_no_hash);
+
+				if (redir.exists && redir.error !== null) {
+					nav_errors.push(redir.error);
+					redirect_errored = true;
+				} else if (redir.exists && redir.error === null) {
+					redirected = true;
+				}
+
+				// Validate path exists - key should be a html file at this point
+				let file_exists = true;
+				let file_name = path.join(source_path, `${key_no_hash}.html`);
+				if (!fs.existsSync(file_name)) {
+					file_name = path.join(source_path, `${key_no_hash}.htm`);
+					if (!fs.existsSync(file_name)) {
+						file_name = path.join(source_path, key_no_hash, "index.html");
+						if (!fs.existsSync(file_name)) {
+							file_name = path.join(source_path, key_no_hash, "index.htm");
+							if (!fs.existsSync(file_name)) {
+								file_exists = false;
+								if (!redirected && !redirect_errored && draft_links.indexOf(key_no_hash) === -1)
+									nav_errors.push(
+										`Navigation path [${key_no_hash}] file does not exist.`,
+									);
+							}
+						}
+					}
+				}
+
+				if (file_exists) {
+					// File exists - but is there a redirect? If so, we want to flag this as an error
+					if (redirected)
+						nav_errors.push(
+							`Navigation path [${key_no_hash}] is redirected, but path still exists.`,
+						);
+
+					// Check file path case match
+					const true_file = trueCasePathSync(file_name)
+						.replace(source_path, "")
+						.replaceAll("\\", "/");
+					const relative_file = file_name
+						.replace(source_path, "")
+						.replaceAll("\\", "/");
+					if (true_file !== relative_file) {
+						nav_errors.push(
+							`Navigation path [${key}] for filename [${relative_file}] does not match filename case [${true_file}].`,
+						);
+					}
+				}
+
+				// Validate path spellings
+				const paths = key.split("/");
+				for (let i = 0; i < paths.length; i++) {
+					const path_words = paths[i].split("-");
+					for (let j = 0; j < path_words.length; j++) {
+						const translate_output = translator.translate(
+							path_words[j],
+							spellcheck_options,
+						);
+						if (Object.keys(translate_output).length) {
+							for (const spell_val in translate_output) {
+								if (Object.hasOwn(translate_output, spell_val)) {
+									for (const spelling in translate_output[spell_val][0]) {
+										if (
+											Object.hasOwn(translate_output[spell_val][0], spelling)
+										) {
+											if (!excludes[key]) {
+												nav_errors.push(
+													`Navigation path [${key}] key contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`,
+												);
+											} else if (
+												!excludes[key].includes(spelling.toLowerCase())
+											) {
+												nav_errors.push(
+													`Navigation path [${key}] key contains a British English spelling: ${spelling} should be ${translate_output[spell_val][0][spelling].details}`,
+												);
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+
+				// Validate display names/bookmarks
+				for (let i = 0; i < flat_nav[key].length; i++) {
+					if (flat_nav[key][i].link === key) {
+						const translate_output = translator.translate(
+							flat_nav[key][i].text,
+							spellcheck_options,
+						);
+						if (Object.keys(translate_output).length) {
+							for (const spell_val in translate_output) {
+								if (Object.hasOwn(translate_output, spell_val)) {
+									for (let j = 0; j < translate_output[spell_val].length; j++) {
+										for (const spelling in translate_output[spell_val][j]) {
+											if (
+												Object.hasOwn(translate_output[spell_val][j], spelling)
+											) {
+												if (!excludes[key]) {
+													nav_errors.push(
+														`Navigation path [${key}] display text contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`,
+													);
+												} else if (
+													!excludes[key].includes(spelling.toLowerCase())
+												) {
+													nav_errors.push(
+														`Navigation path [${key}] display text contains a British English spelling: ${spelling} should be ${translate_output[spell_val][j][spelling].details}`,
+													);
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		return nav_errors;
+	};
+
+	const checkRedirects = async (source_path) => {
+		const errors = [];
+		for (const key in redirects) {
+			if (Object.hasOwn(redirects, key)) {
+				if (
+					redirects[key].code !== 301 &&
+					redirects[key].code !== 308 &&
+					redirects[key].code !== 410
+				)
+					errors.push(`Invalid redirect code: ${redirects[key].code}`);
+
+				if (redirects[key].location) {
+					const redir_locations = [
+						path.join(source_path, `${redirects[key].location}.md`),
+						path.join(source_path, redirects[key].location, "index.md"),
+						path.join(source_path, `${redirects[key].location}.html`),
+						path.join(source_path, `${redirects[key].location}.htm`),
+						path.join(source_path, redirects[key].location, "index.html"),
+						path.join(source_path, redirects[key].location, "index.htm"),
+					];
+					let redir_location_ok = false;
+					for (let i = 0; i < redir_locations.length; i++) {
+						if (fs.existsSync(redir_locations[i])) {
+							redir_location_ok = true;
+							break;
+						}
+					}
+					if (!redir_location_ok)
+						errors.push(
+							`Redirect location does not exist: ${redirects[key].location}`,
+						);
+				}
+			}
+		}
+		return errors;
+	};
+
+	const checkRedirect = (source_path, nav_path) => {
+		const response = {
+			exists: false,
+			error: null,
+		};
+		if (redirects[nav_path]) {
+			response.exists = true;
+			if (redirects[nav_path].location) {
+				// We have a redirect, check if it's a valid location
+				let file_path = path.join(
+					source_path,
+					`${redirects[nav_path].location}.html`,
+				);
+				if (!fs.existsSync(file_path)) {
+					file_path = path.join(
+						source_path,
+						`${redirects[nav_path].location}.htm`,
+					);
+					if (!fs.existsSync(file_path)) {
+						file_path = path.join(
+							source_path,
+							redirects[nav_path].location,
+							"index.html",
+						);
+						if (!fs.existsSync(file_path)) {
+							file_path = path.join(
+								source_path,
+								redirects[nav_path].location,
+								"index.htm",
+							);
+							if (!fs.existsSync(file_path)) {
+								response.error = `Redirect path for [${nav_path}] does not exist: ${redirects[nav_path].location}`;
+							}
+						}
+					}
+				}
+			}
+		}
+		return response;
+	};
+
+	const isHashAnchor = (html_file, hash_anchor, full_hash_anchor_link = "") => {
+		try {
+			const file_content = fs.readFileSync(html_file.path, {
+				encoding: "utf-8",
+			});
+			const clean_hash_anchor = hash_anchor.startsWith("/")
+				? hash_anchor.substring(2, hash_anchor.length)
+				: hash_anchor.substring(1, hash_anchor.length);
+			if (
+				!file_content.includes(`<div id="hb-doc-anchor-${clean_hash_anchor}"`)
+			) {
+				errors[html_file.relativePath].push(
+					`Target hash anchor is not present in page content: ${full_hash_anchor_link !== "" ? full_hash_anchor_link : hash_anchor}`,
+				);
+			}
+		} catch (e) {
+			errors[html_file.relativePath].push(e);
+		}
+	};
+
+	const checkLinks = async (source_path, htmlFile, links, hdocbook_config) => {
+		for (let i = 0; i < links.length; i++) {
+			// Validate that link is a valid URL first
+			const valid_url = hdoc.valid_url(links[i]);
+			if (!valid_url) {
+				// Could be a relative path, check
+				if (links[i].startsWith("/") && !links[i].startsWith("/#")) {
+					let link_root = links[i].split("/");
+					if (link_root[0] === "") link_root.shift();
+					link_root = link_root[0] === "_books" ? link_root[1] : link_root[0];
+
+					// Checking for internal links in other books - can't easily validate those here, returning
+					if (link_root !== hdocbook_config.docId) {
+						continue;
+					}
+
+					isRelativePath(source_path, htmlFile, links[i]);
+				} else if (links[i].startsWith("#") || links[i].startsWith("/#")) {
+					//Flat Anchor - validate we have a same-file hit
+					isHashAnchor(htmlFile, links[i]);
+				} else {
+					errors[htmlFile.relativePath].push(
+						`Root relative links should start with a forward-slash: ${links[i]}`,
+					);
+				}
+			} else {
+				messages[htmlFile.relativePath].push(
+					`Link is a properly formatted external URL: ${links[i]}`,
+				);
+
+				// Skip if it's the auto-generated edit url, as these could be part of a private repo which would return a 404
+				if (
+					hdocbook_config.publicSource !== undefined &&
+					links[i] ===
+						hdoc
+							.get_github_api_path(
+								hdocbook_config.publicSource,
+								htmlFile.relativePath,
+							)
+							.edit_path.replace(path.extname(htmlFile.relativePath), ".md")
+				) {
+					continue;
+				}
+
+				if (valid_url.protocol === "mailto:") {
+					continue;
+				}
+
+				// Skip if the link is excluded in the project config
+				if (excludeLink(links[i])) {
+					messages[htmlFile.relativePath].push(
+						`Skipping link validation for: ${links[i]}`,
+					);
+					continue;
+				}
+
+				if (
+					links[i].toLowerCase().includes("docs.hornbill.com") ||
+					links[i].toLowerCase().includes("docs-internal.hornbill.com")
+				) {
+					errors[htmlFile.relativePath].push(
+						`Links to Hornbill Docs should rooted and not fully-qualified: ${links[i]}`,
+					);
+					continue;
+				}
+
+				try {
+					await axios.get(links[i], {
+						httpsAgent: agent,
+					});
+					messages[htmlFile.relativePath].push(
+						`Link is a valid external URL: ${links[i]}`,
+					);
+				} catch (e) {
+					// Handle errors
+					errors[htmlFile.relativePath].push(
+						`Link is not responding: ${links[i]} - [${e.message}]`,
+					);
+				}
+			}
+		}
+	};
+
+	const checkImages = async (source_path, htmlFile, links) => {
+		for (let i = 0; i < links.length; i++) {
+			// Validate that image is a valid URL first
+			if (!hdoc.valid_url(links[i])) {
+				// Could be a relative path, check image exists
+				doesFileExist(source_path, htmlFile, links[i]);
+			} else {
+				messages[htmlFile.relativePath].push(
+					`Image link is a properly formatted external URL: ${links[i]}`,
+				);
+				// Do a Get to the URL to see if it exists
+				try {
+					const res = await axios.get(links[i]);
+					messages[htmlFile.relativePath].push(
+						`Image link is a valid external URL: ${links[i]}`,
+					);
+				} catch (e) {
+					// Handle errors
+					errors[htmlFile.relativePath].push(
+						`Unexpected Error from external image link: ${links[i]} - ${e.message}`,
+					);
+				}
+			}
+		}
+	};
+
+	const checkTags = async (htmlFile) => {
+		// Check if file  is excluded from tag check
+		const file_no_ext = htmlFile.relativePath.replace(
+			path.extname(htmlFile.relativePath),
+			"",
+		);
+		if (exclude_h1_count[file_no_ext]) return;
+
+		// Check tags
+		const htmlBody = fs.readFileSync(htmlFile.path, "utf8");
+		const $ = cheerio.load(htmlBody);
+
+		const h1_tags = $("h1")
+			.map(function () {
+				return $(this);
+			})
+			.get();
+		if (h1_tags.length && h1_tags.length > 1) {
+			let error_msg = `${h1_tags.length} <h1> tags found in content: `;
+			for (let i = 0; i < h1_tags.length; i++) {
+				error_msg += h1_tags[i].text();
+				if (i < h1_tags.length - 1) error_msg += "; ";
+			}
+			errors[htmlFile.relativePath].push(error_msg);
+		}
+	};
+
+	const dreeOptions = {
+		descendants: true,
+		excludeEmptyDirectories: true,
+		extensions: ["htm", "html", "md"],
+		hash: false,
+		normalize: true,
+		size: false,
+		sizeInBytes: false,
+		stat: false,
+		symbolicLinks: false,
+	};
+
+	// File scan callback for content type files
+	const fileContentCallback = (element) => {
+		if (element.extension.toLowerCase() === "md") {
+			md_to_validate.push(element);
+		} else {
+			html_to_validate.push(element);
+		}
+	};
+
+	const isRelativePath = (source_path, html_path, relative_path) => {
+		const rel_path_ext = path.extname(relative_path);
+		const response = {
+			is_rel_path: false,
+			has_md_extension: rel_path_ext === ".md",
+		};
+		const supported_relpaths = [
+			`${path.sep}index.htm`,
+			`${path.sep}index.html`,
+			".htm",
+			".html",
+			".md",
+		];
+
+		// Remove explicit anchor links and _books prefix
+		const clean_relative_path = relative_path
+			.split("#")[0]
+			.replace("_books/", "");
+
+		let hash_anchor = null;
+		if (relative_path.split("#")[1])
+			hash_anchor = `#${relative_path.split("#")[1]}`;
+
+		// Make full file path
+		const file_path = path.join(source_path, clean_relative_path);
+
+		// Does path exist?
+		if (fs.existsSync(file_path)) {
+			response.is_rel_path = true;
+		} else {
+			// Path
+			for (let i = 0; i < supported_relpaths.length; i++) {
+				const html_file_path = `${file_path}${supported_relpaths[i]}`;
+				if (fs.existsSync(html_file_path)) {
+					response.is_rel_path = true;
+
+					// Check for hash anchor
+					if (hash_anchor !== null) {
+						isHashAnchor(
+							{ path: html_file_path, relativePath: html_path.relativePath },
+							hash_anchor,
+							relative_path,
+						);
+					}
+					break;
+				}
+			}
+		}
+		if (response.has_md_extension) {
+			errors[html_path.relativePath].push(
+				`Relative link contains MD extension, but should not: ${clean_relative_path}`,
+			);
+			return;
+		}
+		if (response.is_rel_path) {
+			messages[html_path.relativePath].push(
+				`Relative path exists: ${clean_relative_path}`,
+			);
+			return;
+		}
+
+		// See if there's a redirect in place
+		const relpath =
+			clean_relative_path.indexOf("/") === 0
+				? clean_relative_path.substring(1)
+				: clean_relative_path;
+		const redir = checkRedirect(source_path, relpath);
+		if (redir.exists) {
+			if (redir.error !== null)
+				errors[html_path.relativePath].push(redir.error);
+		} else {
+			errors[html_path.relativePath].push(
+				`Link path does not exist: ${clean_relative_path}`,
+			);
+		}
+	};
+
+	const doesFileExist = (source_path, html_path, relative_path) => {
+		// Remove explicit anchor links and _books prefix
+		const clean_relative_path = relative_path
+			.split("#")[0]
+			.replace("_books/", "");
+		const file_path = path.join(source_path, clean_relative_path);
+		if (
+			!fs.existsSync(file_path) &&
+			!fs.existsSync(`${file_path + path.sep}index.htm`) &&
+			!fs.existsSync(`${file_path}index.html`) &&
+			!fs.existsSync(`${file_path}.htm`) &&
+			!fs.existsSync(`${file_path}.html`)
+		) {
+			errors[html_path.relativePath].push(
+				`Book resource does not exist: ${clean_relative_path}`,
+			);
+			return false;
+		}
+		messages[html_path.relativePath].push(
+			`Book resource exists: ${clean_relative_path}`,
+		);
+		return true;
+	};
+
+	// Takes a dree element, returns an object with a pair of arrays
+	const getLinks = (file) => {
+		messages[file.relativePath].push("Parsing HTML file");
+		const htmlBody = fs.readFileSync(file.path, "utf8");
+		const links = {
+			href: [],
+			img: [],
+		};
+		const $ = cheerio.load(htmlBody);
+		const hrefs = $("a")
+			.map(function (i) {
+				return $(this).attr("href");
+			})
+			.get();
+		const srcs = $("img")
+			.map(function (i) {
+				return $(this).attr("src");
+			})
+			.get();
+		links.href.push(...hrefs);
+		links.img.push(...srcs);
+		return links;
+	};
+
+	exports.run = async (
+		source_path,
+		doc_id,
+		verbose,
+		hdocbook_config,
+		hdocbook_project,
+		nav_items,
+		prod_families,
+		prods_supported,
+		gen_exclude,
+		gen_redirects,
+		draft_links,
+	) => {
+		console.log("Performing Validation and Building SEO Link List...");
+		redirects = gen_redirects;
+
+		// Get a list of HTML files in source_path
+		dree.scan(source_path, dreeOptions, fileContentCallback);
+
+		// Check product family
+		let valid_product = false;
+		const meta_errors = [];
+		for (let i = 0; i < prod_families.products.length; i++) {
+			if (prod_families.products[i].id === hdocbook_config.productFamily) {
+				valid_product = true;
+			}
+		}
+		if (!valid_product) {
+			let val_prod_error = `Incorrect productFamily: ${hdocbook_config.productFamily}. Supported values:`;
+			for (let i = 0; i < prods_supported.length; i++) {
+				val_prod_error += `\n  - ${prods_supported[i]}`;
+			}
+			meta_errors.push(val_prod_error);
+		}
+
+		if (hdocbook_config.publicSource && hdocbook_config.publicSource !== "") {
+			// Validate publicSource
+			if (hdocbook_config.publicSource.toLowerCase() === "--publicsource--") {
+				meta_errors.push(
+					"Value for publicSource in book metadata is set to its default template value",
+				);
+			} else {
+				// Check URL exists
+				if (
+					!hdocbook_config.publicSource.startsWith("https://github.com") &&
+					!hdocbook_config.publicSource.startsWith("https://api.github.com")
+				) {
+					meta_errors.push(
+						`Value for publicSource in book metadata is not a recognised GitHub URL: ${hdocbook_config.publicSource}`,
+					);
+				}
+			}
+		}
+
+		if (
+			!hdocbook_config.audience ||
+			!Array.isArray(hdocbook_config.audience) ||
+			hdocbook_config.audience.length === 0
+		) {
+			meta_errors.push(
+				"Property audience of type array in book metadata is mandatory.",
+			);
+		}
+		if (hdocbook_project.validation) {
+			if (
+				hdocbook_project.validation.exclude_links &&
+				Array.isArray(hdocbook_project.validation.exclude_links)
+			) {
+				for (const excl_link of hdocbook_project.validation.exclude_links) {
+					exclude_links[excl_link] = true;
+				}
+			}
+			if (
+				hdocbook_project.validation.exclude_spellcheck &&
+				Array.isArray(hdocbook_project.validation.exclude_spellcheck)
+			) {
+				for (const excl_sc of hdocbook_project.validation.exclude_spellcheck) {
+					exclude_spellcheck[excl_sc.document_path] = excl_sc.words;
+				}
+			}
+			if (
+				hdocbook_project.validation.exclude_h1_count &&
+				Array.isArray(hdocbook_project.validation.exclude_h1_count)
+			) {
+				for (const excl_h1 of hdocbook_project.validation.exclude_h1_count) {
+					exclude_h1_count[excl_h1] = true;
+				}
+			}
+		}
+
+		// Check navigation spellings & paths exist
+		const nav_errors = await checkNavigation(
+			source_path,
+			nav_items,
+			exclude_spellcheck,
+			draft_links,
+		);
+		if (nav_errors.length > 0) meta_errors.push(...nav_errors);
+
+		// Check inline content spellings & paths exist
+		if (hdocbook_config.inline && hdocbook_config.inline.length > 0) {
+			const inline_errors = await checkInline(
+				source_path,
+				hdocbook_config.inline,
+				exclude_spellcheck,
+			);
+			if (inline_errors.length > 0) meta_errors.push(...inline_errors);
+		}
+
+		// Check redirects
+		const redirect_errors = await checkRedirects(source_path);
+		if (redirect_errors.length > 0) meta_errors.push(...redirect_errors);
+
+		if (meta_errors.length > 0) {
+			console.log("\r\n-----------------------");
+			console.log("   Validation Output   ");
+			console.log("-----------------------");
+			for (let i = 0; i < meta_errors.length; i++) {
+				console.error(`- ${meta_errors[i]}`);
+			}
+			console.error(`\r\n${meta_errors.length} Validation Errors Found`);
+			return false;
+		}
+
+		const excl_output = [];
+
+		// Do spellchecking on markdown files
+		const md_files_spellchecked = {};
+		const mdPromiseArray = [];
+		for (let i = 0; i < md_to_validate.length; i++) {
+			errors[md_to_validate[i].relativePath] = [];
+			messages[md_to_validate[i].relativePath] = [];
+			warnings[md_to_validate[i].relativePath] = [];
+			mdPromiseArray.push(md_to_validate[i]);
+		}
+		await Promise.all(
+			mdPromiseArray.map(async (file) => {
+				// Initiate maps for errors and verbose messages for markdown file
+				const exclusions = await spellcheckContent(file, exclude_spellcheck);
+				if (gen_exclude && exclusions.length > 0)
+					excl_output.push({
+						document_path: file.relativePath.replace(`.${file.extension}`, ""),
+						words: exclusions,
+					});
+				md_files_spellchecked[
+					file.relativePath.replace(`.${file.extension}`, "")
+				] = true;
+			}),
+		);
+
+		// Perform rest of validation against HTML files
+		let listContent = "";
+		const htmlPromiseArray = [];
+		for (let i = 0; i < html_to_validate.length; i++) {
+			errors[html_to_validate[i].relativePath] = [];
+			messages[html_to_validate[i].relativePath] = [];
+			warnings[html_to_validate[i].relativePath] = [];
+			htmlPromiseArray.push(html_to_validate[i]);
+		}
+		await Promise.all(
+			htmlPromiseArray.map(async (file) => {
+				// Check for British spellings in static HTML content
+				if (
+					!md_files_spellchecked[
+						file.relativePath.replace(`.${file.extension}`, "")
+					]
+				) {
+					const exclusions = await spellcheckContent(file, exclude_spellcheck);
+					if (gen_exclude && exclusions.length > 0)
+						excl_output.push({
+							document_path: file.relativePath.replace(
+								`.${file.extension}`,
+								"",
+							),
+							words: exclusions,
+						});
+				}
+
+				const links = getLinks(file);
+				if (links.href.length === 0) {
+					messages[file.relativePath].push("No links found in file");
+				} else {
+					await checkLinks(source_path, file, links.href, hdocbook_config);
+				}
+				if (links.img.length === 0) {
+					messages[file.relativePath].push("No images found in file");
+				} else {
+					await checkImages(source_path, file, links.img);
+				}
+
+				// Check for multiple H1 tags
+				await checkTags(file);
+
+				// Build list content for Google
+				listContent += `/${file.relativePath.replace(path.extname(file.relativePath), "")}`;
+				listContent += "\r\n";
+			}),
+		);
+
+		if (gen_exclude) console.log(JSON.stringify(excl_output, null, 2));
+
+		try {
+			// Write list
+			const listFile = path.join(source_path, doc_id, "links.txt");
+			fs.writeFileSync(listFile, listContent);
+			console.log(`\r\nLink list text file created successfully: ${listFile}`);
+		} catch (err) {
+			console.error(err);
+		}
+
+		if (verbose) {
+			console.log("\r\n-------------");
+			console.log("   Verbose   ");
+			console.log("-------------");
+			for (const key in messages) {
+				if (Object.hasOwn(messages, key) && messages[key].length > 0) {
+					console.log(`\r\nMessage output for ${key}`);
+					for (let i = 0; i < messages[key].length; i++) {
+						console.log(` - ${messages[key][i]}`);
+					}
+				}
+			}
+		}
+
+		console.log("\r\n-----------------------");
+		console.log("   Validation Output   ");
+		console.log("-----------------------");
+		if (Object.keys(errors).length > 0) {
+			let error_count = 0;
+			for (const key in errors) {
+				if (Object.hasOwn(errors, key) && errors[key].length > 0) {
+					console.error(`\r\n${errors[key].length} error(s) in ${key}`);
+					for (let i = 0; i < errors[key].length; i++) {
+						console.error(` - ${errors[key][i]}`);
+						error_count++;
+					}
+				}
+			}
+			if (error_count > 0) {
+				console.error(`\r\n${error_count} Validation Errors Found`);
+				if (verbose) {
+					console.log("\n");
+					console.error(JSON.stringify(exclude_spellcheck_output, null, 2));
+				}
+				return false;
+			}
+		}
+
+		console.log("\r\nNo Validation Errors Found!\n");
+		return true;
+	};
+})();