@abreen/tada 1.1.0 → 1.3.1

package/build/build-manifest.test.ts

@@ -0,0 +1,349 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import {
+  diffManifests,
+  hashFile,
+  walkAndHash,
+  getVersions,
+  getNextVersion,
+  generateBuildManifest,
+  loadManifest,
+  pruneOldVersions,
+  copyChangedFiles,
+} from './build-manifest';
+import type { BuildManifest, ManifestDiff } from './build-manifest';
+
+function makeManifest(files: Record<string, string>): BuildManifest {
+  return { version: 1, buildTime: '2025-01-01T00:00:00.000Z', files };
+}
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true });
+});
+
+describe('diffManifests', () => {
+  test('detects added files', () => {
+    const prev = makeManifest({ 'a.html': 'hash1' });
+    const current = makeManifest({ 'a.html': 'hash1', 'b.html': 'hash2' });
+    const diff = diffManifests(prev, current);
+    expect(diff.added).toEqual(['b.html']);
+    expect(diff.changed).toEqual([]);
+    expect(diff.removed).toEqual([]);
+  });
+
+  test('detects changed files', () => {
+    const prev = makeManifest({ 'a.html': 'hash1' });
+    const current = makeManifest({ 'a.html': 'hash2' });
+    const diff = diffManifests(prev, current);
+    expect(diff.added).toEqual([]);
+    expect(diff.changed).toEqual(['a.html']);
+    expect(diff.removed).toEqual([]);
+  });
+
+  test('detects removed files', () => {
+    const prev = makeManifest({ 'a.html': 'hash1', 'b.html': 'hash2' });
+    const current = makeManifest({ 'a.html': 'hash1' });
+    const diff = diffManifests(prev, current);
+    expect(diff.added).toEqual([]);
+    expect(diff.changed).toEqual([]);
+    expect(diff.removed).toEqual(['b.html']);
+  });
+
+  test('detects added, changed, and removed all at once', () => {
+    const prev = makeManifest({
+      'unchanged.html': 'same',
+      'changed.html': 'old',
+      'removed.html': 'gone',
+    });
+    const current = makeManifest({
+      'unchanged.html': 'same',
+      'changed.html': 'new',
+      'added.html': 'fresh',
+    });
+    const diff = diffManifests(prev, current);
+    expect(diff.added).toEqual(['added.html']);
+    expect(diff.changed).toEqual(['changed.html']);
+    expect(diff.removed).toEqual(['removed.html']);
+  });
+
+  test('returns empty arrays for identical manifests', () => {
+    const manifest = makeManifest({ 'a.html': 'hash1', 'b.css': 'hash2' });
+    const diff = diffManifests(manifest, manifest);
+    expect(diff.added).toEqual([]);
+    expect(diff.changed).toEqual([]);
+    expect(diff.removed).toEqual([]);
+  });
+
+  test('returns results in alphabetical order', () => {
+    const prev = makeManifest({
+      'z.html': 'old',
+      'removed-b.html': 'r',
+      'removed-a.html': 'r',
+    });
+    const current = makeManifest({
+      'z.html': 'new',
+      'c-added.html': 'c',
+      'a-added.html': 'a',
+    });
+    const diff = diffManifests(prev, current);
+    expect(diff.added).toEqual(['a-added.html', 'c-added.html']);
+    expect(diff.changed).toEqual(['z.html']);
+    expect(diff.removed).toEqual(['removed-a.html', 'removed-b.html']);
+  });
+});
+
+describe('hashFile', () => {
+  test('produces consistent hashes for the same content', async () => {
+    const file = path.join(tmpDir, 'test.txt');
+    fs.writeFileSync(file, 'hello world');
+    const hash1 = await hashFile(file);
+    const hash2 = await hashFile(file);
+    expect(hash1).toBe(hash2);
+  });
+
+  test('returns a 64-character hex string', async () => {
+    const file = path.join(tmpDir, 'test.txt');
+    fs.writeFileSync(file, 'content');
+    const hash = await hashFile(file);
+    expect(hash).toHaveLength(64);
+    expect(hash).toMatch(/^[0-9a-f]+$/);
+  });
+
+  test('different content produces different hashes', async () => {
+    const file1 = path.join(tmpDir, 'a.txt');
+    const file2 = path.join(tmpDir, 'b.txt');
+    fs.writeFileSync(file1, 'content one');
+    fs.writeFileSync(file2, 'content two');
+    const hash1 = await hashFile(file1);
+    const hash2 = await hashFile(file2);
+    expect(hash1).not.toBe(hash2);
+  });
+});
+
+describe('walkAndHash', () => {
+  test('returns a file map with relative paths and hashes', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<html></html>');
+    fs.writeFileSync(path.join(tmpDir, 'style.css'), 'body {}');
+    const result = await walkAndHash(tmpDir);
+    expect(Object.keys(result).sort()).toEqual(['index.html', 'style.css']);
+    for (const hash of Object.values(result)) {
+      expect(hash).toHaveLength(64);
+    }
+  });
+
+  test('excludes pagefind/ top-level directory', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<html></html>');
+    const pagefindDir = path.join(tmpDir, 'pagefind');
+    fs.mkdirSync(pagefindDir);
+    fs.writeFileSync(path.join(pagefindDir, 'pagefind.js'), 'code');
+    const result = await walkAndHash(tmpDir);
+    expect(Object.keys(result)).toEqual(['index.html']);
+    expect('pagefind/pagefind.js' in result).toBe(false);
+  });
+
+  test('returns empty object for empty directory', async () => {
+    const result = await walkAndHash(tmpDir);
+    expect(result).toEqual({});
+  });
+
+  test('uses forward slashes in keys', async () => {
+    const subDir = path.join(tmpDir, 'sub', 'nested');
+    fs.mkdirSync(subDir, { recursive: true });
+    fs.writeFileSync(path.join(subDir, 'file.html'), 'content');
+    const result = await walkAndHash(tmpDir);
+    const keys = Object.keys(result);
+    expect(keys).toEqual(['sub/nested/file.html']);
+    for (const key of keys) {
+      expect(key).not.toContain('\\');
+    }
+  });
+});
+
+describe('getVersions', () => {
+  test('returns sorted version numbers', () => {
+    fs.mkdirSync(path.join(tmpDir, 'v3'));
+    fs.mkdirSync(path.join(tmpDir, 'v1'));
+    fs.mkdirSync(path.join(tmpDir, 'v2'));
+    expect(getVersions(tmpDir)).toEqual([1, 2, 3]);
+  });
+
+  test('ignores non-version entries', () => {
+    fs.mkdirSync(path.join(tmpDir, 'v1'));
+    fs.mkdirSync(path.join(tmpDir, 'other'));
+    fs.mkdirSync(path.join(tmpDir, 'v2x'));
+    fs.writeFileSync(path.join(tmpDir, 'v3.manifest.json'), '{}');
+    expect(getVersions(tmpDir)).toEqual([1]);
+  });
+
+  test('returns empty array for nonexistent directory', () => {
+    expect(getVersions(path.join(tmpDir, 'nonexistent'))).toEqual([]);
+  });
+
+  test('returns empty array for empty directory', () => {
+    expect(getVersions(tmpDir)).toEqual([]);
+  });
+});
+
+describe('getNextVersion', () => {
+  test('returns 1 for nonexistent directory', () => {
+    expect(getNextVersion(path.join(tmpDir, 'nonexistent'))).toBe(1);
+  });
+
+  test('returns 1 for empty directory', () => {
+    expect(getNextVersion(tmpDir)).toBe(1);
+  });
+
+  test('returns highest version + 1', () => {
+    fs.mkdirSync(path.join(tmpDir, 'v1'));
+    fs.mkdirSync(path.join(tmpDir, 'v3'));
+    expect(getNextVersion(tmpDir)).toBe(4);
+  });
+});
+
+describe('generateBuildManifest', () => {
+  test('writes valid JSON with version, buildTime, and files', async () => {
+    const distDir = path.join(tmpDir, 'dist');
+    fs.mkdirSync(distDir);
+    fs.writeFileSync(path.join(distDir, 'index.html'), '<html></html>');
+
+    const manifestPath = path.join(tmpDir, 'manifest.json');
+    await generateBuildManifest(distDir, manifestPath);
+
+    const raw = fs.readFileSync(manifestPath, 'utf8');
+    const manifest = JSON.parse(raw) as BuildManifest;
+
+    expect(manifest.version).toBe(1);
+    expect(typeof manifest.buildTime).toBe('string');
+    expect(manifest.buildTime).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    expect(typeof manifest.files).toBe('object');
+    expect('index.html' in manifest.files).toBe(true);
+  });
+});
+
+describe('loadManifest', () => {
+  test('loads and parses a manifest from a file', () => {
+    const manifest = makeManifest({ 'index.html': 'abc123' });
+    const filePath = path.join(tmpDir, 'manifest.json');
+    fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2) + '\n');
+
+    const loaded = loadManifest(filePath);
+    expect(loaded).toEqual(manifest);
+  });
+
+  test('returns null for a nonexistent file', () => {
+    const result = loadManifest(path.join(tmpDir, 'missing.json'));
+    expect(result).toBeNull();
+  });
+});
+
+describe('pruneOldVersions', () => {
+  function setupVersions(versions: number[]) {
+    for (const v of versions) {
+      fs.mkdirSync(path.join(tmpDir, `v${v}`));
+      fs.writeFileSync(
+        path.join(tmpDir, `v${v}.manifest.json`),
+        JSON.stringify(makeManifest({})),
+      );
+    }
+  }
+
+  test('removes all but the latest 2 version directories', () => {
+    setupVersions([1, 2, 3]);
+    pruneOldVersions(tmpDir);
+    expect(fs.existsSync(path.join(tmpDir, 'v1'))).toBe(false);
+    expect(fs.existsSync(path.join(tmpDir, 'v2'))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, 'v3'))).toBe(true);
+  });
+
+  test('also removes manifest files for pruned versions', () => {
+    setupVersions([1, 2, 3]);
+    pruneOldVersions(tmpDir);
+    expect(fs.existsSync(path.join(tmpDir, 'v1.manifest.json'))).toBe(false);
+    expect(fs.existsSync(path.join(tmpDir, 'v2.manifest.json'))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, 'v3.manifest.json'))).toBe(true);
+  });
+
+  test('keeps all versions when there are 2 or fewer', () => {
+    setupVersions([1, 2]);
+    pruneOldVersions(tmpDir);
+    expect(fs.existsSync(path.join(tmpDir, 'v1'))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, 'v2'))).toBe(true);
+  });
+
+  test('is a no-op for a nonexistent directory', () => {
+    expect(() =>
+      pruneOldVersions(path.join(tmpDir, 'nonexistent')),
+    ).not.toThrow();
+  });
+});
+
+describe('copyChangedFiles', () => {
+  test('copies added and changed files', () => {
+    const distDir = path.join(tmpDir, 'dist');
+    const outDir = path.join(tmpDir, 'out');
+    fs.mkdirSync(distDir);
+    fs.mkdirSync(outDir);
+
+    fs.writeFileSync(path.join(distDir, 'added.html'), 'new file');
+    fs.writeFileSync(path.join(distDir, 'changed.css'), 'updated styles');
+
+    const diff: ManifestDiff = {
+      added: ['added.html'],
+      changed: ['changed.css'],
+      removed: ['old.html'],
+    };
+
+    copyChangedFiles(diff, distDir, outDir);
+
+    expect(fs.existsSync(path.join(outDir, 'added.html'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'changed.css'))).toBe(true);
+  });
+
+  test('does not copy removed files', () => {
+    const distDir = path.join(tmpDir, 'dist');
+    const outDir = path.join(tmpDir, 'out');
+    fs.mkdirSync(distDir);
+    fs.mkdirSync(outDir);
+
+    const diff: ManifestDiff = {
+      added: [],
+      changed: [],
+      removed: ['removed.html'],
+    };
+
+    copyChangedFiles(diff, distDir, outDir);
+
+    expect(fs.existsSync(path.join(outDir, 'removed.html'))).toBe(false);
+  });
+
+  test('creates nested directories as needed', () => {
+    const distDir = path.join(tmpDir, 'dist');
+    const outDir = path.join(tmpDir, 'out');
+    fs.mkdirSync(distDir);
+    fs.mkdirSync(outDir);
+
+    const nested = path.join(distDir, 'deep', 'nested');
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(path.join(nested, 'page.html'), 'content');
+
+    const diff: ManifestDiff = {
+      added: ['deep/nested/page.html'],
+      changed: [],
+      removed: [],
+    };
+
+    copyChangedFiles(diff, distDir, outDir);
+
+    expect(
+      fs.existsSync(path.join(outDir, 'deep', 'nested', 'page.html')),
+    ).toBe(true);
+  });
+});

