@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/locator/selector.test.ts

@@ -1,124 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-  cssSelector,
-  describeChain,
-  describeSelector,
-  normalizeXpath,
-  roleSelector,
-  textSelector,
-  toBiDiLocator,
-  xpathSelector,
-  type Selector,
-} from "./selector.js";
-
-describe("normalizeXpath", () => {
-  it("prefixes a relative xpath with //, keeping absolute, grouped and context paths", () => {
-    assert.equal(normalizeXpath("h1", false), "//h1");
-    assert.equal(normalizeXpath("//div", false), "//div");
-    assert.equal(normalizeXpath("a[text()='Start']", false), "//a[text()='Start']");
-    assert.equal(normalizeXpath("/html/body", false), "/html/body");
-    assert.equal(normalizeXpath("(//li)[2]", false), "(//li)[2]");
-    assert.equal(normalizeXpath(".//span", false), ".//span");
-  });
-
-  it("scopes a chained xpath to its parent: relative and // paths become .//", () => {
-    assert.equal(normalizeXpath("input", true), ".//input");
-    assert.equal(normalizeXpath("//input", true), ".//input");
-    assert.equal(normalizeXpath(".//input", true), ".//input");
-    assert.equal(normalizeXpath("./input", true), "./input");
-    assert.equal(normalizeXpath("/html/body", true), "/html/body");
-    assert.equal(normalizeXpath("(//li)[2]", true), "(//li)[2]");
-  });
-});
-
-describe("selector constructors", () => {
-  it("build selectors with defaults", () => {
-    assert.deepEqual(xpathSelector("h1"), { kind: "xpath", value: "h1" });
-    assert.deepEqual(cssSelector("form input"), { kind: "css", value: "form input" });
-    assert.deepEqual(textSelector("Sign in"), {
-      kind: "text",
-      value: "Sign in",
-      match: "full",
-      ignoreCase: false,
-    });
-    assert.deepEqual(textSelector("in", { match: "partial", ignoreCase: true }), {
-      kind: "text",
-      value: "in",
-      match: "partial",
-      ignoreCase: true,
-    });
-    assert.deepEqual(roleSelector("button", { name: "Submit" }), {
-      kind: "role",
-      role: "button",
-      name: "Submit",
-    });
-    assert.deepEqual(roleSelector("button"), { kind: "role", role: "button" });
-  });
-
-  it("reject empty input", () => {
-    assert.throws(() => xpathSelector(""), TypeError);
-    assert.throws(() => cssSelector("  "), TypeError);
-    assert.throws(() => textSelector(""), TypeError);
-    assert.throws(() => roleSelector(""), TypeError);
-  });
-});
-
-describe("toBiDiLocator", () => {
-  it("maps every kind", () => {
-    assert.deepEqual(toBiDiLocator(xpathSelector("h1"), false), { type: "xpath", value: "//h1" });
-    assert.deepEqual(toBiDiLocator(xpathSelector("h1"), true), { type: "xpath", value: ".//h1" });
-    assert.deepEqual(toBiDiLocator(cssSelector("a.b"), false), { type: "css", value: "a.b" });
-    assert.deepEqual(toBiDiLocator(textSelector("Hi", { match: "partial", ignoreCase: true }), false), {
-      type: "innerText",
-      value: "Hi",
-      matchType: "partial",
-      ignoreCase: true,
-    });
-    assert.deepEqual(toBiDiLocator(roleSelector("button", { name: "Go" }), false), {
-      type: "accessibility",
-      value: { role: "button", name: "Go" },
-    });
-    assert.deepEqual(toBiDiLocator(roleSelector("link"), false), {
-      type: "accessibility",
-      value: { role: "link" },
-    });
-  });
-
-  it("refuses nth, which the browser does not know", () => {
-    assert.throws(() => toBiDiLocator({ kind: "nth", index: 0 }, false), /nth/);
-  });
-});
-
-describe("describeSelector", () => {
-  it("prints a name for every kind", () => {
-    assert.equal(describeSelector(xpathSelector("h1"), false), "//h1");
-    assert.equal(describeSelector(xpathSelector("h1"), true), ".//h1");
-    assert.equal(describeSelector(cssSelector("form input"), false), "css=form input");
-    assert.equal(describeSelector(textSelector("Sign in"), false), 'text="Sign in"');
-    assert.equal(
-      describeSelector(textSelector("in", { match: "partial" }), false),
-      'text="in" (partial)',
-    );
-    assert.equal(
-      describeSelector(textSelector("in", { match: "partial", ignoreCase: true }), false),
-      'text="in" (partial, ignoring case)',
-    );
-    assert.equal(
-      describeSelector(textSelector("in", { ignoreCase: true }), false),
-      'text="in" (ignoring case)',
-    );
-    assert.equal(
-      describeSelector(roleSelector("button", { name: "Submit" }), false),
-      'role=button[name="Submit"]',
-    );
-    assert.equal(describeSelector(roleSelector("button"), false), "role=button");
-    assert.equal(describeSelector({ kind: "nth", index: 2 }, false), "nth=2");
-  });
-
-  it("joins a chain with >> and scopes chained xpaths", () => {
-    const chain: Selector[] = [xpathSelector("//form"), xpathSelector("input"), cssSelector(".x")];
-    assert.equal(describeChain(chain), "//form >> .//input >> css=.x");
-    assert.equal(describeChain([xpathSelector("h1")]), "//h1");
-  });
-});

