njsparser 0.1.0 → 0.2.0

package/tests/parser/types.test.js

@@ -0,0 +1,243 @@
+import { test, expect } from 'bun:test';
+import {
+  Element,
+  HintPreload,
+  Module,
+  Text,
+  Data,
+  EmptyData,
+  SpecialData,
+  HTMLElement,
+  DataContainer,
+  DataParent,
+  URLQuery,
+  RSCPayload,
+  Error as FlightError,
+  isFlightDataObj,
+  resolveType,
+  T
+} from '../../parser/types.js';
+
+test('Element constructor', () => {
+  const el = new Element('test', 'TestClass', 5);
+  expect(el.value).toBe('test');
+  expect(el.value_class).toBe('TestClass');
+  expect(el.index).toBe(5);
+});
+
+test('HintPreload with font', () => {
+  const hl = new HintPreload(
+    ['/_next/static/media/font.woff2', 'font', { crossOrigin: '', type: 'font/woff2' }],
+    'HL',
+    1
+  );
+  expect(hl.href).toBe('/_next/static/media/font.woff2');
+  expect(hl.type_name).toBe('font');
+  expect(hl.attrs).toEqual({ crossOrigin: '', type: 'font/woff2' });
+});
+
+test('HintPreload with style (no attrs)', () => {
+  const hl = new HintPreload(
+    ['/_next/static/css/style.css', 'style'],
+    'HL',
+    2
+  );
+  expect(hl.href).toBe('/_next/static/css/style.css');
+  expect(hl.type_name).toBe('style');
+  expect(hl.attrs).toBeNull();
+});
+
+test('Module with array format', () => {
+  const mod = new Module(
+    [30777, ['71523', 'static/chunks/chunk1.js', '10411', 'static/chunks/chunk2.js'], 'default'],
+    'I',
+    3
+  );
+  expect(mod.module_id).toBe(30777);
+  expect(mod.module_name).toBe('default');
+  expect(mod.module_chunks_raw()).toEqual({
+    '71523': 'static/chunks/chunk1.js',
+    '10411': 'static/chunks/chunk2.js'
+  });
+  expect(mod.module_chunks['71523']).toBe('/_next/static/chunks/chunk1.js');
+  expect(mod.is_async).toBe(false);
+});
+
+test('Module with object format', () => {
+  const mod = new Module(
+    { id: '123', chunks: ['71523:static/chunks/chunk1.js'], name: 'test', async: true },
+    'I',
+    4
+  );
+  expect(mod.module_id).toBe(123);
+  expect(mod.module_name).toBe('test');
+  expect(mod.is_async).toBe(true);
+});
+
+test('Text element', () => {
+  const txt = new Text('hello world', 'T', 5);
+  expect(txt.text).toBe('hello world');
+  expect(txt.value).toBe('hello world');
+});
+
+test('Data with content', () => {
+  const data = new Data(['$', '$L1', null, { user: 'test' }], null, 6);
+  expect(data.content).toEqual({ user: 'test' });
+});
+
+test('Data with null content', () => {
+  const data = new Data(['$', '$L1', null, null], null, 7);
+  expect(data.content).toBeNull();
+});
+
+test('EmptyData', () => {
+  const empty = new EmptyData(null, null, 8);
+  expect(empty.value).toBeNull();
+});
+
+test('SpecialData', () => {
+  const special = new SpecialData('$Sreact.suspense', null, 9);
+  expect(special.value).toBe('$Sreact.suspense');
+});
+
+test('HTMLElement', () => {
+  const html = new HTMLElement(
+    ['$', 'link', 'https://example.com', { rel: 'dns-prefetch', href: 'https://example.com' }],
+    null,
+    10
+  );
+  expect(html.tag).toBe('link');
+  expect(html.href).toBe('https://example.com');
+  expect(html.attrs).toEqual({ rel: 'dns-prefetch', href: 'https://example.com' });
+});
+
+test('DataContainer resolves children', () => {
+  const container = new DataContainer(
+    [
+      ['$', 'div', null, {}],
+      ['$', 'span', null, { class: 'test' }]
+    ],
+    null,
+    11
+  );
+  expect(container.value).toHaveLength(2);
+  expect(container.value[0]).toBeInstanceOf(HTMLElement);
+  expect(container.value[1]).toBeInstanceOf(HTMLElement);
+});
+
+test('DataParent resolves children', () => {
+  const parent = new DataParent(
+    ['$', '$L16', null, { children: ['$', '$L17', null, { profile: {} }] }],
+    null,
+    12
+  );
+  expect(parent.children).toBeInstanceOf(Data);
+  expect(parent.children.content).toEqual({ profile: {} });
+});
+
+test('URLQuery', () => {
+  const query = new URLQuery(['userId', '624dc255c12744f2fdaf90c8', 'd'], null, 13);
+  expect(query.key).toBe('userId');
+  expect(query.val).toBe('624dc255c12744f2fdaf90c8');
+});
+
+test('RSCPayload old format', () => {
+  const payload = new RSCPayload(
+    ['$', '$L1', null, { buildId: 'abc123' }],
+    null,
+    0
+  );
+  expect(payload.build_id).toBe('abc123');
+});
+
+test('RSCPayload new format', () => {
+  const payload = new RSCPayload({ b: 'xyz789' }, null, 0);
+  expect(payload.build_id).toBe('xyz789');
+});
+
+test('Error element', () => {
+  const err = new FlightError({ digest: 'NEXT_NOT_FOUND' }, 'E', 14);
+  expect(err.digest).toBe('NEXT_NOT_FOUND');
+});
+
+test('isFlightDataObj returns true for valid objects', () => {
+  expect(isFlightDataObj(['$', '$L1', null, {}])).toBe(true);
+  expect(isFlightDataObj(['$', 'div', 'href', { class: 'test' }])).toBe(true);
+});
+
+test('isFlightDataObj returns false for invalid objects', () => {
+  expect(isFlightDataObj([])).toBe(false);
+  expect(isFlightDataObj(['$', '$L1'])).toBe(false);
+  expect(isFlightDataObj(['$', '$L1', null])).toBe(false);
+  expect(isFlightDataObj([1, '$L1', null, {}])).toBe(false);
+  expect(isFlightDataObj(['$', 123, null, {}])).toBe(false);
+  expect(isFlightDataObj(null)).toBe(false);
+  expect(isFlightDataObj('string')).toBe(false);
+});
+
+test('resolveType with explicit class', () => {
+  const el = resolveType('test', 'T', 1, Text);
+  expect(el).toBeInstanceOf(Text);
+  expect(el.text).toBe('test');
+});
+
+test('resolveType with value_class', () => {
+  const el = resolveType('test', 'T', 1);
+  expect(el).toBeInstanceOf(Text);
+});
+
+test('resolveType for Data with buildId', () => {
+  const el = resolveType(['$', '$L1', null, { buildId: 'test' }], null, 0);
+  expect(el).toBeInstanceOf(RSCPayload);
+});
+
+test('resolveType for Data with children', () => {
+  const el = resolveType(['$', '$L1', null, { children: ['$', '$L2', null, {}] }], null, 1);
+  expect(el).toBeInstanceOf(DataParent);
+});
+
+test('resolveType for HTMLElement', () => {
+  const el = resolveType(['$', 'div', null, {}], null, 1);
+  expect(el).toBeInstanceOf(HTMLElement);
+});
+
+test('resolveType for URLQuery', () => {
+  const el = resolveType(['key', 'value', 'd'], null, 1);
+  expect(el).toBeInstanceOf(URLQuery);
+});
+
+test('resolveType for DataContainer', () => {
+  const el = resolveType([['$', 'div', null, {}]], null, 1);
+  expect(el).toBeInstanceOf(DataContainer);
+});
+
+test('resolveType for EmptyData', () => {
+  const el = resolveType(null, null, 1);
+  expect(el).toBeInstanceOf(EmptyData);
+});
+
+test('resolveType for SpecialData', () => {
+  const el = resolveType('$Sreact.suspense', null, 1);
+  expect(el).toBeInstanceOf(SpecialData);
+});
+
+test('resolveType for RSCPayload at index 0', () => {
+  const el = resolveType({ b: 'test' }, null, 0);
+  expect(el).toBeInstanceOf(RSCPayload);
+});
+
+test('T object contains all types', () => {
+  expect(T.Element).toBe(Element);
+  expect(T.HintPreload).toBe(HintPreload);
+  expect(T.Module).toBe(Module);
+  expect(T.Text).toBe(Text);
+  expect(T.Data).toBe(Data);
+  expect(T.EmptyData).toBe(EmptyData);
+  expect(T.SpecialData).toBe(SpecialData);
+  expect(T.HTMLElement).toBe(HTMLElement);
+  expect(T.DataContainer).toBe(DataContainer);
+  expect(T.DataParent).toBe(DataParent);
+  expect(T.URLQuery).toBe(URLQuery);
+  expect(T.RSCPayload).toBe(RSCPayload);
+  expect(T.Error).toBe(FlightError);
+});