package/build/build-manifest.ts

@@ -0,0 +1,165 @@
+import fs from 'fs';
+import path from 'path';
+
+const EXCLUDED_DIRS = new Set(['pagefind']);
+
+export interface BuildManifest {
+  version: 1;
+  buildTime: string;
+  files: Record<string, string>;
+}
+
+export interface ManifestDiff {
+  added: string[];
+  changed: string[];
+  removed: string[];
+}
+
+export function diffManifests(
+  prev: BuildManifest,
+  current: BuildManifest,
+): ManifestDiff {
+  const prevFiles = prev.files;
+  const currentFiles = current.files;
+
+  const added: string[] = [];
+  const changed: string[] = [];
+  const removed: string[] = [];
+
+  for (const key of Object.keys(currentFiles)) {
+    if (!(key in prevFiles)) {
+      added.push(key);
+    } else if (prevFiles[key] !== currentFiles[key]) {
+      changed.push(key);
+    }
+  }
+
+  for (const key of Object.keys(prevFiles)) {
+    if (!(key in currentFiles)) {
+      removed.push(key);
+    }
+  }
+
+  return {
+    added: added.sort(),
+    changed: changed.sort(),
+    removed: removed.sort(),
+  };
+}
+
+export async function hashFile(filePath: string): Promise<string> {
+  const buffer = await Bun.file(filePath).arrayBuffer();
+  const hasher = new Bun.CryptoHasher('sha256');
+  hasher.update(buffer);
+  return hasher.digest('hex');
+}
+
+export async function walkAndHash(
+  dir: string,
+): Promise<Record<string, string>> {
+  const entries = fs.readdirSync(dir, { withFileTypes: true, recursive: true });
+  const result: Record<string, string> = {};
+
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const abs = path.join(entry.parentPath, entry.name);
+    const rel = path.relative(dir, abs).split(path.sep).join(path.posix.sep);
+
+    const topLevel = rel.split('/')[0];
+    if (EXCLUDED_DIRS.has(topLevel)) {
+      continue;
+    }
+
+    result[rel] = await hashFile(abs);
+  }
+
+  return result;
+}
+
+export function getVersions(prodBaseDir: string): number[] {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(prodBaseDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const versions: number[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const match = entry.name.match(/^v(\d+)$/);
+    if (match) {
+      versions.push(parseInt(match[1], 10));
+    }
+  }
+
+  return versions.sort((a, b) => a - b);
+}
+
+export function getNextVersion(prodBaseDir: string): number {
+  const versions = getVersions(prodBaseDir);
+  if (versions.length === 0) {
+    return 1;
+  }
+  return Math.max(...versions) + 1;
+}
+
+export async function generateBuildManifest(
+  distDir: string,
+  manifestPath: string,
+): Promise<void> {
+  const files = await walkAndHash(distDir);
+  const manifest: BuildManifest = {
+    version: 1,
+    buildTime: new Date().toISOString(),
+    files,
+  };
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+}
+
+export function loadManifest(filePath: string): BuildManifest | null {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content) as BuildManifest;
+  } catch {
+    return null;
+  }
+}
+
+export function pruneOldVersions(prodBaseDir: string): number[] {
+  const versions = getVersions(prodBaseDir);
+  if (versions.length <= 2) {
+    return [];
+  }
+
+  const toRemove = versions.slice(0, versions.length - 2);
+  for (const v of toRemove) {
+    const vDir = path.join(prodBaseDir, `v${v}`);
+    fs.rmSync(vDir, { recursive: true, force: true });
+
+    const manifestFile = path.join(prodBaseDir, `v${v}.manifest.json`);
+    fs.rmSync(manifestFile, { force: true });
+  }
+
+  return toRemove;
+}
+
+export function copyChangedFiles(
+  diff: ManifestDiff,
+  distDir: string,
+  outDir: string,
+): void {
+  const filesToCopy = [...diff.added, ...diff.changed];
+  for (const rel of filesToCopy) {
+    const src = path.join(distDir, rel);
+    const dest = path.join(outDir, rel);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+  }
+}

