npm - @abreen/tada - Versions diffs - 1.0.0 - Mend

@abreen/tada 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (125) hide show

package/LICENSE +21 -0
package/README.md +290 -0
package/bin/tada.js +361 -0
package/config/authors.json +1 -0
package/config/nav.json +28 -0
package/content/index.md +19 -0
package/content/lectures/01/Pair.java.md +296 -0
package/content/lectures/01/Rectangle.java +80 -0
package/content/lectures/01/demo.py +9 -0
package/content/lectures/01/index.md +39 -0
package/content/lectures/01/lecture1.pdf +0 -0
package/content/lectures/index.md +25 -0
package/content/markdown.md +379 -0
package/content/problem_sets/index.md +6 -0
package/fonts/google-sans-code/GoogleSansCodeVariable-Italic.ttf +0 -0
package/fonts/google-sans-code/GoogleSansCodeVariable.ttf +0 -0
package/fonts/google-sans-code/LICENSE.txt +93 -0
package/fonts/inter/InterVariable-Italic.ttf +0 -0
package/fonts/inter/InterVariable.ttf +0 -0
package/fonts/inter/LICENSE.txt +92 -0
package/package.json +70 -0
package/public/avatars/alex.jpg +0 -0
package/public/test.txt +1 -0
package/src/_mixins.scss +4 -0
package/src/anchor/README.md +6 -0
package/src/anchor/index.ts +34 -0
package/src/anchor/style.scss +48 -0
package/src/code/README.md +5 -0
package/src/code/index.ts +113 -0
package/src/code/style.scss +101 -0
package/src/code.scss +54 -0
package/src/header/README.md +8 -0
package/src/header/index.ts +43 -0
package/src/header/style.scss +228 -0
package/src/index.ts +73 -0
package/src/layout.scss +144 -0
package/src/literate/style.scss +60 -0
package/src/print/README.md +4 -0
package/src/print/index.ts +32 -0
package/src/print/style.scss +82 -0
package/src/question/README.md +3 -0
package/src/question/index.ts +25 -0
package/src/question/style.scss +116 -0
package/src/search/README.md +6 -0
package/src/search/index.ts +574 -0
package/src/search/style.scss +217 -0
package/src/style.scss +815 -0
package/src/timezone/index.test.ts +100 -0
package/src/timezone/index.ts +298 -0
package/src/timezone/style.scss +16 -0
package/src/timezone/timezones.json +58 -0
package/src/toc/README.md +3 -0
package/src/toc/index.ts +322 -0
package/src/toc/style.scss +203 -0
package/src/top/README.md +4 -0
package/src/top/index.ts +75 -0
package/src/util.ts +122 -0
package/templates/_author.html +27 -0
package/templates/_bottom.html +3 -0
package/templates/_download.html +1 -0
package/templates/_heading.html +19 -0
package/templates/_nav.html +18 -0
package/templates/_theme.scss +97 -0
package/templates/_top.html +87 -0
package/templates/authors.schema.json +13 -0
package/templates/code.html +31 -0
package/templates/default.html +13 -0
package/templates/literate.html +16 -0
package/templates/nav.schema.json +27 -0
package/tsconfig.json +15 -0
package/types/dev.ts +3 -0
package/types/sass.d.ts +1 -0
package/types/site-variables.d.ts +16 -0
package/webpack/apply-base-path-plugin.js +78 -0
package/webpack/build-state.js +97 -0
package/webpack/code.test.js +162 -0
package/webpack/colors.js +15 -0
package/webpack/config.base.js +147 -0
package/webpack/config.dev.js +23 -0
package/webpack/config.prod.js +32 -0
package/webpack/content-watch-plugin.js +153 -0
package/webpack/deflist-id-plugin.js +62 -0
package/webpack/external-links-plugin.js +37 -0
package/webpack/features.js +5 -0
package/webpack/flair.json +1 -0
package/webpack/generate-content-assets-plugin.js +308 -0
package/webpack/generate-favicon-plugin.js +198 -0
package/webpack/generate-fonts-plugin.js +69 -0
package/webpack/generate-manifest-plugin.js +116 -0
package/webpack/globals.js +74 -0
package/webpack/heading-subtitle-plugin.js +80 -0
package/webpack/json-schema.js +19 -0
package/webpack/log.js +143 -0
package/webpack/markdown-plugins.test.js +203 -0
package/webpack/pagefind-plugin.js +379 -0
package/webpack/pagefind-plugin.test.js +131 -0
package/webpack/pdf-text.js +163 -0
package/webpack/print-flair-plugin.js +22 -0
package/webpack/reachability.js +273 -0
package/webpack/reachability.test.js +80 -0
package/webpack/serve.js +104 -0
package/webpack/site-variables.js +53 -0
package/webpack/site.schema.json +67 -0
package/webpack/templates.js +128 -0
package/webpack/text-to-id.js +8 -0
package/webpack/toc-plugin.js +167 -0
package/webpack/util.js +49 -0
package/webpack/utils/code.js +439 -0
package/webpack/utils/content-files.js +147 -0
package/webpack/utils/define-plugin.js +20 -0
package/webpack/utils/file-types.js +26 -0
package/webpack/utils/front-matter.js +57 -0
package/webpack/utils/jdi-runner/LiterateRunner.class +0 -0
package/webpack/utils/jdi-runner/LiterateRunner.java +241 -0
package/webpack/utils/literate-java.js +153 -0
package/webpack/utils/markdown.js +244 -0
package/webpack/utils/parse-hsl.js +8 -0
package/webpack/utils/paths.js +58 -0
package/webpack/utils/render.js +466 -0
package/webpack/utils/shiki-highlighter.js +26 -0
package/webpack/validate-internal-links-plugin.js +155 -0
package/webpack/watch-reachability-state.js +273 -0
package/webpack/watch-reachability-state.test.js +198 -0
package/webpack/watch-reload-client.js +54 -0
package/webpack/watch.js +166 -0