package/src/locator/selector.ts

@@ -1,107 +0,0 @@
-import type { NodeLocator } from "../types/bidi-modules/browsing-context.js";
-
-/** One step of a locator. A locator is a chain of them, each searching inside the previous step's matches */
-export type Selector =
-  | { kind: "xpath"; value: string }
-  | { kind: "css"; value: string }
-  | { kind: "text"; value: string; match: "full" | "partial"; ignoreCase: boolean }
-  | { kind: "role"; role?: string; name?: string }
-  /** Picks the n-th (0-based) of everything the chain so far matches; `all()` builds these */
-  | { kind: "nth"; index: number };
-
-export interface TextOptions {
-  /** @default "full" */
-  match?: "full" | "partial";
-  /** @default false */
-  ignoreCase?: boolean;
-}
-
-function nonEmpty(value: string, what: string): string {
-  if (value.trim() === "") throw new TypeError(`${what} must not be empty`);
-  return value;
-}
-
-export function xpathSelector(value: string): Selector {
-  return { kind: "xpath", value: nonEmpty(value, "an xpath") };
-}
-
-export function cssSelector(value: string): Selector {
-  return { kind: "css", value: nonEmpty(value, "a css selector") };
-}
-
-export function textSelector(value: string, { match = "full", ignoreCase = false }: TextOptions = {}): Selector {
-  return { kind: "text", value: nonEmpty(value, "the text"), match, ignoreCase };
-}
-
-export function roleSelector(role: string, { name }: { name?: string } = {}): Selector {
-  nonEmpty(role, "the role");
-  return name === undefined ? { kind: "role", role } : { kind: "role", role, name };
-}
-
-/**
- * Normalises an xpath. Relative xpaths get a leading `//` (`.//` when `scoped`, i.e. searching inside
- * a parent match). Absolute (`/…`), grouped (`(…)`) and context (`./…`) paths are kept; in a scoped
- * position `//…` is also made relative, so `parent.locator("//x")` means "x inside parent".
- */
-export function normalizeXpath(xpath: string, scoped: boolean): string {
-  if (scoped) {
-    if (xpath.startsWith("//")) return "." + xpath;
-    return /^[/(.]/.test(xpath) ? xpath : ".//" + xpath;
-  }
-  return /^[/(.]/.test(xpath) ? xpath : "//" + xpath;
-}
-
-/** The BiDi locator for a step. `scoped` is true for every step after the first */
-export function toBiDiLocator(selector: Selector, scoped: boolean): NodeLocator {
-  switch (selector.kind) {
-    case "xpath":
-      return { type: "xpath", value: normalizeXpath(selector.value, scoped) };
-    case "css":
-      return { type: "css", value: selector.value };
-    case "text":
-      return {
-        type: "innerText",
-        value: selector.value,
-        matchType: selector.match,
-        ignoreCase: selector.ignoreCase,
-      };
-    case "role":
-      return {
-        type: "accessibility",
-        value: {
-          ...(selector.role !== undefined && { role: selector.role }),
-          ...(selector.name !== undefined && { name: selector.name }),
-        },
-      };
-    case "nth":
-      throw new Error("nth is resolved by the framework, not by the browser");
-  }
-}
-
-/** A short name for error messages */
-export function describeSelector(selector: Selector, scoped: boolean): string {
-  switch (selector.kind) {
-    case "xpath":
-      return normalizeXpath(selector.value, scoped);
-    case "css":
-      return `css=${selector.value}`;
-    case "text": {
-      const flags = [
-        selector.match === "partial" && "partial",
-        selector.ignoreCase && "ignoring case",
-      ].filter(Boolean);
-      return `text=${JSON.stringify(selector.value)}${flags.length ? ` (${flags.join(", ")})` : ""}`;
-    }
-    case "role":
-      return (
-        `role=${selector.role ?? ""}` +
-        (selector.name === undefined ? "" : `[name=${JSON.stringify(selector.name)}]`)
-      );
-    case "nth":
-      return `nth=${selector.index}`;
-  }
-}
-
-export function describeChain(chain: readonly Selector[]): string {
-  return chain.map((selector, index) => describeSelector(selector, index > 0)).join(" >> ");
-}

package/src/locator/set-files.browser-test.ts

@@ -1,141 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { after, before, test } from "node:test";
-import { Browser } from "../browser/browser.js";
-import type Page from "../browser/page.js";
-import { setContent } from "../testing/browser-fixture.js";
-import { ActionTimeoutError } from "./action-timeout-error.js";
-
-let browser: Browser;
-let page: Page;
-const dir = mkdtempSync(path.join(tmpdir(), "samurai-upload-"));
-
-before(async () => {
-  ({ browser, page } = await Browser.launch("firefox", { port: 9236, headless: true }));
-  await page.navigateTo("about:blank", "complete");
-});
-
-after(async () => {
-  await page.dispose();
-  await browser?.close();
-  rmSync(dir, { recursive: true, force: true });
-});
-
-const OPTIONS = { timeout: 20000 };
-function file(name: string, content = name) {
-  const full = path.join(dir, name);
-  writeFileSync(full, content);
-  return full;
-}
-
-/** Records the chosen files and how often `input` and `change` fired */
-const RECORD = `
-  const input = document.getElementById("f");
-  const out = document.getElementById("out");
-  const counts = { input: 0, change: 0 };
-  const render = () => {
-    out.textContent = JSON.stringify({ names: [...input.files].map((f) => f.name), ...counts });
-  };
-  input.addEventListener("input", () => { counts.input++; render(); });
-  input.addEventListener("change", () => { counts.change++; render(); });`;
-const result = async () => JSON.parse((await page.locator("div[@id='out']").textContent()) ?? "null");
-
-test("uploads one file and the browser fires input and change once", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f"><div id="out"></div>`, RECORD);
-  await page.locator("input[@id='f']").setInputFiles(file("avatar.png"), { timeout: 5000 });
-  assert.deepEqual(await result(), { names: ["avatar.png"], input: 1, change: 1 });
-});
-
-test("uploads several files to a multiple input", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f" multiple><div id="out"></div>`, RECORD);
-  await page.locator("input[@id='f']").setInputFiles([file("a.csv"), file("b.csv")], { timeout: 5000 });
-  assert.deepEqual((await result()).names, ["a.csv", "b.csv"]);
-});
-
-test("the browser reads the file content", OPTIONS, async () => {
-  await setContent(
-    page,
-    `<input type="file" id="f"><div id="out"></div>`,
-    `document.getElementById("f").addEventListener("change", async (e) => {
-       document.getElementById("out").textContent = await e.target.files[0].text();
-     });`,
-  );
-  await page.locator("input[@id='f']").setInputFiles(file("hello.txt", "hello upload"), { timeout: 5000 });
-  await page.locator("div[@id='out']").waitFor({ state: "visible", timeout: 3000 });
-  await new Promise((resolve) => setTimeout(resolve, 200));
-  assert.equal(await page.locator("div[@id='out']").textContent(), "hello upload");
-});
-
-test("an empty list clears the selection", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f"><div id="out"></div>`, RECORD);
-  const input = page.locator("input[@id='f']");
-  await input.setInputFiles(file("first.txt"), { timeout: 5000 });
-  await input.setInputFiles([], { timeout: 5000 });
-  const state = await result();
-  assert.deepEqual(state.names, []);
-});
-
-test("works on a hidden input behind a styled label", OPTIONS, async () => {
-  await setContent(
-    page,
-    `<label for="f" style="display:inline-block;padding:8px">Choose</label>
-     <input type="file" id="f" style="display:none"><div id="out"></div>`,
-    RECORD,
-  );
-  const input = page.locator("input[@id='f']");
-  assert.equal(await input.isVisible(), false);
-  await input.setInputFiles(file("hidden.txt"), { timeout: 5000 });
-  assert.deepEqual((await result()).names, ["hidden.txt"]);
-});
-
-test("waits for an input that appears later", OPTIONS, async () => {
-  await setContent(
-    page,
-    `<div id="out"></div>`,
-    `setTimeout(() => {
-       document.body.insertAdjacentHTML("afterbegin", '<input type="file" id="f">');
-       ${RECORD}
-     }, 300);`,
-  );
-  await page.locator("input[@id='f']").setInputFiles(file("late.txt"), { timeout: 5000 });
-  assert.deepEqual((await result()).names, ["late.txt"]);
-});
-
-test("refuses two files for an input without multiple", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f"><div id="out"></div>`, RECORD);
-  await assert.rejects(
-    page.locator("input[@id='f']").setInputFiles([file("x.txt"), file("y.txt")], { timeout: 5000 }),
-    /does not accept multiple files/,
-  );
-  assert.deepEqual((await result().catch(() => null)), null, "nothing was set, so no event rendered");
-});
-
-test("refuses an element that is not a file input", OPTIONS, async () => {
-  await setContent(page, `<input type="text" id="t"><div id="d"></div>`);
-  await assert.rejects(
-    page.locator("input[@id='t']").setInputFiles(file("t.txt"), { timeout: 5000 }),
-    /is not an <input type=file> \(found <input type="text">\)/,
-  );
-  await assert.rejects(
-    page.locator("div[@id='d']").setInputFiles(file("t.txt"), { timeout: 5000 }),
-    /found <div>/,
-  );
-});
-
-test("a disabled input times out naming the check", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f" disabled>`);
-  await assert.rejects(
-    page.locator("input[@id='f']").setInputFiles(file("d.txt"), { timeout: 400 }),
-    (err) => err instanceof ActionTimeoutError && /attached ✓  enabled ✗/.test(err.message),
-  );
-});
-
-test("a missing file fails before touching the page", OPTIONS, async () => {
-  await setContent(page, `<input type="file" id="f">`);
-  await assert.rejects(
-    page.locator("input[@id='f']").setInputFiles(path.join(dir, "missing.txt")),
-    /file not found/,
-  );
-});

