@abreen/tada 1.0.2 → 1.2.0

package/build/utils/file-types.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  getProcessedExtensions,
+  extensionIsMarkdown,
+  isLiterateJava,
+} from './file-types';
+
+describe('getProcessedExtensions', () => {
+  test('includes md, markdown, html, and custom extensions', () => {
+    expect(getProcessedExtensions(['java'])).toEqual([
+      'md',
+      'markdown',
+      'html',
+      'java',
+    ]);
+  });
+
+  test('works with empty code extensions', () => {
+    expect(getProcessedExtensions([])).toEqual(['md', 'markdown', 'html']);
+  });
+});
+
+describe('extensionIsMarkdown', () => {
+  test('returns true for .md', () => {
+    expect(extensionIsMarkdown('.md')).toBe(true);
+  });
+
+  test('returns true for .markdown', () => {
+    expect(extensionIsMarkdown('.markdown')).toBe(true);
+  });
+
+  test('returns false for .html', () => {
+    expect(extensionIsMarkdown('.html')).toBe(false);
+  });
+
+  test('returns false for .txt', () => {
+    expect(extensionIsMarkdown('.txt')).toBe(false);
+  });
+});
+
+describe('isLiterateJava', () => {
+  test('returns true for .java.md files', () => {
+    expect(isLiterateJava('Example.java.md')).toBe(true);
+  });
+
+  test('case insensitive', () => {
+    expect(isLiterateJava('Example.JAVA.MD')).toBe(true);
+  });
+
+  test('returns false for plain .md files', () => {
+    expect(isLiterateJava('readme.md')).toBe(false);
+  });
+
+  test('returns false for .java files', () => {
+    expect(isLiterateJava('Example.java')).toBe(false);
+  });
+
+  test('handles paths with directories', () => {
+    expect(isLiterateJava('/content/code/Example.java.md')).toBe(true);
+  });
+});

package/build/utils/file-types.ts

@@ -0,0 +1,13 @@
+import path from 'path';
+
+export function getProcessedExtensions(codeExtensions: string[]): string[] {
+  return ['md', 'markdown', 'html', ...codeExtensions];
+}
+
+export function extensionIsMarkdown(ext: string): boolean {
+  return ['.md', '.markdown'].includes(ext);
+}
+
+export function isLiterateJava(filePath: string): boolean {
+  return path.basename(filePath).toLowerCase().endsWith('.java.md');
+}

package/build/utils/front-matter.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from 'bun:test';
+import { parseFrontMatterAndContent, parseFrontMatter } from './front-matter';
+
+describe('parseFrontMatter', () => {
+  test('parses markdown front matter separated by blank line', () => {
+    const raw = 'title: Hello\nauthor: Alice\n\nBody content here.';
+    const result = parseFrontMatter(raw, '.md');
+    expect(result.frontMatter).toBe('title: Hello\nauthor: Alice');
+    expect(result.content).toBe('\nBody content here.');
+  });
+
+  test('handles .markdown extension', () => {
+    const raw = 'title: Test\n\nContent.';
+    const result = parseFrontMatter(raw, '.markdown');
+    expect(result.frontMatter).toBe('title: Test');
+  });
+
+  test('handles .html extension', () => {
+    const raw = 'title: Page\nlayout: full\n\n<h1>Hi</h1>';
+    const result = parseFrontMatter(raw, '.html');
+    expect(result.frontMatter).toBe('title: Page\nlayout: full');
+    expect(result.content).toBe('\n<h1>Hi</h1>');
+  });
+
+  test('returns null frontMatter for unknown extensions', () => {
+    const raw = 'title: Nope\n\nContent';
+    const result = parseFrontMatter(raw, '.txt');
+    expect(result.frontMatter).toBe(null);
+    expect(result.content).toBe(raw);
+  });
+
+  test('returns null frontMatter when content starts with blank line', () => {
+    const raw = '\nNo front matter here.';
+    const result = parseFrontMatter(raw, '.md');
+    expect(result.frontMatter).toBe(null);
+    expect(result.content).toBe(raw);
+  });
+
+  test('handles YAML multiline pipe syntax', () => {
+    const raw =
+      'title: Hello\ndescription: |\n  This is a\n  multiline value\n\nBody.';
+    const result = parseFrontMatter(raw, '.md');
+    expect(result.frontMatter).toContain('description: |');
+    expect(result.frontMatter).toContain('  This is a');
+    expect(result.frontMatter).toContain('  multiline value');
+  });
+});
+
+describe('parseFrontMatterAndContent', () => {
+  test('returns parsed pageVariables and content', () => {
+    const raw = 'title: Hello World\nauthor: Bob\n\n# Main Content';
+    const result = parseFrontMatterAndContent(raw, '.md');
+    expect(result.pageVariables.title).toBe('Hello World');
+    expect(result.pageVariables.author).toBe('Bob');
+    expect(result.content).toContain('# Main Content');
+  });
+
+  test('handles content with no front matter fields', () => {
+    const raw = '\nJust content, no front matter.';
+    const result = parseFrontMatterAndContent(raw, '.md');
+    expect(result.pageVariables).toEqual({});
+    expect(result.content).toBe(raw);
+  });
+
+  test('handles boolean and numeric front matter values', () => {
+    const raw = 'toc: true\norder: 5\n\nContent.';
+    const result = parseFrontMatterAndContent(raw, '.md');
+    expect(result.pageVariables.toc).toBe(true);
+    expect(result.pageVariables.order).toBe(5);
+  });
+
+  test('handles Windows-style line endings', () => {
+    const raw = 'title: Hello\r\n\r\nBody content.';
+    const result = parseFrontMatterAndContent(raw, '.md');
+    expect(result.pageVariables.title).toBe('Hello');
+  });
+});

