@abreen/tada 1.5.1 → 1.5.4

package/build/build-manifest.test.ts

@@ -1,369 +0,0 @@
-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>,
-  build: number = 1,
-): BuildManifest {
-  return { schema: 1, build, 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('excludes tada.manifest.json', async () => {
-    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<html></html>');
-    fs.writeFileSync(path.join(tmpDir, 'tada.manifest.json'), '{"schema":1}');
-    const result = await walkAndHash(tmpDir);
-    expect(Object.keys(result)).toEqual(['index.html']);
-    expect('tada.manifest.json' 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, 'some-file.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 schema, build, 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(distDir, 'tada.manifest.json');
-    await generateBuildManifest(distDir, manifestPath, 3);
-
-    const raw = fs.readFileSync(manifestPath, 'utf8');
-    const manifest = JSON.parse(raw) as BuildManifest;
-
-    expect(manifest.schema).toBe(1);
-    expect(manifest.build).toBe(3);
-    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);
-    expect('tada.manifest.json' in manifest.files).toBe(false);
-  });
-});
-
-describe('loadManifest', () => {
-  test('loads and parses a manifest from a file', () => {
-    const manifest = makeManifest({ 'index.html': 'abc123' });
-    const filePath = path.join(tmpDir, 'tada.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) {
-      const vDir = path.join(tmpDir, `v${v}`);
-      fs.mkdirSync(vDir);
-      fs.writeFileSync(
-        path.join(vDir, 'tada.manifest.json'),
-        JSON.stringify(makeManifest({}, v)),
-      );
-    }
-  }
-
-  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('removes manifests inside pruned version directories', () => {
-    setupVersions([1, 2, 3]);
-    pruneOldVersions(tmpDir);
-    expect(fs.existsSync(path.join(tmpDir, 'v1', 'tada.manifest.json'))).toBe(
-      false,
-    );
-    expect(fs.existsSync(path.join(tmpDir, 'v2', 'tada.manifest.json'))).toBe(
-      true,
-    );
-    expect(fs.existsSync(path.join(tmpDir, 'v3', 'tada.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/code.test.ts

@@ -1,272 +0,0 @@
-import { describe, expect, test, beforeAll } from 'bun:test';
-import { initHighlighter } from './utils/shiki-highlighter';
-import {
-  renderCodeWithComments,
-  extractJavaMethodToc,
-  rewriteProseLinks,
-} from './utils/code';
-import type { SiteVariables } from './types';
-
-beforeAll(async () => {
-  await initHighlighter(['java', 'text', 'plaintext']);
-});
-
-describe('extractJavaMethodToc', () => {
-  test('returns methods from a regular class', () => {
-    const toc = extractJavaMethodToc(`
-public class Foo {
-  public void foo() {}
-  public int bar(int x) { return x; }
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'method', label: 'Method', name: 'foo()', line: 3 },
-      { kind: 'method', label: 'Method', name: 'bar(x)', line: 4 },
-    ]);
-  });
-
-  test('returns top-level methods from a compact source file', () => {
-    const toc = extractJavaMethodToc(`
-void hello() {
-  System.out.println("Hello");
-}
-
-void main() {
-  hello();
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'method', label: 'Method', name: 'hello()', line: 2 },
-      { kind: 'method', label: 'Method', name: 'main()', line: 6 },
-    ]);
-  });
-
-  test('returns empty array when class has no methods or fields', () => {
-    const toc = extractJavaMethodToc(`
-public class Empty {
-}
-`);
-    expect(toc).toEqual([]);
-  });
-
-  test('returns constructor from a class', () => {
-    const toc = extractJavaMethodToc(`
-public class Point {
-  public Point(int x) {}
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'constructor', label: 'Constructor', name: 'Point(x)', line: 3 },
-    ]);
-  });
-
-  test('excludes methods on inner classes', () => {
-    const toc = extractJavaMethodToc(`
-public class Outer {
-  public void outerMethod() {}
-  static class Inner {
-    public void innerMethod() {}
-  }
-}
-`);
-    expect(toc.map(e => e.name)).toEqual(['outerMethod()']);
-  });
-
-  test('returns default method from an interface', () => {
-    const toc = extractJavaMethodToc(`
-public interface Greeter {
-  default String greet(String name) { return "Hello, " + name; }
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'method', label: 'Method', name: 'greet(name)', line: 3 },
-    ]);
-  });
-
-  test('returns fields from a class with type but not access modifier', () => {
-    const toc = extractJavaMethodToc(`
-public class Counter {
-  private int count;
-  public String label;
-}
-`);
-    expect(toc.map(e => e.name)).toEqual(['int count', 'String label']);
-  });
-
-  test('returns one entry per variable in a multi-variable declaration', () => {
-    const toc = extractJavaMethodToc(`
-public class Coords {
-  int x, y;
-}
-`);
-    expect(toc.map(e => e.name)).toEqual(['int x', 'int y']);
-  });
-
-  test('returns array type field', () => {
-    const toc = extractJavaMethodToc(`
-public class Arr {
-  int[] values;
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'field', label: 'Field', name: 'int[] values', line: 3 },
-    ]);
-  });
-
-  test('returns generic type field', () => {
-    const toc = extractJavaMethodToc(`
-public class Container {
-  List<String> items;
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'field', label: 'Field', name: 'List<String> items', line: 3 },
-    ]);
-  });
-
-  test('returns interface constant', () => {
-    const toc = extractJavaMethodToc(`
-public interface Config {
-  int TIMEOUT = 30;
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'field', label: 'Field', name: 'int TIMEOUT', line: 3 },
-    ]);
-  });
-
-  test('returns abstract interface methods (no body)', () => {
-    const toc = extractJavaMethodToc(`
-public interface Greeter {
-  String greet(String name);
-}
-`);
-    expect(toc).toEqual([
-      { kind: 'method', label: 'Method', name: 'greet(name)', line: 3 },
-    ]);
-  });
-});
-
-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"');
-    expect(html).toContain('id="L2" href="#L2"');
-    expect(html).toContain('id="L3" href="#L3"');
-    expect(html).not.toContain('id="L4" href="#L4"');
-    expect(html).toContain('<code class="shiki language-java">');
-  });
-
-  test('data-prose-source contains rewritten links when pageDirPath is provided', () => {
-    const source = '/// See [rect](./rect.py)\npublic class Foo {}\n';
-    const html = renderCodeWithComments(
-      source,
-      'java',
-      {
-        base: 'https://example.edu',
-        basePath: '/course',
-        codeLanguages: { java: 'java', py: 'python' },
-        internalDomains: [],
-        title: 'Test',
-        titlePostfix: ' - Test',
-        themeColor: 'steelblue',
-        defaultTimeZone: 'America/New_York',
-      } as SiteVariables,
-      'lectures/01',
-    );
-
-    expect(html).toContain(
-      'https://example.edu/course/lectures/01/rect.py.html',
-    );
-  });
-});
-
-describe('rewriteProseLinks', () => {
-  const siteVariables = {
-    base: 'https://example.edu',
-    basePath: '/course',
-    codeLanguages: { java: 'java', py: 'python' },
-    internalDomains: [],
-    title: 'Test',
-    titlePostfix: ' - Test',
-    themeColor: 'steelblue',
-    defaultTimeZone: 'America/New_York',
-  } as SiteVariables;
-
-  test('rewrites relative link with base + basePath', () => {
-    const lines = ['/// See [rectangle.py](./rectangle.py)'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe(
-      '/// See [rectangle.py](https://example.edu/course/lectures/01/rectangle.py.html)',
-    );
-  });
-
-  test('rewrites absolute link with base + basePath', () => {
-    const lines = ['/// See [about](/about.html)'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe(
-      '/// See [about](https://example.edu/course/about.html)',
-    );
-  });
-
-  test('leaves external links unchanged', () => {
-    const lines = ['/// See [Google](https://google.com)'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe('/// See [Google](https://google.com)');
-  });
-
-  test('leaves anchor links unchanged', () => {
-    const lines = ['/// See [section](#overview)'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe('/// See [section](#overview)');
-  });
-
-  test('applies code extension rewriting', () => {
-    const lines = ['/// See [App](./App.java)'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe(
-      '/// See [App](https://example.edu/course/lectures/01/App.java.html)',
-    );
-  });
-
-  test('handles multiple links on one line', () => {
-    const lines = ['/// See [a](./a.py) and [b](./b.java)'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe(
-      '/// See [a](https://example.edu/course/lectures/01/a.py.html) and [b](https://example.edu/course/lectures/01/b.java.html)',
-    );
-  });
-
-  test('does not rewrite non-comment lines', () => {
-    const lines = ['String s = "[link](./file.py)";'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe('String s = "[link](./file.py)";');
-  });
-
-  test('preserves query string and fragment', () => {
-    const lines = ['/// See [code](./App.java?view=1#L5)'];
-    const result = rewriteProseLinks(lines, siteVariables, 'lectures/01');
-    expect(result[0]).toBe(
-      '/// See [code](https://example.edu/course/lectures/01/App.java.html?view=1#L5)',
-    );
-  });
-
-  test('works with root basePath', () => {
-    const vars = { ...siteVariables, basePath: '/' } as SiteVariables;
-    const lines = ['/// See [rect](./rect.py)'];
-    const result = rewriteProseLinks(lines, vars, 'lectures/01');
-    expect(result[0]).toBe(
-      '/// See [rect](https://example.edu/lectures/01/rect.py.html)',
-    );
-  });
-});

package/build/colors.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { R, G, B, Y, L, P, I, Ri, Gi, Yi, Li } from './colors';
-
-describe('color tag functions', () => {
-  test('R wraps text in red', () => {
-    const result = R`hello`;
-    expect(result).toContain('hello');
-    expect(typeof result).toBe('string');
-  });
-
-  test('G wraps text in green', () => {
-    const result = G`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('B wraps text in blue', () => {
-    const result = B`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('Y wraps text in yellow', () => {
-    const result = Y`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('L wraps text in dim', () => {
-    const result = L`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('P wraps text in magenta', () => {
-    const result = P`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('I wraps text in italic bold', () => {
-    const result = I`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('Ri wraps text in inverse red', () => {
-    const result = Ri`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('Gi wraps text in inverse green', () => {
-    const result = Gi`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('Yi wraps text in inverse yellow', () => {
-    const result = Yi`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('Li wraps text in inverse dim', () => {
-    const result = Li`hello`;
-    expect(result).toContain('hello');
-  });
-
-  test('handles template interpolation', () => {
-    const name = 'world';
-    const result = R`hello ${name}`;
-    expect(result).toContain('hello world');
-  });
-});