package/src/locator/set-files.test.ts

@@ -1,191 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { after, describe, it } from "node:test";
-import { remote, stubConnector, type StubResponse } from "../testing/stub-connector.js";
-import { BiDiError } from "../transport/bidi-error.js";
-import { ActionTimeoutError } from "./action-timeout-error.js";
-import Locator from "./locator.js";
-
-const dir = mkdtempSync(path.join(tmpdir(), "samurai-set-files-"));
-after(() => rmSync(dir, { recursive: true, force: true }));
-function file(name: string) {
-  const full = path.join(dir, name);
-  writeFileSync(full, name);
-  return full;
-}
-
-const state = (overrides: object = {}): StubResponse =>
-  remote({
-    attached: true,
-    visible: true,
-    enabled: true,
-    editable: true,
-    box: { x: 0, y: 0, width: 10, height: 10 },
-    hitTarget: null,
-    ...overrides,
-  });
-const info = (overrides: object = {}): StubResponse =>
-  remote({ tag: "input", type: "file", multiple: false, ...overrides });
-
-function setup(...responses: StubResponse[]) {
-  const stub = stubConnector(...responses);
-  return { locator: new Locator("input[@type='file']", stub.connector, "ctx"), ...stub };
-}
-const methods = (sent: Array<{ method: string }>) => sent.map(({ method }) => method);
-const setFilesParams = (sent: Array<{ method: string; params: unknown }>) =>
-  sent.filter(({ method }) => method === "input.setFiles").map(({ params }) => params);
-
-describe("setInputFiles", () => {
-  it("checks the files, waits for the element, verifies it, then sets the files", async () => {
-    const a = file("a.txt");
-    const { locator, sent } = setup(state(), info());
-    await locator.setInputFiles(a, { timeout: 1000 });
-    assert.deepEqual(methods(sent), [
-      "browsingContext.locateNodes", // the wait
-      "script.callFunction", // its probe
-      "browsingContext.locateNodes", // the element to use
-      "script.callFunction", // what kind of element it is
-      "input.setFiles",
-    ]);
-    assert.deepEqual(setFilesParams(sent), [
-      { context: "ctx", element: { sharedId: "stub-node-0" }, files: [a] },
-    ]);
-  });
-
-  it("waits only for attached and enabled: no scrolling, no hit test, hidden inputs are fine", async () => {
-    const { locator, calls } = setup(state({ visible: false, box: null }), info());
-    await locator.setInputFiles(file("hidden.txt"), { timeout: 1000 });
-    assert.deepEqual(calls[0]!.args[1], { scroll: false, hitTest: false });
-  });
-
-  it("resolves relative paths against the working directory", async () => {
-    const a = file("relative.txt");
-    const { locator, sent } = setup(state(), info());
-    await locator.setInputFiles(path.relative(process.cwd(), a), { timeout: 1000 });
-    assert.deepEqual((setFilesParams(sent)[0] as { files: string[] }).files, [a]);
-  });
-
-  it("sends several files in order to an input that accepts them", async () => {
-    const [a, b] = [file("m1.txt"), file("m2.txt")];
-    const { locator, sent } = setup(state(), info({ multiple: true }));
-    await locator.setInputFiles([a, b], { timeout: 1000 });
-    assert.deepEqual((setFilesParams(sent)[0] as { files: string[] }).files, [a, b]);
-  });
-
-  it("refuses several files for an input without multiple, and sends nothing", async () => {
-    const { locator, sent } = setup(state(), info({ multiple: false }));
-    await assert.rejects(
-      locator.setInputFiles([file("x1.txt"), file("x2.txt")], { timeout: 1000 }),
-      /setInputFiles\(\): \/\/input\[@type='file'\] does not accept multiple files/,
-    );
-    assert.deepEqual(setFilesParams(sent), []);
-  });
-
-  it("an empty list clears the selection, also on an input without multiple, without touching the disk", async () => {
-    const { locator, sent } = setup(state(), info({ multiple: false }));
-    await locator.setInputFiles([], { timeout: 1000 });
-    assert.deepEqual((setFilesParams(sent)[0] as { files: string[] }).files, []);
-  });
-
-  it("fails on a missing file before any command is sent", async () => {
-    const missing = path.join(dir, "nope.txt");
-    const { locator, sent } = setup(state(), info());
-    await assert.rejects(locator.setInputFiles(missing), new Error(`setInputFiles(): file not found: ${missing}`));
-    assert.equal(sent.length, 0);
-  });
-
-  it("fails on a directory before any command is sent", async () => {
-    const folder = path.join(dir, "folder");
-    mkdirSync(folder);
-    const { locator, sent } = setup(state(), info());
-    await assert.rejects(locator.setInputFiles(folder), new Error(`setInputFiles(): not a file: ${folder}`));
-    assert.equal(sent.length, 0);
-  });
-
-  it("names the first bad file when several are given", async () => {
-    const good = file("good.txt");
-    const bad = path.join(dir, "bad.txt");
-    const { locator } = setup(state(), info());
-    await assert.rejects(locator.setInputFiles([good, bad]), /file not found: .*bad\.txt/);
-  });
-
-  it("rejects an element that is not a file input, describing what it found", async () => {
-    const a = file("wrong.txt");
-    const div = setup(state(), info({ tag: "div", type: "" }));
-    await assert.rejects(
-      div.locator.setInputFiles(a, { timeout: 1000 }),
-      /is not an <input type=file> \(found <div>\)/,
-    );
-    const text = setup(state(), info({ tag: "input", type: "text" }));
-    await assert.rejects(
-      text.locator.setInputFiles(a, { timeout: 1000 }),
-      /is not an <input type=file> \(found <input type="text">\)/,
-    );
-    assert.deepEqual(setFilesParams(div.sent), []);
-    assert.deepEqual(setFilesParams(text.sent), []);
-  });
-
-  it("times out naming the check that failed", async () => {
-    const { locator, sent } = setup(state({ enabled: false }));
-    await assert.rejects(locator.setInputFiles(file("t.txt"), { timeout: 250 }), (err) => {
-      assert.ok(err instanceof ActionTimeoutError);
-      assert.equal(err.action, "setInputFiles");
-      assert.equal(
-        err.message,
-        "setInputFiles(): //input[@type='file'] was not actionable within 250ms\n" +
-          "  attached ✓  enabled ✗",
-      );
-      return true;
-    });
-    assert.deepEqual(setFilesParams(sent), []);
-  });
-
-  it("times out when the input never appears", async () => {
-    const { locator, nodeCounts } = setup(state());
-    nodeCounts(0);
-    await assert.rejects(
-      locator.setInputFiles(file("n.txt"), { timeout: 150 }),
-      /setInputFiles\(\): \/\/input\[@type='file'\] was not attached within 150ms/,
-    );
-  });
-
-  it("with timeout 0 it looks once", async () => {
-    const { locator, calls } = setup(state({ enabled: false }));
-    await assert.rejects(locator.setInputFiles(file("z.txt"), { timeout: 0 }), ActionTimeoutError);
-    assert.equal(calls.length, 1);
-  });
-
-  it("waits until the input becomes enabled", async () => {
-    const { locator, sent } = setup(state({ enabled: false }), state({ enabled: false }), state(), info());
-    await locator.setInputFiles(file("w.txt"), { timeout: 3000 });
-    assert.equal(setFilesParams(sent).length, 1);
-  });
-
-  it("an input that vanished after the wait is reported as not found", async () => {
-    const { locator, nodeCounts, sent } = setup(state(), info());
-    nodeCounts(1, 0);
-    await assert.rejects(
-      locator.setInputFiles(file("v.txt"), { timeout: 1000 }),
-      /Failed to locate element \/\/input\[@type='file'\]/,
-    );
-    assert.deepEqual(setFilesParams(sent), []);
-  });
-
-  it("rethrows what the browser answers", async () => {
-    const { locator, failCommand } = setup(state(), info());
-    failCommand("input.setFiles", new BiDiError("input.setFiles", "unable to set file input", "read-only"));
-    await assert.rejects(locator.setInputFiles(file("e.txt"), { timeout: 1000 }), {
-      name: "BiDiError",
-      code: "unable to set file input",
-    });
-  });
-
-  it("works through a chained locator", async () => {
-    const stub = stubConnector(state(), info());
-    const chained = new Locator("//form", stub.connector, "ctx").getByCss("input[type=file]");
-    await chained.setInputFiles(file("c.txt"), { timeout: 1000 });
-    assert.equal(setFilesParams(stub.sent).length, 1);
-  });
-});