package/{webpack/utils/front-matter.js → build/utils/front-matter.ts}

@@ -1,18 +1,30 @@
-const fm = require('front-matter');
-const { extensionIsMarkdown } = require('./file-types');
+import fm from 'front-matter';
+import { extensionIsMarkdown } from './file-types';
+import type { ParsedContent } from '../types';
 
-function parseFrontMatterAndContent(raw, ext) {
+interface RawParsedFrontMatter {
+  frontMatter: string | null;
+  content: string;
+}
+
+export function parseFrontMatterAndContent(
+  raw: string,
+  ext: string,
+): ParsedContent {
   const { frontMatter, content } = parseFrontMatter(raw, ext);
 
   // Add delimiters to satisfy the front-matter library
   const result = fm(`---\n${frontMatter}\n---\n`);
 
-  return { pageVariables: result.attributes, content };
+  return {
+    pageVariables: result.attributes as Record<string, unknown>,
+    content,
+  };
 }
 
-function parseFrontMatterPlainText(rawContent) {
+function parseFrontMatterPlainText(rawContent: string): RawParsedFrontMatter {
   const lines = rawContent.split(/\r?\n/);
-  const fmLines = [];
+  const fmLines: string[] = [];
   let i = 0;
 
   while (i < lines.length) {
@@ -45,7 +57,10 @@ function parseFrontMatterPlainText(rawContent) {
   };
 }
 
-function parseFrontMatter(rawContent, ext) {
+export function parseFrontMatter(
+  rawContent: string,
+  ext: string,
+): RawParsedFrontMatter {
   if (extensionIsMarkdown(ext) || ext === '.html') {
     return parseFrontMatterPlainText(rawContent);
   } else {
@@ -53,5 +68,3 @@ function parseFrontMatter(rawContent, ext) {
     return { frontMatter: null, content: rawContent };
   }
 }
-
-module.exports = { parseFrontMatter, parseFrontMatterAndContent };

package/{webpack → build}/utils/jdi-runner/LiterateRunner.java

@@ -186,7 +186,7 @@ public class LiterateRunner {
                 }
             }
         } catch (VMDisconnectedException e) {
-            // VM died unexpectedly — drain any remaining output
+            // VM died unexpectedly, drain any remaining output
             Thread.sleep(10);
             String output = drainStream(targetStdout);
             if (!output.isEmpty() && activeBlock >= 0) {

package/{webpack/utils/literate-java.js → build/utils/literate-java.ts}

@@ -1,16 +1,25 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execSync } = require('child_process');
-const { createMarkdown } = require('./markdown');
-const { makeLogger } = require('../log');
-const { parseFrontMatterAndContent } = require('./front-matter');
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { createMarkdown } from './markdown';
+import { makeLogger } from '../log';
+import { parseFrontMatterAndContent } from './front-matter';
+import type {
+  SiteVariables,
+  LiterateJavaParseResult,
+  LiterateCodeBlock,
+  LiterateRunnerEntry,
+} from '../types';
 
 const log = makeLogger(__filename);
 
 const MAIN_PATTERN = /\bvoid\s+main\s*\(/m;
 
-function parseLiterateJava(rawContent, siteVariables) {
+export function parseLiterateJava(
+  rawContent: string,
+  siteVariables: SiteVariables,
+): LiterateJavaParseResult {
   const { pageVariables, content } = parseFrontMatterAndContent(
     rawContent,
     '.md',
@@ -21,7 +30,7 @@ function parseLiterateJava(rawContent, siteVariables) {
   });
   const tokens = md.parse(content, {});
 
-  const codeBlocks = [];
+  const codeBlocks: LiterateCodeBlock[] = [];
   let javaLine = 1;
 
   for (let i = 0; i < tokens.length; i++) {
@@ -45,7 +54,7 @@ function parseLiterateJava(rawContent, siteVariables) {
   const javaSource = codeBlocks.map(b => b.content).join('');
   const visibleBlockIndices = codeBlocks
     .map((b, i) => (b.hidden ? null : i))
-    .filter(i => i !== null);
+    .filter((i): i is number => i !== null);
 
   const hiddenCount = codeBlocks.length - visibleBlockIndices.length;
   log.debug`Parsed ${codeBlocks.length} code block(s) (${hiddenCount} hidden), ${javaSource.split('\n').length} Java line(s)`;
@@ -59,16 +68,19 @@ function parseLiterateJava(rawContent, siteVariables) {
   };
 }
 
-function hasMainMethod(javaSource) {
+export function hasMainMethod(javaSource: string): boolean {
   return MAIN_PATTERN.test(javaSource);
 }
 
-function deriveClassName(filePath) {
+export function deriveClassName(filePath: string): string {
   const name = path.parse(filePath).name;
   return path.parse(name).name;
 }
 
-function compileJavaSource(javaSource, className) {
+export function compileJavaSource(
+  javaSource: string,
+  className: string,
+): string {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-literate-'));
   const javaFile = path.join(tempDir, `${className}.java`);
   fs.writeFileSync(javaFile, javaSource);
@@ -76,21 +88,24 @@ function compileJavaSource(javaSource, className) {
   log.debug`Compiling ${className}.java (${javaSource.split('\n').length} lines) in ${tempDir}`;
 
   try {
-    execSync(`javac "${className}.java"`, {
+    execFileSync('javac', [`${className}.java`], {
       cwd: tempDir,
       timeout: 30000,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-  } catch (err) {
-    const stderr = err.stderr ? err.stderr.toString() : err.message;
+  } catch (err: unknown) {
+    const execErr = err as { stderr?: Buffer; message: string };
+    const stderr = execErr.stderr ? execErr.stderr.toString() : execErr.message;
     fs.rmSync(tempDir, { recursive: true, force: true });
-    throw new Error(`Compilation failed for ${className}.java:\n${stderr}`);
+    throw new Error(`Compilation failed for ${className}.java:\n${stderr}`, {
+      cause: err,
+    });
   }
 
   return tempDir;
 }
 
-function ensureRunnerCompiled(runnerDir) {
+function ensureRunnerCompiled(runnerDir: string): void {
   const sourceFile = path.join(runnerDir, 'LiterateRunner.java');
   const classFile = path.join(runnerDir, 'LiterateRunner.class');
 
@@ -105,49 +120,64 @@ function ensureRunnerCompiled(runnerDir) {
   log.debug`Compiling LiterateRunner.java`;
 
   try {
-    execSync('javac LiterateRunner.java', {
+    execFileSync('javac', ['LiterateRunner.java'], {
       cwd: runnerDir,
       timeout: 30000,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
-  } catch (err) {
-    const stderr = err.stderr ? err.stderr.toString() : err.message;
-    throw new Error(`Failed to compile LiterateRunner.java:\n${stderr}`);
+  } catch (err: unknown) {
+    const execErr = err as { stderr?: Buffer; message: string };
+    const stderr = execErr.stderr ? execErr.stderr.toString() : execErr.message;
+    throw new Error(`Failed to compile LiterateRunner.java:\n${stderr}`, {
+      cause: err,
+    });
   }
 }
 
-function executeLiterateJava(className, classPath, codeBlocks) {
+export function executeLiterateJava(
+  className: string,
+  classPath: string,
+  codeBlocks: LiterateCodeBlock[],
+): LiterateRunnerEntry[] {
   const runnerDir = path.join(__dirname, 'jdi-runner');
   ensureRunnerCompiled(runnerDir);
 
   const blockRanges = codeBlocks.map(b => [b.javaStartLine, b.javaEndLine]);
   const rangesJson = JSON.stringify(blockRanges);
 
-  log.info`Executing literate Java: ${className}`;
+  log.debug`Executing literate Java: ${className}`;
 
   log.debug`Running LiterateRunner with ${blockRanges.length} block range(s)`;
 
   try {
-    const result = execSync(
-      `java -cp "${runnerDir}" LiterateRunner "${className}" "${classPath}" '${rangesJson}'`,
+    const result = execFileSync(
+      'java',
+      ['-cp', runnerDir, 'LiterateRunner', className, classPath, rangesJson],
       { timeout: 30000, encoding: 'utf-8' },
     );
-    const entries = JSON.parse(result);
+    const entries: LiterateRunnerEntry[] = JSON.parse(result);
     log.debug`LiterateRunner returned ${entries.length} output entries`;
     return entries;
-  } catch (err) {
-    const stderr = err.stderr ? err.stderr.toString() : '';
-    const stdout = err.stdout ? err.stdout.toString() : '';
+  } catch (err: unknown) {
+    const execErr = err as {
+      stderr?: Buffer | string;
+      stdout?: Buffer | string;
+      message: string;
+    };
+    const stderr = execErr.stderr ? execErr.stderr.toString() : '';
+    const stdout = execErr.stdout ? execErr.stdout.toString() : '';
     throw new Error(
-      `Execution failed for ${className}:\n${stderr || stdout || err.message}`,
+      `Execution failed for ${className}:\n${stderr || stdout || execErr.message}`,
+      { cause: err },
     );
   }
 }
 
-module.exports = {
-  parseLiterateJava,
-  hasMainMethod,
-  deriveClassName,
-  compileJavaSource,
-  executeLiterateJava,
-};
+export function checkJavac(): boolean {
+  try {
+    execFileSync('javac', ['-version'], { stdio: ['pipe', 'pipe', 'pipe'] });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/{webpack/utils/markdown.js → build/utils/markdown.ts}

@@ -1,9 +1,30 @@
-const MarkdownIt = require('markdown-it');
-const { convertMarkdown: curlyQuote } = require('quote-quote');
-const textToId = require('../text-to-id');
-const { getHighlighter } = require('./shiki-highlighter');
+import MarkdownIt from 'markdown-it';
+import type { Options } from 'markdown-it/lib/index.mjs';
+import type Token from 'markdown-it/lib/token.mjs';
+import type Renderer from 'markdown-it/lib/renderer.mjs';
+import { convertMarkdown as curlyQuote } from 'quote-quote';
+import markdownItAnchor from 'markdown-it-anchor';
+import markdownItFootnote from 'markdown-it-footnote';
+import markdownItDeflist from 'markdown-it-deflist';
+import markdownItContainer from 'markdown-it-container';
+import textToId from '../text-to-id';
+import { getHighlighter } from './shiki-highlighter';
+import headingSubtitlePlugin from '../heading-subtitle-plugin';
+import deflistIdPlugin from '../deflist-id-plugin';
+import externalLinksPlugin from '../external-links-plugin';
+import validateInternalLinksPlugin from '../validate-internal-links-plugin';
+import applyBasePathPlugin from '../apply-base-path-plugin';
+import { tocPlugin } from '../toc-plugin';
+import markdownItKatex from '@vscode/markdown-it-katex';
+import katex from 'katex';
+import renderA11yString from 'katex/contrib/render-a11y-string';
+import type { SiteVariables } from '../types';
 
-function capitalize(str) {
+interface CreateMarkdownOptions {
+  validatorOptions?: Record<string, unknown>;
+}
+
+function capitalize(str: string): string {
   if (str.length < 2) {
     return str;
   }
@@ -11,31 +32,35 @@ function capitalize(str) {
   return str[0].toUpperCase() + str.slice(1);
 }
 
-function createMarkdown(siteVariables, options = {}) {
+export function createMarkdown(
+  siteVariables: SiteVariables,
+  options: CreateMarkdownOptions = {},
+): MarkdownIt {
   const { validatorOptions = {} } = options;
   const markdown = new MarkdownIt({ html: true, typographer: true })
-    .use(require('../heading-subtitle-plugin'))
-    .use(require('markdown-it-anchor'), { tabIndex: false })
-    .use(require('markdown-it-footnote'))
-    .use(require('markdown-it-deflist'))
-    .use(require('../deflist-id-plugin'))
-    .use(require('../external-links-plugin'), siteVariables)
-    .use(require('../validate-internal-links-plugin'), validatorOptions)
-    .use(require('../apply-base-path-plugin'), siteVariables)
-    .use(require('../toc-plugin').tocPlugin)
-    .use(require('markdown-it-container'), 'details', {
+    .use(headingSubtitlePlugin)
+    .use(markdownItAnchor, { tabIndex: false })
+    .use(markdownItFootnote)
+    .use(markdownItDeflist)
+    .use(deflistIdPlugin)
+    .use(externalLinksPlugin, siteVariables)
+    .use(validateInternalLinksPlugin, validatorOptions)
+    .use(applyBasePathPlugin, siteVariables)
+    .use(tocPlugin)
+    .use(markdownItKatex)
+    .use(markdownItContainer, 'details', {
       marker: '<',
-      validate: function (params) {
-        return params.trim().match(/^details\s+(.*)$/);
+      validate: function (params: string) {
+        return !!params.trim().match(/^details\s+(.*)$/);
       },
 
-      render: function (tokens, idx) {
-        var m = tokens[idx].info.trim().match(/^details\s+(.*)$/);
+      render: function (tokens: Token[], idx: number) {
+        const m = tokens[idx].info.trim().match(/^details\s+(.*)$/);
 
         if (tokens[idx].nesting === 1) {
           return (
             '<details><summary>' +
-            markdown.renderInline(m[1]) +
+            markdown.renderInline(m![1]) +
             '</summary><div class="content">\n'
           );
         } else {
@@ -43,12 +68,12 @@ function createMarkdown(siteVariables, options = {}) {
         }
       },
     })
-    .use(require('markdown-it-container'), 'section', {
+    .use(markdownItContainer, 'section', {
       marker: ':',
-      validate: function (params) {
-        return params.trim().match(/^section$/);
+      validate: function (params: string) {
+        return !!params.trim().match(/^section$/);
       },
-      render: function (tokens, idx) {
+      render: function (tokens: Token[], idx: number) {
         if (tokens[idx].nesting === 1) {
           return '<section>\n';
         } else {
@@ -57,13 +82,41 @@ function createMarkdown(siteVariables, options = {}) {
       },
     });
 
-  const usedIds = new Map();
-  markdown.use(require('markdown-it-container'), 'alert', {
+  // The @vscode/markdown-it-katex plugin's renderers swallow errors thrown
+  // by katex.renderToString() and return error HTML instead of propagating
+  // the exception. Override the renderers so parse errors fail the build.
+  // The plugin's tokenizer ($ and $$ delimiter parsing) is kept.
+  // Each renderer also adds an aria-label with a screen-reader-friendly
+  // description generated by katex/contrib/render-a11y-string.
+  markdown.renderer.rules.math_inline = (tokens: Token[], idx: number) => {
+    const latex = tokens[idx].content;
+    const html = katex.renderToString(latex, { throwOnError: true });
+    const a11y = markdown.utils.escapeHtml(renderA11yString(latex));
+    return html.replace(
+      '<span class="katex">',
+      `<span class="katex" aria-label="${a11y}">`,
+    );
+  };
+  const katexBlockRenderer = (tokens: Token[], idx: number) => {
+    const latex = tokens[idx].content;
+    const html = katex.renderToString(latex, {
+      throwOnError: true,
+      displayMode: true,
+    });
+    const a11y = markdown.utils.escapeHtml(renderA11yString(latex));
+    return `<p class="katex-block" aria-label="${a11y}">` + html + `</p>\n`;
+  };
+  markdown.renderer.rules.math_block = katexBlockRenderer;
+  markdown.renderer.rules.math_inline_block = katexBlockRenderer;
+  markdown.renderer.rules.math_inline_bare_block = katexBlockRenderer;
+
+  const usedIds = new Map<string, number>();
+  markdown.use(markdownItContainer, 'alert', {
     marker: '!',
-    validate: function (params) {
-      return params.trim().match(/^(note|warning)\s*"?(.+)?"?$/);
+    validate: function (params: string) {
+      return !!params.trim().match(/^(note|warning)\s*"?(.+)?"?$/);
     },
-    render: function (tokens, idx) {
+    render: function (tokens: Token[], idx: number) {
       const matches = tokens[idx].info
         .trim()
         .match(/^(note|warning)\s*"?(.+)?"?$/);
@@ -86,7 +139,7 @@ function createMarkdown(siteVariables, options = {}) {
           const renderedTitle = markdown.utils.escapeHtml(curlyQuote(title));
           html += `<p class="title" id="${titleId}">${renderedTitle}</p>\n`;
         } else {
-          const defaultTitle = capitalize(type);
+          const defaultTitle = capitalize(type || '');
           html += `<p class="title">${defaultTitle}</p>\n`;
         }
         html += '<div class="content">\n';
@@ -97,15 +150,15 @@ function createMarkdown(siteVariables, options = {}) {
     },
   });
 
-  markdown.use(require('markdown-it-container'), 'question', {
+  markdown.use(markdownItContainer, 'question', {
     marker: '?',
-    validate: function (params) {
-      return params.trim().match(/^question\s+(.+)$/);
+    validate: function (params: string) {
+      return !!params.trim().match(/^question\s+(.+)$/);
     },
-    render: function (tokens, idx) {
+    render: function (tokens: Token[], idx: number) {
       const m = tokens[idx].info.trim().match(/^question\s+(.+)$/);
       if (tokens[idx].nesting === 1) {
-        const question = markdown.renderInline(m[1]);
+        const question = markdown.renderInline(m![1]);
         return (
           '<div class="question">' +
           '<p class="question-q"><span class="question-label">Q.</span><span>' +
@@ -130,28 +183,54 @@ function createMarkdown(siteVariables, options = {}) {
   markdown.renderer.rules.footnote_block_close = () => '</ol></div>';
 
   // Change appearance of reference
-  const caption = markdown.renderer.rules.footnote_caption;
-  markdown.renderer.rules.footnote_caption = (...args) => {
-    const str = caption(...args);
+  const caption = markdown.renderer.rules.footnote_caption!;
+  markdown.renderer.rules.footnote_caption = (
+    tokens: Token[],
+    idx: number,
+    options: Options,
+    env: unknown,
+    self: Renderer,
+  ) => {
+    const str = caption(tokens, idx, options, env, self);
     return str.slice(1, str.length - 1);
   };
 
-  const footnoteRef = markdown.renderer.rules.footnote_ref;
-  markdown.renderer.rules.footnote_ref = (...args) =>
-    footnoteRef(...args)
+  const footnoteRef = markdown.renderer.rules.footnote_ref!;
+  markdown.renderer.rules.footnote_ref = (
+    tokens: Token[],
+    idx: number,
+    options: Options,
+    env: unknown,
+    self: Renderer,
+  ) =>
+    footnoteRef(tokens, idx, options, env, self)
       .replace('<sup class="footnote-ref">', '')
       .replace('</sup>', '')
       .replace('<a href="', '<a class="footnote-ref" href="');
 
-  const footnoteAnchor = markdown.renderer.rules.footnote_anchor;
-  markdown.renderer.rules.footnote_anchor = (...args) =>
-    footnoteAnchor(...args).replace('\u21a9\uFE0E', '\u2191');
+  const footnoteAnchor = markdown.renderer.rules.footnote_anchor!;
+  markdown.renderer.rules.footnote_anchor = (
+    tokens: Token[],
+    idx: number,
+    options: Options,
+    env: unknown,
+    self: Renderer,
+  ) =>
+    footnoteAnchor(tokens, idx, options, env, self).replace(
+      '\u21a9\uFE0E',
+      '\u2191',
+    );
 
   /*
    * Customize lists (add wrapper element)
    */
-  const proxy = (tokens, idx, options, env, self) =>
-    self.renderToken(tokens, idx, options);
+  const proxy = (
+    tokens: Token[],
+    idx: number,
+    options: Options,
+    _env: unknown,
+    self: Renderer,
+  ) => self.renderToken(tokens, idx, options);
 
   const itemOpen = markdown.renderer.rules.list_item_open || proxy;
   markdown.renderer.rules.list_item_open = (
@@ -240,5 +319,3 @@ function createMarkdown(siteVariables, options = {}) {
 
   return markdown;
 }
-
-module.exports = { createMarkdown };