package/tests/parser/urls.test.js

@@ -0,0 +1,84 @@
+import { test, expect } from 'bun:test';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { DOMParser } from '../setup.js';
+import { getNextStaticUrls, getBasePath, _NS } from '../../parser/urls.js';
+
+function loadTestHTML(filename) {
+  const path = join(process.cwd(), '..', 'test', 'src', filename);
+  return readFileSync(path, 'utf-8');
+}
+
+test('getNextStaticUrls finds URLs in nextjs.org.html', () => {
+  const html = loadTestHTML('nextjs.org.html');
+  const urls = getNextStaticUrls(html, DOMParser);
+  expect(urls).not.toBeNull();
+  expect(Array.isArray(urls)).toBe(true);
+  expect(urls.length).toBeGreaterThan(0);
+  expect(urls.every(url => url.includes(_NS))).toBe(true);
+});
+
+test('getNextStaticUrls returns null for no static URLs', () => {
+  const html = '<html><body>No static URLs</body></html>';
+  const urls = getNextStaticUrls(html, DOMParser);
+  expect(urls).toBeNull();
+});
+
+test('getNextStaticUrls finds URLs in swag.live.html', () => {
+  const html = loadTestHTML('swag.live.html');
+  const urls = getNextStaticUrls(html, DOMParser);
+  expect(urls).not.toBeNull();
+  expect(Array.isArray(urls)).toBe(true);
+});
+
+test('getBasePath extracts base path from URLs', () => {
+  const urls = [
+    '/_next/static/abc/chunk1.js',
+    '/_next/static/abc/chunk2.js'
+  ];
+  const basePath = getBasePath(urls);
+  expect(basePath).toBe('');
+});
+
+test('getBasePath extracts base path with prefix', () => {
+  const urls = [
+    '/app/_next/static/abc/chunk1.js',
+    '/app/_next/static/abc/chunk2.js'
+  ];
+  const basePath = getBasePath(urls);
+  expect(basePath).toBe('/app');
+});
+
+test('getBasePath throws on inconsistent prefixes', () => {
+  const urls = [
+    '/app1/_next/static/abc/chunk1.js',
+    '/app2/_next/static/abc/chunk2.js'
+  ];
+  expect(() => getBasePath(urls)).toThrow();
+});
+
+test('getBasePath throws on missing _NS', () => {
+  const urls = ['/invalid/path.js'];
+  expect(() => getBasePath(urls)).toThrow("can't find");
+});
+
+test('getBasePath removes domain when requested', () => {
+  const urls = [
+    'https://example.com/app/_next/static/abc/chunk1.js',
+    'https://example.com/app/_next/static/abc/chunk2.js'
+  ];
+  const basePath = getBasePath(urls, null, true);
+  expect(basePath).toBe('/app');
+});
+
+test('getBasePath from HTML', () => {
+  const html = loadTestHTML('nextjs.org.html');
+  const basePath = getBasePath(html, DOMParser);
+  expect(typeof basePath).toBe('string');
+});
+
+test('getBasePath returns null for HTML with no static URLs', () => {
+  const html = '<html><body>No static URLs</body></html>';
+  const basePath = getBasePath(html, DOMParser);
+  expect(basePath).toBeNull();
+});