package/build/bundle.ts

@@ -3,23 +3,23 @@ import os from 'os';
 import path from 'path';
 import _ from 'lodash';
 import * as sass from 'sass';
-import { getPackageDir, getProjectDir, getDistDir } from './utils/paths.js';
-import { deriveTheme } from './utils/derive-theme.js';
+import { getPackageDir, getProjectDir, getDistDir } from './utils/paths';
+import { deriveTheme } from './utils/derive-theme';
 import type { PluginBuilder } from 'bun';
-import type { SiteVariables } from './types.js';
+import type { SiteVariables } from './types';
 import timezones from '../src/timezone/timezones.json' with { type: 'json' };
 
 function renderThemeScss(siteVariables: SiteVariables): string {
   const templatePath = path.join(getPackageDir(), 'templates/_theme.scss');
   const template = fs.readFileSync(templatePath, 'utf-8');
-  const theme = deriveTheme(siteVariables.themeColor!);
+  const theme = deriveTheme(siteVariables.themeColor);
   const tintHue = siteVariables.tintHue ?? 20;
   const tintAmount = siteVariables.tintAmount ?? 100;
 
   const iconColor = `hsl(${tintHue}deg ${(8 * tintAmount) / 100}% 8%)`;
-  const iconColorHover = `hsl(${tintHue}deg ${(6 * tintAmount) / 100}% 60%)`;
+  const iconColorHover = `hsl(${tintHue}deg ${(6 * tintAmount) / 100}% 45%)`;
   const iconColorDark = `hsl(${tintHue}deg ${(20 * tintAmount) / 100}% 90%)`;
-  const iconColorHoverDark = `hsl(${tintHue}deg ${(6 * tintAmount) / 100}% 55%)`;
+  const iconColorHoverDark = `hsl(${tintHue}deg ${(6 * tintAmount) / 100}% 60%)`;
   const iconColorTranslucentDark = `hsl(${tintHue}deg ${(85 * tintAmount) / 100}% 90%)`;
 
   const rendered = _.template(template)({
@@ -46,16 +46,12 @@ function createDefine(
   isDev = false,
 ): Record<string, string> {
   return {
-    'window.siteVariables.base': JSON.stringify(siteVariables.base),
-    'window.siteVariables.basePath': JSON.stringify(siteVariables.basePath),
-    'window.siteVariables.titlePostfix': JSON.stringify(
-      siteVariables.titlePostfix,
-    ),
-    'window.siteVariables.defaultTimeZone': JSON.stringify(
-      siteVariables.defaultTimeZone,
-    ),
-    'window.siteVariables.timezones': JSON.stringify(timezones),
-    'window.IS_DEV': JSON.stringify(isDev),
+    __SITE_BASE__: JSON.stringify(siteVariables.base),
+    __SITE_BASE_PATH__: JSON.stringify(siteVariables.basePath),
+    __SITE_TITLE_POSTFIX__: JSON.stringify(siteVariables.titlePostfix),
+    __SITE_DEFAULT_TIMEZONE__: JSON.stringify(siteVariables.defaultTimeZone),
+    __SITE_TIMEZONES__: JSON.stringify(timezones),
+    __IS_DEV__: JSON.stringify(isDev),
   };
 }
 
@@ -77,10 +73,10 @@ function createScssPlugin(siteVariables: SiteVariables) {
 
 export async function bundle(
   siteVariables: SiteVariables,
-  { mode = 'development' }: { mode?: string } = {},
+  { mode = 'development', distDir }: { mode?: string; distDir?: string } = {},
 ): Promise<string[]> {
   const packageDir = getPackageDir();
-  const distDir = getDistDir();
+  const resolvedDistDir = distDir ?? getDistDir();
   const isDev = mode === 'development';
 
   const entrypoints = [
@@ -90,7 +86,7 @@ export async function bundle(
 
   const result = await Bun.build({
     entrypoints,
-    outdir: distDir,
+    outdir: resolvedDistDir,
     naming: '[name].bundle.[ext]',
     minify: mode === 'production',
     sourcemap: isDev ? 'inline' : 'none',
@@ -108,7 +104,10 @@ export async function bundle(
 
   // Return the output filenames for asset tag injection
   const assetFiles = result.outputs.map(output =>
-    path.relative(distDir, output.path).split(path.sep).join(path.posix.sep),
+    path
+      .relative(resolvedDistDir, output.path)
+      .split(path.sep)
+      .join(path.posix.sep),
   );
 
   return assetFiles;

package/build/code.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test, beforeAll } from 'bun:test';
-import { initHighlighter } from './utils/shiki-highlighter.js';
-import { renderCodeWithComments, extractJavaMethodToc } from './utils/code.js';
-import type { SiteVariables } from './types.js';
+import { initHighlighter } from './utils/shiki-highlighter';
+import { renderCodeWithComments, extractJavaMethodToc } from './utils/code';
+import type { SiteVariables } from './types';
 
 beforeAll(async () => {
   await initHighlighter(['java', 'text', 'plaintext']);
@@ -149,6 +149,10 @@ describe('renderCodeWithComments', () => {
       base: '',
       basePath: '/',
       internalDomains: [],
+      title: 'Test',
+      titlePostfix: ' - Test',
+      themeColor: 'steelblue',
+      defaultTimeZone: 'America/New_York',
     } as SiteVariables);
 
     expect(html).toContain('<span class="code-row">');

package/build/content-watch.ts

@@ -1,15 +1,15 @@
 import path from 'path';
-import type { SiteVariables } from './types.js';
-import { getContentDir, getBuildContentFiles } from './util.js';
+import type { SiteVariables } from './types';
+import { getContentDir, getBuildContentFiles } from './util';
 import {
   compileTemplates,
   getHtmlTemplatesDir,
   getJsonDataDir,
   JSON_DATA_FILES,
-} from './templates.js';
-import { getProjectDir } from './utils/paths.js';
-import { B } from './colors.js';
-import { makeLogger } from './log.js';
+} from './templates';
+import { getProjectDir } from './utils/paths';
+import { B } from './colors';
+import { makeLogger } from './log';
 
 const log = makeLogger(__filename);
 

package/build/copy.ts

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
-import { makeLogger } from './log.js';
-import { B } from './colors.js';
+import { makeLogger } from './log';
+import { B } from './colors';
 
 const log = makeLogger(__filename);
 

package/build/deflist-id-plugin.ts

@@ -1,5 +1,5 @@
 import type MarkdownIt from 'markdown-it';
-import textToId from './text-to-id.js';
+import textToId from './text-to-id';
 
 export default function deflistIdPlugin(md: MarkdownIt): void {
   md.core.ruler.push('deflist_id_injector', function (state) {

package/build/external-links-plugin.ts

@@ -1,7 +1,7 @@
 import type MarkdownIt from 'markdown-it';
 import type Token from 'markdown-it/lib/token.mjs';
-import { makeLogger } from './log.js';
-import type { SiteVariables } from './types.js';
+import { makeLogger } from './log';
+import type { SiteVariables } from './types';
 
 const log = makeLogger(__filename);
 

package/build/features.ts

@@ -1,4 +1,4 @@
-import type { SiteVariables } from './types.js';
+import type { SiteVariables } from './types';
 
 export function isFeatureEnabled(
   siteVariables: SiteVariables,