package/webpack/utils/render.js ADDED Viewed

@@ -0,0 +1,466 @@
+const fs = require('fs');
+const path = require('path');
+const _ = require('lodash');
+const { stripHtml } = require('string-strip-html');
+const { makeLogger } = require('../log');
+const { B } = require('../colors');
+const createGlobals = require('../globals');
+const { render, json } = require('../templates');
+const {
+  extractJavaMethodToc,
+  renderCodeSegment,
+  renderCodeWithComments,
+} = require('./code');
+const { extensionIsMarkdown } = require('./file-types');
+const { createApplyBasePath, normalizeOutputPath } = require('./paths');
+const { parseFrontMatterAndContent } = require('./front-matter');
+const { createMarkdown } = require('./markdown');
+const { generateTocHtml, generateCodeTocHtml } = require('../toc-plugin');
+const {
+  parseLiterateJava,
+  hasMainMethod,
+  deriveClassName,
+  compileJavaSource,
+  executeLiterateJava,
+} = require('./literate-java');
+const log = makeLogger(__filename);
+const REQUIRED_FRONT_MATTER_FIELDS = ['title'];
+function resolveAuthor(pageVariables, filePath) {
+  if (!pageVariables.author) {
+    return;
+  }
+  const authors = json('authors.json');
+  const authorKey = pageVariables.author;
+  const authorEntry = authors[authorKey];
+  if (!authorEntry) {
+    throw new Error(
+      `${filePath}: unknown author "${authorKey}" (not found in authors.json)`,
+    );
+  }
+  pageVariables.author = authorEntry;
+}
+function validateFrontMatter(pageVariables, filePath) {
+  let valid = true;
+  for (const field of REQUIRED_FRONT_MATTER_FIELDS) {
+    if (!pageVariables[field]) {
+      log.error`${filePath}: missing required front matter field: "${field}"`;
+      valid = false;
+    }
+  }
+  return valid;
+}
+function createTemplateParameters({
+  pageVariables,
+  siteVariables,
+  content,
+  applyBasePath,
+  subPath,
+}) {
+  return {
+    ...(siteVariables.vars || {}),
+    ...createGlobals(pageVariables, siteVariables, subPath),
+    site: siteVariables,
+    base: siteVariables.base,
+    basePath: siteVariables.basePath,
+    page: pageVariables,
+    content,
+    applyBasePath,
+  };
+}
+function injectWebpackAssets(html, compilation, applyBasePath) {
+  const assets = compilation.getAssets();
+  const jsAssets = assets
+    .filter(asset => asset.name.endsWith('.js'))
+    .map(asset => asset.name);
+  const cssAssets = assets
+    .filter(asset => asset.name.endsWith('.css'))
+    .map(asset => asset.name);
+  const scriptTags = jsAssets
+    .map(asset => `<script defer src="${applyBasePath('/' + asset)}"></script>`)
+    .join('');
+  const linkTags = cssAssets
+    .map(
+      asset => `<link href="${applyBasePath('/' + asset)}" rel="stylesheet">`,
+    )
+    .join('');
+  return html
+    .replace('<head>', `<head>${linkTags}`)
+    .replace('</head>', `${scriptTags}</head>`);
+}
+function toContentAssetPath(contentDir, filePath) {
+  return path
+    .relative(contentDir, filePath)
+    .split(path.sep)
+    .join(path.posix.sep);
+}
+function renderPlainTextPageAsset({
+  filePath,
+  contentDir,
+  siteVariables,
+  validInternalTargets,
+  compilation,
+}) {
+  const { dir, name, ext } = path.parse(filePath);
+  const subPath = path.relative(contentDir, path.join(dir, name));
+  const applyBasePath = createApplyBasePath(siteVariables);
+  log.info`Rendering page ${B`${subPath + ext}`}`;
+  const { content, pageVariables, tocItems } = renderPlainTextContent(
+    filePath,
+    subPath,
+    siteVariables,
+    applyBasePath,
+    validInternalTargets,
+    { validateInternalLinks: extensionIsMarkdown(ext.toLowerCase()) },
+  );
+  if (!validateFrontMatter(pageVariables, filePath)) {
+    return [];
+  }
+  if (!pageVariables.template) {
+    pageVariables.template = 'default';
+  }
+  if (pageVariables.toc && tocItems) {
+    pageVariables.tocHtml = generateTocHtml(tocItems);
+  }
+  const templateParameters = createTemplateParameters({
+    pageVariables,
+    siteVariables,
+    content,
+    applyBasePath,
+    subPath,
+  });
+  const html = injectWebpackAssets(
+    render(`${pageVariables.template}.html`, templateParameters),
+    compilation,
+    applyBasePath,
+  );
+  return [
+    {
+      assetPath: toContentAssetPath(contentDir, path.join(dir, `${name}.html`)),
+      content: html,
+    },
+  ];
+}
+function renderCodePageAsset({
+  filePath,
+  contentDir,
+  siteVariables,
+  compilation,
+}) {
+  const { dir, name, ext } = path.parse(filePath);
+  const subPath = path.relative(contentDir, path.join(dir, name));
+  const applyBasePath = createApplyBasePath(siteVariables);
+  const lang = siteVariables.codeLanguages[ext.slice(1).toLowerCase()];
+  const sourceCode = fs.readFileSync(filePath, 'utf-8');
+  log.info`Rendering code page ${B`${subPath + ext}`}`;
+  const content = renderCodeWithComments(sourceCode, lang, siteVariables);
+  const codeFilePath = applyBasePath(
+    normalizeOutputPath(`/${toContentAssetPath(contentDir, filePath)}`),
+  );
+  const titleHtml = `<tt>${name + ext}</tt>`;
+  const tocItems = lang === 'java' ? extractJavaMethodToc(sourceCode) : [];
+  const tocHtml = generateCodeTocHtml(tocItems);
+  const pageVariables = {
+    template: 'code',
+    filePath,
+    title: `${name}${ext}`,
+    titleHtml,
+    codeFilePath,
+    downloadName: `${name}${ext}`,
+    tocItems,
+    tocHtml,
+  };
+  const templateParameters = createTemplateParameters({
+    pageVariables,
+    siteVariables,
+    content,
+    applyBasePath,
+    subPath,
+  });
+  const html = injectWebpackAssets(
+    render('code.html', templateParameters),
+    compilation,
+    applyBasePath,
+  );
+  return [
+    {
+      assetPath: toContentAssetPath(contentDir, path.join(dir, `${name}.html`)),
+      content: html,
+    },
+  ];
+}
+function renderCopiedContentAsset({ filePath, contentDir }) {
+  const ext = path.extname(filePath).toLowerCase();
+  const label = ext === '.pdf' ? 'Copying' : 'Copying source file';
+  const relPath = toContentAssetPath(contentDir, filePath);
+  log.info`${label} ${B`${relPath}`}`;
+  return [{ assetPath: relPath, content: fs.readFileSync(filePath) }];
+}
+/** Parses the file, renders using template, returns HTML & params used to generate page */
+function renderPlainTextContent(
+  filePath,
+  subPath,
+  siteVariables,
+  applyBasePath,
+  validInternalTargets,
+  { validateInternalLinks = true } = {},
+) {
+  const sourceUrlPath = `/${subPath}.html`;
+  const md = createMarkdown(siteVariables, {
+    validatorOptions: {
+      enabled: validateInternalLinks,
+      filePath,
+      sourceUrlPath,
+      validTargets: validInternalTargets,
+      codeExtensions:
+        siteVariables.features?.code === false
+          ? []
+          : Object.keys(siteVariables.codeLanguages),
+    },
+  });
+  const ext = path.extname(filePath);
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const { pageVariables, content } = parseFrontMatterAndContent(raw, ext);
+  // Handle substitutions inside front matter using siteVariables
+  const siteOnlyParams = createTemplateParameters({
+    pageVariables: {},
+    siteVariables,
+    content: null,
+    applyBasePath,
+    subPath,
+  });
+  const pageVariablesProcessed = Object.entries(pageVariables)
+    .map(([k, v]) => {
+      const newValue =
+        typeof v === 'string' ? _.template(v)(siteOnlyParams) : v;
+      return [k, newValue];
+    })
+    .reduce((acc, [k, v]) => {
+      acc[k] = v;
+      return acc;
+    }, {});
+  // Render title and description as inline Markdown
+  if (pageVariablesProcessed.title) {
+    const titleHtml = md.renderInline(pageVariablesProcessed.title);
+    pageVariablesProcessed.titleHtml = titleHtml;
+    pageVariablesProcessed.title = stripHtml(titleHtml).result;
+  }
+  if (pageVariablesProcessed.description) {
+    const descriptionHtml = md.renderInline(pageVariablesProcessed.description);
+    pageVariablesProcessed.descriptionHtml = descriptionHtml;
+    pageVariablesProcessed.description = stripHtml(descriptionHtml).result;
+  }
+  resolveAuthor(pageVariablesProcessed, filePath);
+  const strippedContent = stripHtmlComments(content);
+  const params = createTemplateParameters({
+    pageVariables: pageVariablesProcessed,
+    siteVariables,
+    content: strippedContent,
+    applyBasePath,
+    subPath,
+  });
+  let html = null;
+  try {
+    html = _.template(strippedContent)(params);
+  } catch (err) {
+    throw new Error(
+      `${filePath}: Lodash template error in page or template: ${err.message}`,
+    );
+  }
+  let tocItems = null;
+  if (extensionIsMarkdown(ext)) {
+    const env = {};
+    html = md.render(html, env);
+    tocItems = env.tocItems || null;
+  }
+  return { content: html, pageVariables: params.page, tocItems };
+}
+function stripHtmlComments(str) {
+  return str.replace(/<!---[\s\S]*?-->/g, '');
+}
+function renderLiterateJavaPageAsset({
+  filePath,
+  contentDir,
+  siteVariables,
+  compilation,
+}) {
+  const { dir, name } = path.parse(filePath);
+  const className = deriveClassName(filePath);
+  const subPath = path.relative(contentDir, path.join(dir, className));
+  const applyBasePath = createApplyBasePath(siteVariables);
+  log.info`Rendering literate Java page ${B`${name}`}`;
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const {
+    pageVariables,
+    content,
+    javaSource,
+    codeBlocks,
+    visibleBlockIndices,
+  } = parseLiterateJava(raw, siteVariables);
+  if (!validateFrontMatter(pageVariables, filePath)) {
+    return [];
+  }
+  // Compile the concatenated Java source
+  let tempDir;
+  let blockOutputMap = null;
+  try {
+    tempDir = compileJavaSource(javaSource, className);
+    // Execute if there is a main() method
+    if (hasMainMethod(javaSource)) {
+      const outputEntries = executeLiterateJava(className, tempDir, codeBlocks);
+      blockOutputMap = new Map(outputEntries);
+    }
+  } finally {
+    if (tempDir) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+  // Render full markdown with a custom fence rule that replaces fences
+  // with Shiki-highlighted code blocks and optional JDI output columns
+  const md = createMarkdown(siteVariables, {
+    validatorOptions: { enabled: false },
+  });
+  let fenceIndex = 0;
+  md.renderer.rules.fence = (tokens, idx) => {
+    const token = tokens[idx];
+    const code = token.content;
+    const lines = code.endsWith('\n')
+      ? code.slice(0, -1).split('\n')
+      : code.split('\n');
+    // Dedent: strip common leading whitespace for display
+    const minIndent = lines.reduce((min, line) => {
+      if (line.trim().length === 0) {
+        return min;
+      }
+      const indent = line.match(/^(\s*)/)[1].length;
+      return Math.min(min, indent);
+    }, Infinity);
+    const dedented =
+      minIndent > 0 && minIndent < Infinity
+        ? lines.map(l => l.slice(minIndent))
+        : lines;
+    const blockIdx = visibleBlockIndices[fenceIndex++];
+    const startLine = codeBlocks[blockIdx].javaStartLine;
+    const codeHtml = renderCodeSegment(dedented, startLine, 'java');
+    const output =
+      blockOutputMap && blockOutputMap.has(blockIdx)
+        ? blockOutputMap.get(blockIdx)
+        : null;
+    if (output) {
+      const escapedOutput = output
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+      return `<div class="literate-code-output">${codeHtml}<pre>${escapedOutput}</pre></div>`;
+    }
+    return codeHtml;
+  };
+  const env = {};
+  const contentHtml = md.render(content, env);
+  // Build page variables
+  const javaFileName = `${className}.java`;
+  const codeFilePath = applyBasePath(
+    normalizeOutputPath(
+      `/${toContentAssetPath(contentDir, path.join(dir, javaFileName))}`,
+    ),
+  );
+  const titleHtml = md.renderInline(pageVariables.title);
+  pageVariables.titleHtml = titleHtml;
+  pageVariables.title = stripHtml(titleHtml).result;
+  pageVariables.template = 'literate';
+  pageVariables.codeFilePath = codeFilePath;
+  pageVariables.downloadName = javaFileName;
+  if (pageVariables.toc && env.tocItems) {
+    pageVariables.tocHtml = generateTocHtml(env.tocItems);
+  }
+  resolveAuthor(pageVariables, filePath);
+  const templateParameters = createTemplateParameters({
+    pageVariables,
+    siteVariables,
+    content: contentHtml,
+    applyBasePath,
+    subPath,
+  });
+  const html = injectWebpackAssets(
+    render('literate.html', templateParameters),
+    compilation,
+    applyBasePath,
+  );
+  return [
+    {
+      assetPath: toContentAssetPath(
+        contentDir,
+        path.join(dir, `${className}.html`),
+      ),
+      content: html,
+    },
+    {
+      assetPath: toContentAssetPath(contentDir, path.join(dir, javaFileName)),
+      content: javaSource,
+    },
+  ];
+}
+module.exports = {
+  injectWebpackAssets,
+  renderCodePageAsset,
+  renderCopiedContentAsset,
+  renderLiterateJavaPageAsset,
+  renderPlainTextPageAsset,
+};

package/webpack/utils/shiki-highlighter.js ADDED Viewed

@@ -0,0 +1,26 @@
+const { makeLogger } = require('../log');
+const log = makeLogger(__filename);
+let highlighter = null;
+async function initHighlighter(langs) {
+  if (highlighter) {
+    return;
+  }
+  log.info`Initializing syntax highlighter`;
+  const { createHighlighter } = await import('shiki');
+  highlighter = await createHighlighter({
+    themes: ['github-light', 'github-dark'],
+    langs,
+  });
+}
+function getHighlighter() {
+  if (!highlighter) {
+    throw new Error('Shiki highlighter not initialized');
+  }
+  return highlighter;
+}
+module.exports = { initHighlighter, getHighlighter };

package/webpack/validate-internal-links-plugin.js ADDED Viewed

@@ -0,0 +1,155 @@
+const path = require('path');
+const { makeLogger } = require('./log');
+const log = makeLogger(__filename);
+function stripQueryAndHash(href) {
+  return href.split('#')[0].split('?')[0];
+}
+function isExternalOrAnchor(href) {
+  if (!href || href.startsWith('#') || href.startsWith('//')) {
+    return true;
+  }
+  return /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(href);
+}
+function normalizePathname(pathname) {
+  const normalized = path.posix.normalize(pathname);
+  if (normalized === '.') {
+    return '/';
+  }
+  return normalized.startsWith('/') ? normalized : `/${normalized}`;
+}
+function createCodeExtPattern(codeExtensions) {
+  const escaped = codeExtensions.map(ext =>
+    ext.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+  );
+  if (escaped.length === 0) {
+    return null;
+  }
+  return new RegExp(`\\.(${escaped.join('|')})$`, 'i');
+}
+function rewriteCodeLink(pathname, codeExtPattern) {
+  if (!codeExtPattern) {
+    return pathname;
+  }
+  return pathname.replace(codeExtPattern, '.html');
+}
+function resolveLinkPath(sourceUrlPath, rawHref, codeExtPattern) {
+  const hrefPath = stripQueryAndHash(rawHref.trim());
+  if (!hrefPath) {
+    return null;
+  }
+  const sourceDir = path.posix.dirname(sourceUrlPath);
+  const resolved = hrefPath.startsWith('/')
+    ? normalizePathname(hrefPath)
+    : normalizePathname(path.posix.join(sourceDir, hrefPath));
+  return rewriteCodeLink(resolved, codeExtPattern);
+}
+function getDirectoryIndexPath(pathname) {
+  return normalizePathname(path.posix.join(pathname, 'index.html'));
+}
+module.exports = function validateInternalLinks(md, options = {}) {
+  const {
+    enabled = true,
+    filePath,
+    sourceUrlPath,
+    validTargets,
+    codeExtensions = [],
+  } = options;
+  if (!enabled) {
+    return;
+  }
+  if (!filePath || !sourceUrlPath || !(validTargets instanceof Set)) {
+    throw new Error(
+      'validate-internal-links-plugin requires filePath, sourceUrlPath, and validTargets',
+    );
+  }
+  const codeExtPattern = createCodeExtPattern(codeExtensions);
+  const seenErrors = new Set();
+  function reportBrokenLink(rawHref, resolvedPath) {
+    const key = `${rawHref}|${resolvedPath}`;
+    if (seenErrors.has(key)) {
+      return;
+    }
+    seenErrors.add(key);
+    log.error`${filePath}: broken internal link: "${rawHref}" (resolved to "${resolvedPath}")`;
+  }
+  function reportDirectoryLink(rawHref, resolvedPath, indexPath) {
+    const key = `${rawHref}|${resolvedPath}|directory`;
+    if (seenErrors.has(key)) {
+      return;
+    }
+    seenErrors.add(key);
+    log.error`${filePath}: directory link must reference index.html explicitly: "${rawHref}" (resolved to "${resolvedPath}", expected "${indexPath}")`;
+  }
+  function validateHref(rawHref) {
+    if (!rawHref) {
+      return;
+    }
+    const href = rawHref.trim();
+    if (!href || isExternalOrAnchor(href)) {
+      return;
+    }
+    const resolvedPath = resolveLinkPath(sourceUrlPath, href, codeExtPattern);
+    if (!resolvedPath) {
+      return;
+    }
+    const directoryIndexPath = getDirectoryIndexPath(resolvedPath);
+    if (
+      directoryIndexPath !== resolvedPath &&
+      validTargets.has(directoryIndexPath)
+    ) {
+      reportDirectoryLink(rawHref, resolvedPath, directoryIndexPath);
+      return;
+    }
+    if (!validTargets.has(resolvedPath)) {
+      reportBrokenLink(rawHref, resolvedPath);
+    }
+  }
+  function validateToken(token) {
+    if (token.type === 'link_open') {
+      validateHref(token.attrGet('href'));
+    } else if (token.type === 'html_block' || token.type === 'html_inline') {
+      token.content.replace(/<a\b[^>]*\bhref\s*=\s*"([^"]+)"/gi, (_, href) => {
+        validateHref(href);
+        return _;
+      });
+    }
+    token.children?.forEach(validateToken);
+  }
+  md.core.ruler.push('validate_internal_links', state => {
+    state.tokens.forEach(validateToken);
+    if (seenErrors.size > 0) {
+      throw new Error(
+        `${filePath}: found ${seenErrors.size} broken internal link(s)`,
+      );
+    }
+  });
+};