package/tests/property.test.js

@@ -0,0 +1,299 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+import { test, expect } from 'bun:test';
+
+import { decodeRawFlightData, getRawFlightData, parseDecodedRawFlightData } from '../parser/flight_data.js';
+import { resolveType, RSCPayload, DataContainer, DataParent, Text, Data, HTMLElement, SpecialData, EmptyData } from '../parser/types.js';
+import { getApiPath, listApiPaths } from '../api.js';
+import { DOMParser } from './setup.js';
+import { getNextData } from '../parser/next_data.js';
+import { parseBuildManifest, getBuildManifestPath } from '../parser/manifests.js';
+import { getNextStaticUrls, getBasePath, _NS } from '../parser/urls.js';
+import { findInFlightData, findallInFlightData, finditerInFlightData, findBuildId, BeautifulFD } from '../tools.js';
+
+// Lightweight property-style tests (fast loops, no extra deps)
+
+function loadFixture(filename) {
+  const path = join(process.cwd(), '..', 'test', 'src', filename);
+  return readFileSync(path, 'utf-8');
+}
+
+function randInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function randAscii(len) {
+  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.';
+  let out = '';
+  for (let i = 0; i < len; i++) out += chars[randInt(0, chars.length - 1)];
+  return out;
+}
+
+function randPathSegment(len) {
+  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.';
+  let out = '';
+  for (let i = 0; i < len; i++) out += chars[randInt(0, chars.length - 1)];
+  return out;
+}
+
+function randPathLike(minSegments = 1, maxSegments = 3) {
+  const n = randInt(minSegments, maxSegments);
+  const segments = [];
+  for (let i = 0; i < n; i++) segments.push(randPathSegment(randInt(1, 10)));
+  return `/${segments.join('/')}`;
+}
+
+function randBool() {
+  return Math.random() < 0.5;
+}
+
+test('Property: decodeRawFlightData binary segment round-trip', () => {
+  for (let i = 0; i < 100; i++) {
+    const payload = randAscii(randInt(0, 200));
+    const raw = [[0], [3, btoa(payload)]];
+    const decoded = decodeRawFlightData(raw);
+    expect(decoded).toEqual([payload]);
+  }
+});
+
+test('Property: decodeRawFlightData rejects unknown segment type', () => {
+  for (let i = 0; i < 50; i++) {
+    const badType = randInt(4, 100);
+    expect(() => decodeRawFlightData([[0], [badType, 'x']])).toThrow('Unknown segment type');
+  }
+});
+
+test('Property: decodeRawFlightData enforces bootstrap ordering', () => {
+  for (let i = 0; i < 50; i++) {
+    expect(() => decodeRawFlightData([[1, 'x']])).toThrow('initialServerDataBuffer');
+  }
+});
+
+test('Property: parseDecodedRawFlightData text element length accuracy', () => {
+  for (let i = 0; i < 100; i++) {
+    const text = randAscii(randInt(0, 50));
+    const lenHex = text.length.toString(16);
+    const decoded = [`1:T${lenHex},${text}`];
+    const parsed = parseDecodedRawFlightData(decoded);
+    expect(parsed[1]).toBeInstanceOf(Text);
+    expect(parsed[1].text).toBe(text);
+    expect(parsed[1].text.length).toBe(text.length);
+  }
+});
+
+test('Property: Flight data extraction completeness (all push() captured)', () => {
+  // Synthetic HTML with N pushes; ensure getRawFlightData returns N arrays
+  for (let i = 0; i < 50; i++) {
+    const n = randInt(1, 10);
+    const init = [0];
+    const scripts = [];
+    scripts.push(`(self.__next_f=self.__next_f||[]).push(${JSON.stringify(init)})`);
+    for (let k = 0; k < n; k++) {
+      scripts.push(`self.__next_f.push(${JSON.stringify([1, `chunk-${i}-${k}`])})`);
+    }
+    const html = `<html><body>${scripts.map(s => `<script>${s}</script>`).join('')}</body></html>`;
+    const raw = getRawFlightData(html, DOMParser);
+    expect(raw).not.toBeNull();
+    expect(raw.length).toBe(1 + n);
+  }
+});
+
+test('Property: Next data round-trip', () => {
+  for (let i = 0; i < 100; i++) {
+    const obj = {
+      buildId: randAscii(randInt(1, 20)),
+      props: { pageProps: { n: i, s: randAscii(randInt(0, 10)) } }
+    };
+    const html = `<html><body><script id="__NEXT_DATA__">${JSON.stringify(obj)}</script></body></html>`;
+    const parsed = getNextData(html, DOMParser);
+    expect(parsed).toEqual(obj);
+  }
+});
+
+test('Property: parseBuildManifest round-trip through eval wrapper', () => {
+  for (let i = 0; i < 50; i++) {
+    const data = { sortedPages: ['/', `/p${i}`], __rand: randAscii(6) };
+    const script = `self.__BUILD_MANIFEST=${JSON.stringify(data)};`;
+    const parsed = parseBuildManifest(script);
+    expect(parsed).toEqual(data);
+  }
+});
+
+test('Property: getBuildManifestPath format', () => {
+  for (let i = 0; i < 50; i++) {
+    const buildId = randPathSegment(randInt(1, 16));
+    const basePath = randBool() ? '' : randPathLike(1, 2);
+    const p = getBuildManifestPath(buildId, basePath);
+
+    expect(p.startsWith('/')).toBe(true);
+    expect(p.endsWith(`/_next/static/${buildId}/_buildManifest.js`)).toBe(true);
+
+    if (basePath) {
+      expect(p.startsWith(`${basePath}/`)).toBe(true);
+    }
+  }
+});
+
+test('Property: URL discovery completeness (every URL contains /_next/static/)', () => {
+  const html = loadFixture('nextjs.org.html');
+  const urls = getNextStaticUrls(html, DOMParser);
+  expect(urls).not.toBeNull();
+  for (const u of urls) expect(u.includes(_NS)).toBe(true);
+});
+
+test('Property: base path extraction consistency', () => {
+  for (let i = 0; i < 50; i++) {
+    const prefix = randBool() ? '' : `/${randAscii(randInt(1, 6))}`;
+    const build = randAscii(8);
+    const urls = [
+      `${prefix}${_NS}${build}/a.js`,
+      `${prefix}${_NS}${build}/b.js`
+    ];
+    expect(getBasePath(urls)).toBe(prefix);
+  }
+});
+
+test('Property: domain removal correctness', () => {
+  for (let i = 0; i < 50; i++) {
+    const prefix = `/${randAscii(randInt(1, 6))}`;
+    const build = randAscii(8);
+    const urls = [
+      `https://example.com${prefix}${_NS}${build}/a.js`,
+      `https://example.com${prefix}${_NS}${build}/b.js`
+    ];
+    expect(getBasePath(urls, null, true)).toBe(prefix);
+  }
+});
+
+test('Property: inconsistent prefixes are rejected', () => {
+  for (let i = 0; i < 50; i++) {
+    const build = randAscii(8);
+    const urls = [
+      `/a${_NS}${build}/a.js`,
+      `/b${_NS}${build}/b.js`
+    ];
+    expect(() => getBasePath(urls)).toThrow();
+  }
+});
+
+test('Property: Element properties are accessible', () => {
+  const cases = [
+    resolveType(["$", "$L1", null, null], null, 10),
+    resolveType(["$", "div", null, { id: "x" }], null, 11),
+    resolveType('$Sreact.suspense', null, 12),
+    resolveType(null, null, 13)
+  ];
+
+  for (const el of cases) {
+    expect(el).toBeTruthy();
+    expect('value' in el).toBe(true);
+    expect('value_class' in el).toBe(true);
+    expect('index' in el).toBe(true);
+  }
+});
+
+test('Property: Recursive resolution completeness (DataContainer / DataParent)', () => {
+  const container = resolveType([null, '$S', ["$", "div", null, { id: 'x' }]], null, 22);
+  expect(container).toBeInstanceOf(DataContainer);
+  expect(container.value.every(v => typeof v === 'object')).toBe(true);
+
+  const parent = resolveType(["$", "$L1", null, { children: ["$", "div", null, { id: 'x' }] }], null, 23);
+  expect(parent).toBeInstanceOf(DataParent);
+  expect(parent.children).toBeTruthy();
+});
+
+test('Property: RSCPayload build ID extraction (old + new formats)', () => {
+  for (let i = 0; i < 50; i++) {
+    const buildId = randAscii(randInt(1, 20));
+
+    const oldVal = ["$", "$L1", null, { buildId }];
+    const old = resolveType(oldVal, null, 0);
+    expect(old).toBeInstanceOf(RSCPayload);
+    expect(old.build_id).toBe(buildId);
+
+    const newer = resolveType({ b: buildId }, null, 0);
+    expect(newer).toBeInstanceOf(RSCPayload);
+    expect(newer.build_id).toBe(buildId);
+  }
+});
+
+test('Property: find/filter semantics (class filtering, callback filtering, recursive, non-recursive, first match)', () => {
+  const flightData = {
+    0: resolveType({ b: 'build' }, null, 0),
+    1: resolveType('hello', 'T', 1),
+    2: resolveType(["$", "div", null, { id: 'x' }], null, 2),
+    3: resolveType([resolveType('nested', 'T', null)], null, 3)
+  };
+
+  // class filtering
+  const texts = findallInFlightData(flightData, [Text]);
+  expect(texts.every(t => t instanceof Text)).toBe(true);
+
+  // callback filtering
+  const onlyHello = findallInFlightData(flightData, null, (el) => el instanceof Text && el.text === 'hello');
+  expect(onlyHello.length).toBe(1);
+
+  // recursive vs non-recursive
+  const rec = findallInFlightData(flightData, [Text], null, true);
+  const nonRec = findallInFlightData(flightData, [Text], null, false);
+  expect(rec.length).toBeGreaterThanOrEqual(nonRec.length);
+
+  // first match
+  const first = findInFlightData(flightData, [Text]);
+  expect(first).toBeTruthy();
+  expect(first).toBeInstanceOf(Text);
+});
+
+test('Property: buildId discovery works and priority is staticUrls > nextData > flightData', () => {
+  const flightBuild = 'flightBuild';
+  const nextBuild = 'nextBuild';
+  const staticBuild = 'staticBuild';
+
+  const html = `<!doctype html><html><head>
+    <script id="__NEXT_DATA__">${JSON.stringify({ buildId: nextBuild })}</script>
+    <link rel="preload" href="${_NS}${staticBuild}/_buildManifest.js" />
+    <script>(self.__next_f=self.__next_f||[]).push([0])</script>
+    <script>self.__next_f.push([1, ${JSON.stringify(`0:{\"b\":\"${flightBuild}\"}`)}])</script>
+  </head><body></body></html>`;
+
+  const found = findBuildId(html, DOMParser);
+  expect(found).toBe(staticBuild);
+});
+
+test('Property: BeautifulFD iteration completeness + length accuracy', () => {
+  const el0 = resolveType({ b: 'b' }, null, 0);
+  const el1 = resolveType('hello', 'T', 1);
+  const fd = new BeautifulFD({ 0: el0, 1: el1 });
+
+  const items = Array.from(fd);
+  expect(items.length).toBe(fd.length);
+  expect(fd.length).toBe(2);
+
+  // Ensure key-value pairs
+  expect(items[0].length).toBe(2);
+});
+
+test('Property: getApiPath path format correctness + excluded paths + list completeness', () => {
+  const buildId = 'build123';
+
+  // format correctness
+  for (let i = 0; i < 50; i++) {
+    const basePath = randBool() ? '' : randPathLike(1, 2);
+    const p = randBool() ? randPathLike(1, 2) : randPathSegment(5);
+    const api = getApiPath(buildId, basePath, p);
+    if (api === null) continue;
+    expect(api.includes(`/_next/data/${buildId}`)).toBe(true);
+    expect(api.endsWith('.json')).toBe(true);
+  }
+
+  // excluded paths
+  for (const ex of ['/404', '/_app', '/_error', '/sitemap.xml', '/_middleware']) {
+    expect(getApiPath(buildId, '', ex)).toBeNull();
+  }
+
+  // list completeness
+  const pages = ['/', '/a', '/b', '/_app'];
+  const paths = listApiPaths(pages, buildId, '', true);
+  expect(paths.every(p => p.includes(`/_next/data/${buildId}`))).toBe(true);
+});

package/tests/setup.js

@@ -0,0 +1,21 @@
+/**
+ * Test setup and utilities
+ */
+// deno-dom's repo layout doesn't expose a Node-style package entry by default.
+// For Bun tests we import the WASM build directly.
+import { DOMParser } from 'deno-dom/deno-dom-wasm.ts';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+// Export DOMParser for tests
+export { DOMParser };
+
+/**
+ * Load test HTML file
+ * @param {string} filename - Name of the HTML file in test/src/
+ * @returns {string} HTML content
+ */
+export function loadTestHTML(filename) {
+  const path = join(process.cwd(), 'test', 'src', filename);
+  return readFileSync(path, 'utf-8');
+}

package/tests/utils.test.js

@@ -0,0 +1,32 @@
+import { test, expect } from 'bun:test';
+import { DOMParser } from './setup.js';
+import { makeTree, join } from '../utils.js';
+
+test('makeTree parses HTML correctly', () => {
+  const html = '<html><body><div id="test">Hello</div></body></html>';
+  const doc = makeTree(html, DOMParser);
+  const div = doc.querySelector('#test');
+  expect(div).toBeTruthy();
+  expect(div.textContent).toBe('Hello');
+});
+
+test('makeTree throws on non-string input', () => {
+  expect(() => makeTree(123, DOMParser)).toThrow(TypeError);
+});
+
+test('join combines URL parts correctly', () => {
+  expect(join('a', 'b', 'c')).toBe('/a/b/c');
+  expect(join('/a/', '/b/', '/c/')).toBe('/a/b/c');
+  expect(join('', 'a', '', 'b')).toBe('/a/b');
+  expect(join()).toBe('/');
+});
+
+test('join handles empty strings', () => {
+  expect(join('', '', '')).toBe('/');
+  expect(join('a', '', 'b')).toBe('/a/b');
+});
+
+test('join handles leading/trailing slashes', () => {
+  expect(join('/a', 'b/', '/c')).toBe('/a/b/c');
+  expect(join('//a//', '//b//', '//c//')).toBe('/a/b/c');
+});