package/src/locator/text-locator.test.ts

@@ -1,118 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { TEXT_LOCATE } from "./text-locator.js";
-
-/** A tiny DOM: elements with text and children, enough to run TEXT_LOCATE in Node */
-class FakeElement {
-  parentElement: FakeElement | null = null;
-  children: FakeElement[] = [];
-  constructor(
-    public tagName: string,
-    private ownText = "",
-  ) {}
-  add(...kids: FakeElement[]) {
-    for (const kid of kids) {
-      kid.parentElement = this;
-      this.children.push(kid);
-    }
-    return this;
-  }
-  get innerText(): string {
-    return [this.ownText, ...this.children.map((kid) => kid.innerText)].filter(Boolean).join(" ");
-  }
-  get textContent(): string {
-    return this.innerText;
-  }
-  descendants(): FakeElement[] {
-    return this.children.flatMap((kid) => [kid, ...kid.descendants()]);
-  }
-  querySelectorAll() {
-    return this.descendants();
-  }
-  compareDocumentPosition(other: FakeElement) {
-    const order = all(root());
-    return order.indexOf(other) > order.indexOf(this) ? 4 : 2;
-  }
-}
-let documentRoot: FakeElement;
-const root = () => documentRoot;
-const all = (from: FakeElement): FakeElement[] => [from, ...from.descendants()];
-
-function run(start: FakeElement[] | null, value: string, match: string, ignoreCase: boolean) {
-  const fn = new Function(
-    "document",
-    `return (${TEXT_LOCATE})`,
-  )({ documentElement: documentRoot, querySelectorAll: () => documentRoot.descendants() }) as (
-    starts: unknown[],
-    value: string,
-    match: string,
-    ignoreCase: boolean,
-  ) => FakeElement[];
-  return fn(start ?? [], value, match, ignoreCase);
-}
-
-describe("TEXT_LOCATE", () => {
-  it("compiles as a function declaration", () => {
-    assert.doesNotThrow(() => new Function(`return (${TEXT_LOCATE})`));
-  });
-
-  it("finds the innermost element with the full text", () => {
-    const span = new FakeElement("SPAN", "Go");
-    const div = new FakeElement("DIV").add(span);
-    documentRoot = new FakeElement("HTML").add(new FakeElement("BODY").add(div));
-    assert.deepEqual(run(null, "Go", "full", false), [span]);
-  });
-
-  it("normalises whitespace on both sides", () => {
-    const p = new FakeElement("P", "  Hello \n  world ");
-    documentRoot = new FakeElement("HTML").add(p);
-    assert.deepEqual(run(null, "Hello world", "full", false), [p]);
-    assert.deepEqual(run(null, "  Hello   world", "full", false), [p]);
-  });
-
-  it("full needs the whole text, partial a substring", () => {
-    const p = new FakeElement("P", "Sign in now");
-    documentRoot = new FakeElement("HTML").add(p);
-    assert.deepEqual(run(null, "Sign in", "full", false), []);
-    assert.deepEqual(run(null, "Sign in", "partial", false), [p]);
-  });
-
-  it("ignoreCase compares lower-cased", () => {
-    const p = new FakeElement("P", "Sign IN");
-    documentRoot = new FakeElement("HTML").add(p);
-    assert.deepEqual(run(null, "sign in", "full", false), []);
-    assert.deepEqual(run(null, "sign in", "full", true), [p]);
-  });
-
-  it("returns the parent when the text is only complete across its children", () => {
-    const b = new FakeElement("B", "Hel");
-    const p = new FakeElement("P", "lo").add(b);
-    documentRoot = new FakeElement("HTML").add(p);
-    // innerText is "lo Hel" here, so use text that only the parent contains in full
-    assert.deepEqual(run(null, "lo Hel", "full", false), [p]);
-  });
-
-  it("returns every innermost match in document order", () => {
-    const a = new FakeElement("LI", "x");
-    const b = new FakeElement("LI", "x");
-    documentRoot = new FakeElement("HTML").add(new FakeElement("UL").add(a, b));
-    assert.deepEqual(run(null, "x", "full", false), [a, b]);
-  });
-
-  it("searches only inside the start nodes, without repeating a match found from two of them", () => {
-    const inside = new FakeElement("SPAN", "hit");
-    const nested = new FakeElement("DIV").add(inside);
-    const outside = new FakeElement("SPAN", "hit");
-    const form = new FakeElement("FORM").add(nested);
-    documentRoot = new FakeElement("HTML").add(form, outside);
-    assert.deepEqual(run([form], "hit", "full", false), [inside]);
-    assert.deepEqual(run([form, nested], "hit", "full", false), [inside]);
-  });
-
-  it("skips non-rendered elements", () => {
-    const script = new FakeElement("SCRIPT", "Go");
-    const p = new FakeElement("P", "Go");
-    documentRoot = new FakeElement("HTML").add(new FakeElement("HEAD").add(script), p);
-    assert.deepEqual(run(null, "Go", "full", false), [p]);
-  });
-});