@abreen/tada 1.0.2 → 1.2.0

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

@@ -0,0 +1,116 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import _ from 'lodash';
+import * as sass from 'sass';
+import { getPackageDir, getProjectDir, getDistDir } from './utils/paths';
+import { deriveTheme } from './utils/derive-theme';
+import type { PluginBuilder } from 'bun';
+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 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}% 45%)`;
+  const iconColorDark = `hsl(${tintHue}deg ${(20 * tintAmount) / 100}% 90%)`;
+  const iconColorHoverDark = `hsl(${tintHue}deg ${(6 * tintAmount) / 100}% 60%)`;
+  const iconColorTranslucentDark = `hsl(${tintHue}deg ${(85 * tintAmount) / 100}% 90%)`;
+
+  const rendered = _.template(template)({
+    ...theme,
+    tintHue,
+    tintAmount,
+    iconColor,
+    iconColorHover,
+    iconColorDark,
+    iconColorHoverDark,
+    iconColorTranslucentDark,
+  });
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-'));
+  const configDir = path.join(tmpDir, 'config');
+  fs.mkdirSync(configDir);
+  fs.writeFileSync(path.join(configDir, '_theme.scss'), rendered);
+
+  return tmpDir;
+}
+
+function createDefine(
+  siteVariables: SiteVariables,
+  isDev = false,
+): Record<string, string> {
+  return {
+    __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),
+  };
+}
+
+function createScssPlugin(siteVariables: SiteVariables) {
+  const themeDir = renderThemeScss(siteVariables);
+
+  return {
+    name: 'scss',
+    setup(build: PluginBuilder) {
+      build.onLoad({ filter: /\.scss$/ }, args => {
+        const result = sass.compile(args.path, {
+          loadPaths: [themeDir, getProjectDir()],
+        });
+        return { contents: result.css, loader: 'css' as const };
+      });
+    },
+  };
+}
+
+export async function bundle(
+  siteVariables: SiteVariables,
+  { mode = 'development', distDir }: { mode?: string; distDir?: string } = {},
+): Promise<string[]> {
+  const packageDir = getPackageDir();
+  const resolvedDistDir = distDir ?? getDistDir();
+  const isDev = mode === 'development';
+
+  const entrypoints = [
+    path.resolve(packageDir, 'src/index.ts'),
+    path.resolve(packageDir, 'src/critical.scss'),
+  ];
+
+  const result = await Bun.build({
+    entrypoints,
+    outdir: resolvedDistDir,
+    naming: '[name].bundle.[ext]',
+    minify: mode === 'production',
+    sourcemap: isDev ? 'inline' : 'none',
+    define: createDefine(siteVariables, isDev),
+    external: ['*.woff2'],
+    plugins: [createScssPlugin(siteVariables)],
+  });
+
+  if (!result.success) {
+    const messages = result.logs
+      .filter(log => log.level === 'error')
+      .map(log => log.message || String(log));
+    throw new Error(`Bundle failed:\n${messages.join('\n')}`);
+  }
+
+  // Return the output filenames for asset tag injection
+  const assetFiles = result.outputs.map(output =>
+    path
+      .relative(resolvedDistDir, output.path)
+      .split(path.sep)
+      .join(path.posix.sep),
+  );
+
+  return assetFiles;
+}
+
+export { renderThemeScss, createDefine };

package/{webpack/code.test.js → build/code.test.ts}

@@ -1,9 +1,7 @@
-const { describe, expect, test, beforeAll } = require('bun:test');
-const { initHighlighter } = require('./utils/shiki-highlighter');
-const {
-  renderCodeWithComments,
-  extractJavaMethodToc,
-} = require('./utils/code');
+import { describe, expect, test, beforeAll } from 'bun:test';
+import { initHighlighter } from './utils/shiki-highlighter';
+import { renderCodeWithComments, extractJavaMethodToc } from './utils/code';
+import type { SiteVariables } from './types';
 
 beforeAll(async () => {
   await initHighlighter(['java', 'text', 'plaintext']);
@@ -148,9 +146,14 @@ public interface Greeter {
 describe('renderCodeWithComments', () => {
   test('renders build-time line rows for code segments', () => {
     const html = renderCodeWithComments('alpha\n\nbeta\n', 'java', {
+      base: '',
       basePath: '/',
       internalDomains: [],
-    });
+      title: 'Test',
+      titlePostfix: ' - Test',
+      themeColor: 'steelblue',
+      defaultTimeZone: 'America/New_York',
+    } as SiteVariables);
 
     expect(html).toContain('<span class="code-row">');
     expect(html).toContain('id="L1" href="#L1"');

package/build/colors.ts

@@ -0,0 +1,25 @@
+import util from 'util';
+
+export const R = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['red'], String.raw(str, ...args));
+export const G = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['green'], String.raw(str, ...args));
+export const B = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['blue'], String.raw(str, ...args));
+export const Y = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['yellow'], String.raw(str, ...args));
+export const L = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['blackBright'], String.raw(str, ...args));
+export const P = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['magenta'], String.raw(str, ...args));
+export const I = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['italic', 'bold'], String.raw(str, ...args));
+
+export const Ri = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['inverse', 'red'], String.raw(str, ...args));
+export const Gi = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['inverse', 'green'], String.raw(str, ...args));
+export const Yi = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['inverse', 'yellow'], String.raw(str, ...args));
+export const Li = (str: TemplateStringsArray, ...args: unknown[]): string =>
+  util.styleText(['inverse', 'blackBright'], String.raw(str, ...args));