@surrealdb/ui 1.2.12 → 1.2.13

package/tests/unit/MarkdownEditor/editor-ready.test.ts

@@ -4,33 +4,33 @@ import { getMarkdownEditorReady, markdownEditorReady } from "@src/lib/markdown/e
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 describe("markdownEditorReady", () => {
-    afterEach(() => {
-        vi.useRealTimers();
-    });
+	afterEach(() => {
+		vi.useRealTimers();
+	});
 
-    it("sets data-markdown-ready after the first animation frame", async () => {
-        vi.useFakeTimers({ toFake: ["requestAnimationFrame"] });
+	it("sets data-markdown-ready after the first animation frame", async () => {
+		vi.useFakeTimers({ toFake: ["requestAnimationFrame"] });
 
-        const parent = document.createElement("div");
-        document.body.appendChild(parent);
+		const parent = document.createElement("div");
+		document.body.appendChild(parent);
 
-        const view = new EditorView({
-            state: EditorState.create({
-                doc: "# Title",
-                extensions: [markdownEditorReady()],
-            }),
-            parent,
-        });
+		const view = new EditorView({
+			state: EditorState.create({
+				doc: "# Title",
+				extensions: [markdownEditorReady()],
+			}),
+			parent,
+		});
 
-        expect(getMarkdownEditorReady(view.state)).toBe(false);
-        expect(view.dom.getAttribute("data-markdown-ready")).toBeNull();
+		expect(getMarkdownEditorReady(view.state)).toBe(false);
+		expect(view.dom.getAttribute("data-markdown-ready")).toBeNull();
 
-        await vi.runAllTimersAsync();
+		await vi.runAllTimersAsync();
 
-        expect(getMarkdownEditorReady(view.state)).toBe(true);
-        expect(view.dom.getAttribute("data-markdown-ready")).toBe("true");
+		expect(getMarkdownEditorReady(view.state)).toBe(true);
+		expect(view.dom.getAttribute("data-markdown-ready")).toBe("true");
 
-        view.destroy();
-        parent.remove();
-    });
+		view.destroy();
+		parent.remove();
+	});
 });

package/tests/unit/MarkdownEditor/html-descriptors.test.ts

@@ -1,12 +1,12 @@
 import {
-    collectHtmlBlockTokens,
-    collectParagraphJsxDescriptors,
-    findDescriptorForOpenBlock,
-    isBlockHtmlNodeDescriptor,
-    outermostHtmlDescriptors,
-    pairDocumentHtmlBlocks,
-    pairHtmlTokens,
-    pairInlineHtmlTags,
+	collectHtmlBlockTokens,
+	collectParagraphJsxDescriptors,
+	findDescriptorForOpenBlock,
+	isBlockHtmlNodeDescriptor,
+	outermostHtmlDescriptors,
+	pairDocumentHtmlBlocks,
+	pairHtmlTokens,
+	pairInlineHtmlTags,
 } from "@src/lib/markdown/tree/html";
 import { parseMarkdownTree } from "@src/lib/markdown/tree/parse";
 import { markdownSourceFromString } from "@src/lib/markdown/tree/source";
@@ -18,77 +18,77 @@ const TABLE_MARKDOWN = `<table>
 </table>`;
 
 describe("HTML descriptors", () => {
-    it("findDescriptorForOpenBlock picks the outermost table, not nested th/td", () => {
-        const tree = parseMarkdownTree(TABLE_MARKDOWN);
-        const node = tree.topNode.firstChild;
-        expect(node?.name).toBe("HTMLBlock");
-        if (!node) return;
+	it("findDescriptorForOpenBlock picks the outermost table, not nested th/td", () => {
+		const tree = parseMarkdownTree(TABLE_MARKDOWN);
+		const node = tree.topNode.firstChild;
+		expect(node?.name).toBe("HTMLBlock");
+		if (!node) return;
 
-        const source = markdownSourceFromString(TABLE_MARKDOWN);
-        const cross = pairDocumentHtmlBlocks([node], source);
-        const picked = findDescriptorForOpenBlock(node, cross);
+		const source = markdownSourceFromString(TABLE_MARKDOWN);
+		const cross = pairDocumentHtmlBlocks([node], source);
+		const picked = findDescriptorForOpenBlock(node, cross);
 
-        expect(picked?.tagName).toBe("table");
-        expect(picked?.closeTo).not.toBeNull();
-    });
+		expect(picked?.tagName).toBe("table");
+		expect(picked?.closeTo).not.toBeNull();
+	});
 
-    it("outermostHtmlDescriptors keeps only the table for a single HTML block", () => {
-        const tree = parseMarkdownTree(TABLE_MARKDOWN);
-        const node = tree.topNode.firstChild;
-        expect(node).toBeDefined();
-        if (!node) return;
+	it("outermostHtmlDescriptors keeps only the table for a single HTML block", () => {
+		const tree = parseMarkdownTree(TABLE_MARKDOWN);
+		const node = tree.topNode.firstChild;
+		expect(node).toBeDefined();
+		if (!node) return;
 
-        const source = markdownSourceFromString(TABLE_MARKDOWN);
-        const tokens = collectHtmlBlockTokens(node, source);
-        const outer = outermostHtmlDescriptors(pairHtmlTokens(tokens));
+		const source = markdownSourceFromString(TABLE_MARKDOWN);
+		const tokens = collectHtmlBlockTokens(node, source);
+		const outer = outermostHtmlDescriptors(pairHtmlTokens(tokens));
 
-        expect(outer).toHaveLength(1);
-        expect(outer[0]?.tagName).toBe("table");
-    });
+		expect(outer).toHaveLength(1);
+		expect(outer[0]?.tagName).toBe("table");
+	});
 
-    it("treats inline <Since /> as non-block inside a paragraph", () => {
-        const text = 'Text <Since v="1" /> end.';
-        const source = markdownSourceFromString(text);
-        const tree = parseMarkdownTree(text);
-        const para = tree.topNode.firstChild;
-        expect(para?.name).toBe("Paragraph");
-        if (!para) return;
+	it("treats inline <Since /> as non-block inside a paragraph", () => {
+		const text = 'Text <Since v="1" /> end.';
+		const source = markdownSourceFromString(text);
+		const tree = parseMarkdownTree(text);
+		const para = tree.topNode.firstChild;
+		expect(para?.name).toBe("Paragraph");
+		if (!para) return;
 
-        const descriptors = pairInlineHtmlTags(para, source);
-        const since = descriptors.find((d) => d.isJsx && d.rawTagName === "Since");
-        expect(since).toBeDefined();
-        // Unregistered components default to inline.
-        expect(since && isBlockHtmlNodeDescriptor(since, undefined)).toBe(false);
-        // Explicitly registering as block flips the resolved block-ness.
-        expect(
-            since &&
-                isBlockHtmlNodeDescriptor(since, {
-                    Since: { component: () => null, block: true },
-                }),
-        ).toBe(true);
-    });
+		const descriptors = pairInlineHtmlTags(para, source);
+		const since = descriptors.find((d) => d.isJsx && d.rawTagName === "Since");
+		expect(since).toBeDefined();
+		// Unregistered components default to inline.
+		expect(since && isBlockHtmlNodeDescriptor(since, undefined)).toBe(false);
+		// Explicitly registering as block flips the resolved block-ness.
+		expect(
+			since &&
+				isBlockHtmlNodeDescriptor(since, {
+					Since: { component: () => null, block: true },
+				}),
+		).toBe(true);
+	});
 
-    it("pairs multiple self-closing tags in one paragraph", () => {
-        const text = '<Label label="Required" /><Label label="Optional" />';
-        const source = markdownSourceFromString(text);
-        const tree = parseMarkdownTree(text);
-        const para = tree.topNode.firstChild;
-        expect(para?.name).toBe("Paragraph");
-        if (!para) return;
+	it("pairs multiple self-closing tags in one paragraph", () => {
+		const text = '<Label label="Required" /><Label label="Optional" />';
+		const source = markdownSourceFromString(text);
+		const tree = parseMarkdownTree(text);
+		const para = tree.topNode.firstChild;
+		expect(para?.name).toBe("Paragraph");
+		if (!para) return;
 
-        expect(pairInlineHtmlTags(para, source)).toHaveLength(2);
-    });
+		expect(pairInlineHtmlTags(para, source)).toHaveLength(2);
+	});
 
-    it("collectParagraphJsxDescriptors scans plain paragraphs without HTMLTag nodes", () => {
-        const text = 'Before <Card label="x" /> after.';
-        const source = markdownSourceFromString(text);
-        const tree = parseMarkdownTree(text);
-        const para = tree.topNode.firstChild;
-        expect(para?.name).toBe("Paragraph");
-        if (!para) return;
+	it("collectParagraphJsxDescriptors scans plain paragraphs without HTMLTag nodes", () => {
+		const text = 'Before <Card label="x" /> after.';
+		const source = markdownSourceFromString(text);
+		const tree = parseMarkdownTree(text);
+		const para = tree.topNode.firstChild;
+		expect(para?.name).toBe("Paragraph");
+		if (!para) return;
 
-        const descriptors = collectParagraphJsxDescriptors(para, source);
-        expect(descriptors).toHaveLength(1);
-        expect(descriptors[0]?.rawTagName).toBe("Card");
-    });
+		const descriptors = collectParagraphJsxDescriptors(para, source);
+		expect(descriptors).toHaveLength(1);
+		expect(descriptors[0]?.rawTagName).toBe("Card");
+	});
 });

package/tests/unit/MarkdownEditor/indented-fence.test.ts

@@ -4,100 +4,100 @@ import { describe, expect, it } from "vitest";
 
 /** Reconstructed body text of the (single) FencedCode node. */
 function fencedCodeBody(text: string): string | null {
-    const tree = parseMarkdownTree(text);
-    const src = markdownSourceFromString(text);
-    let body: string | null = null;
-    tree.iterate({
-        enter: (n) => {
-            if (n.name === "FencedCode" && body === null) body = readCodeText(n.node, src);
-        },
-    });
-    return body;
+	const tree = parseMarkdownTree(text);
+	const src = markdownSourceFromString(text);
+	let body: string | null = null;
+	tree.iterate({
+		enter: (n) => {
+			if (n.name === "FencedCode" && body === null) body = readCodeText(n.node, src);
+		},
+	});
+	return body;
 }
 
 /** Top-level node names of a parsed document. */
 function topLevelNodes(text: string): { name: string; text: string }[] {
-    const tree = parseMarkdownTree(text);
-    const src = markdownSourceFromString(text);
-    const out: { name: string; text: string }[] = [];
-    let ch = tree.topNode.firstChild;
-    while (ch) {
-        out.push({ name: ch.name, text: src.slice(ch.from, ch.to) });
-        ch = ch.nextSibling;
-    }
-    return out;
+	const tree = parseMarkdownTree(text);
+	const src = markdownSourceFromString(text);
+	const out: { name: string; text: string }[] = [];
+	let ch = tree.topNode.firstChild;
+	while (ch) {
+		out.push({ name: ch.name, text: src.slice(ch.from, ch.to) });
+		ch = ch.nextSibling;
+	}
+	return out;
 }
 
 /** The source text of the (single) FencedCode node, or null if none. */
 function fencedCodeText(text: string): string | null {
-    const tree = parseMarkdownTree(text);
-    const src = markdownSourceFromString(text);
-    let found: string | null = null;
-    tree.iterate({
-        enter: (n) => {
-            if (n.name === "FencedCode" && found === null) found = src.slice(n.from, n.to);
-        },
-    });
-    return found;
+	const tree = parseMarkdownTree(text);
+	const src = markdownSourceFromString(text);
+	let found: string | null = null;
+	tree.iterate({
+		enter: (n) => {
+			if (n.name === "FencedCode" && found === null) found = src.slice(n.from, n.to);
+		},
+	});
+	return found;
 }
 
 describe("MarkdownEditor / indented fenced code closing", () => {
-    it("closes a tab-indented fence and does not swallow following content", () => {
-        const text = "\t```ts\n\tcode\n\t```\ntext";
-        const fence = fencedCodeText(text);
-        expect(fence).not.toBeNull();
-        expect(fence).not.toContain("text");
-        // The trailing paragraph survives as its own node.
-        expect(
-            topLevelNodes(text).some((n) => n.name === "Paragraph" && n.text.includes("text")),
-        ).toBe(true);
-    });
+	it("closes a tab-indented fence and does not swallow following content", () => {
+		const text = "\t```ts\n\tcode\n\t```\ntext";
+		const fence = fencedCodeText(text);
+		expect(fence).not.toBeNull();
+		expect(fence).not.toContain("text");
+		// The trailing paragraph survives as its own node.
+		expect(
+			topLevelNodes(text).some((n) => n.name === "Paragraph" && n.text.includes("text")),
+		).toBe(true);
+	});
 
-    it("closes a 4-space-indented fence and does not swallow following content", () => {
-        const text = "    ```ts\n    code\n    ```\ntext";
-        const fence = fencedCodeText(text);
-        expect(fence).not.toBeNull();
-        expect(fence).not.toContain("text");
-    });
+	it("closes a 4-space-indented fence and does not swallow following content", () => {
+		const text = "    ```ts\n    code\n    ```\ntext";
+		const fence = fencedCodeText(text);
+		expect(fence).not.toBeNull();
+		expect(fence).not.toContain("text");
+	});
 
-    it("does not let an indented fence swallow the closing </Tabs> tag", () => {
-        const text = [
-            "<Tabs>",
-            '\t<TabItem value="esm" label="ESM">',
-            "\t```ts",
-            "\tconst db = 1;",
-            "\t```",
-            "\t</TabItem>",
-            "</Tabs>",
-        ].join("\n");
-        // </Tabs> and </TabItem> must be their own HTMLBlock nodes, not buried
-        // inside a runaway FencedCode.
-        const fence = fencedCodeText(text);
-        expect(fence).not.toContain("</TabItem>");
-        expect(fence).not.toContain("</Tabs>");
-        const names = topLevelNodes(text).map((n) => n.name);
-        expect(names.filter((n) => n === "HTMLBlock").length).toBeGreaterThanOrEqual(4);
-    });
+	it("does not let an indented fence swallow the closing </Tabs> tag", () => {
+		const text = [
+			"<Tabs>",
+			'\t<TabItem value="esm" label="ESM">',
+			"\t```ts",
+			"\tconst db = 1;",
+			"\t```",
+			"\t</TabItem>",
+			"</Tabs>",
+		].join("\n");
+		// </Tabs> and </TabItem> must be their own HTMLBlock nodes, not buried
+		// inside a runaway FencedCode.
+		const fence = fencedCodeText(text);
+		expect(fence).not.toContain("</TabItem>");
+		expect(fence).not.toContain("</Tabs>");
+		const names = topLevelNodes(text).map((n) => n.name);
+		expect(names.filter((n) => n === "HTMLBlock").length).toBeGreaterThanOrEqual(4);
+	});
 
-    it("still parses a flush fence normally (regression)", () => {
-        const text = "```ts\ncode\n```\ntext";
-        expect(fencedCodeText(text)).toBe("```ts\ncode\n```");
-    });
+	it("still parses a flush fence normally (regression)", () => {
+		const text = "```ts\ncode\n```\ntext";
+		expect(fencedCodeText(text)).toBe("```ts\ncode\n```");
+	});
 
-    it("still parses a fence nested in a list item (regression)", () => {
-        const text = ["- item", "  ```js", "  code;", "  ```", "", "after"].join("\n");
-        const fence = fencedCodeText(text);
-        expect(fence).not.toBeNull();
-        expect(fence).not.toContain("after");
-    });
+	it("still parses a fence nested in a list item (regression)", () => {
+		const text = ["- item", "  ```js", "  code;", "  ```", "", "after"].join("\n");
+		const fence = fencedCodeText(text);
+		expect(fence).not.toBeNull();
+		expect(fence).not.toContain("after");
+	});
 
-    // Matches MDX/micromark: exactly the opening fence's indentation is removed
-    // from each content line; deeper indentation is preserved.
-    it("strips the opening fence indent from content, preserving deeper indent", () => {
-        const text =
-            "\t```ts\n\timport { Surreal } from 'surrealdb';\n\t\tconst indented = 1;\n\t```";
-        expect(fencedCodeBody(text)).toBe(
-            "import { Surreal } from 'surrealdb';\n\tconst indented = 1;",
-        );
-    });
+	// Matches MDX/micromark: exactly the opening fence's indentation is removed
+	// from each content line; deeper indentation is preserved.
+	it("strips the opening fence indent from content, preserving deeper indent", () => {
+		const text =
+			"\t```ts\n\timport { Surreal } from 'surrealdb';\n\t\tconst indented = 1;\n\t```";
+		expect(fencedCodeBody(text)).toBe(
+			"import { Surreal } from 'surrealdb';\n\tconst indented = 1;",
+		);
+	});
 });

package/tests/unit/MarkdownEditor/jsx-attr-scan.test.ts

@@ -1,115 +1,115 @@
 import {
-    buildJsxTagHighlights,
-    findJsonAttributeClose,
-    parseAttributes,
-    parseJsonAttribute,
-    resolveAttributeValue,
+	buildJsxTagHighlights,
+	findJsonAttributeClose,
+	parseAttributes,
+	parseJsonAttribute,
+	resolveAttributeValue,
 } from "@src/lib/markdown/grammar/html-attrs";
 import { describe, expect, it } from "vitest";
 
 describe("findJsonAttributeClose", () => {
-    it("finds the closing brace for nested JSON objects and strings", () => {
-        const json = '{"version": "2.0.0", "items": [{"id": 1}]}';
-        const full = `{${json}}`;
-        const bounds = findJsonAttributeClose(`${full} trailing`, 0);
-        expect(bounds).toEqual({
-            contentFrom: 1,
-            contentTo: full.length - 1,
-            closeBrace: full.length - 1,
-        });
-    });
-
-    it("handles braces inside JSON strings", () => {
-        const json = '{"note": "}"}';
-        const full = `{${json}}`;
-        const bounds = findJsonAttributeClose(full, 0);
-        expect(bounds?.closeBrace).toBe(full.length - 1);
-    });
+	it("finds the closing brace for nested JSON objects and strings", () => {
+		const json = '{"version": "2.0.0", "items": [{"id": 1}]}';
+		const full = `{${json}}`;
+		const bounds = findJsonAttributeClose(`${full} trailing`, 0);
+		expect(bounds).toEqual({
+			contentFrom: 1,
+			contentTo: full.length - 1,
+			closeBrace: full.length - 1,
+		});
+	});
+
+	it("handles braces inside JSON strings", () => {
+		const json = '{"note": "}"}';
+		const full = `{${json}}`;
+		const bounds = findJsonAttributeClose(full, 0);
+		expect(bounds?.closeBrace).toBe(full.length - 1);
+	});
 });
 
 describe("parseJsonAttribute", () => {
-    it("parses JSON literals without evaluation", () => {
-        expect(parseJsonAttribute("42")).toBe(42);
-        expect(parseJsonAttribute('"hello"')).toBe("hello");
-        expect(parseJsonAttribute('{"enabled": true}')).toEqual({ enabled: true });
-    });
-
-    it("returns undefined for invalid JSON", () => {
-        expect(parseJsonAttribute("{ foo: 1 }")).toBeUndefined();
-        expect(parseJsonAttribute("count")).toBeUndefined();
-    });
+	it("parses JSON literals without evaluation", () => {
+		expect(parseJsonAttribute("42")).toBe(42);
+		expect(parseJsonAttribute('"hello"')).toBe("hello");
+		expect(parseJsonAttribute('{"enabled": true}')).toEqual({ enabled: true });
+	});
+
+	it("returns undefined for invalid JSON", () => {
+		expect(parseJsonAttribute("{ foo: 1 }")).toBeUndefined();
+		expect(parseJsonAttribute("count")).toBeUndefined();
+	});
 });
 
 describe("resolveAttributeValue", () => {
-    it("resolves JSON attribute values", () => {
-        expect(resolveAttributeValue({ type: "json", value: "100" })).toBe(100);
-        expect(resolveAttributeValue({ type: "json", value: '"2.0.0"' })).toBe("2.0.0");
-    });
+	it("resolves JSON attribute values", () => {
+		expect(resolveAttributeValue({ type: "json", value: "100" })).toBe(100);
+		expect(resolveAttributeValue({ type: "json", value: '"2.0.0"' })).toBe("2.0.0");
+	});
 });
 
 describe("buildJsxTagHighlights", () => {
-    const tag = '<Since v={"2.0.0"} t="true" b="false" />';
-
-    it("covers the attribute section without gaps for the nested HTML parser", () => {
-        const highlights = buildJsxTagHighlights(tag);
-        const attrStart = tag.indexOf(" v=");
-        const attrEnd = tag.lastIndexOf(">");
-
-        const gaps = leftoverGaps(attrStart, attrEnd, highlights);
-        expect(gaps).toEqual([]);
-    });
-
-    it("labels attribute names and quoted literals after a JSON value", () => {
-        const highlights = buildJsxTagHighlights(tag);
-        const names = textAtKinds(tag, highlights, "name");
-        const strings = textAtKinds(tag, highlights, "string");
-
-        expect(names).toEqual(["v", "t", "b"]);
-        expect(strings).toEqual(['"true"', '"false"']);
-    });
-
-    it("matches parseAttributes JSON boundaries", () => {
-        const { endIndex } = readTagNameForTest(tag);
-        const attrString = tag.slice(endIndex, tag.lastIndexOf(">"));
-        const attrs = parseAttributes(attrString);
-        const expr = buildJsxTagHighlights(tag).find((h) => h.kind === "expression-content");
-
-        expect(attrs.v).toEqual({ type: "json", value: '"2.0.0"' });
-        expect(expr).toBeDefined();
-        if (!expr) return;
-        expect(tag.slice(expr.from, expr.to)).toBe('"2.0.0"');
-        expect(attrs.t).toBe("true");
-        expect(attrs.b).toBe("false");
-    });
+	const tag = '<Since v={"2.0.0"} t="true" b="false" />';
+
+	it("covers the attribute section without gaps for the nested HTML parser", () => {
+		const highlights = buildJsxTagHighlights(tag);
+		const attrStart = tag.indexOf(" v=");
+		const attrEnd = tag.lastIndexOf(">");
+
+		const gaps = leftoverGaps(attrStart, attrEnd, highlights);
+		expect(gaps).toEqual([]);
+	});
+
+	it("labels attribute names and quoted literals after a JSON value", () => {
+		const highlights = buildJsxTagHighlights(tag);
+		const names = textAtKinds(tag, highlights, "name");
+		const strings = textAtKinds(tag, highlights, "string");
+
+		expect(names).toEqual(["v", "t", "b"]);
+		expect(strings).toEqual(['"true"', '"false"']);
+	});
+
+	it("matches parseAttributes JSON boundaries", () => {
+		const { endIndex } = readTagNameForTest(tag);
+		const attrString = tag.slice(endIndex, tag.lastIndexOf(">"));
+		const attrs = parseAttributes(attrString);
+		const expr = buildJsxTagHighlights(tag).find((h) => h.kind === "expression-content");
+
+		expect(attrs.v).toEqual({ type: "json", value: '"2.0.0"' });
+		expect(expr).toBeDefined();
+		if (!expr) return;
+		expect(tag.slice(expr.from, expr.to)).toBe('"2.0.0"');
+		expect(attrs.t).toBe("true");
+		expect(attrs.b).toBe("false");
+	});
 });
 
 function readTagNameForTest(text: string): { endIndex: number } {
-    let i = 1;
-    while (i < text.length && !/[\s/>]/.test(text[i] ?? "")) i++;
-    return { endIndex: i };
+	let i = 1;
+	while (i < text.length && !/[\s/>]/.test(text[i] ?? "")) i++;
+	return { endIndex: i };
 }
 
 function leftoverGaps(
-    from: number,
-    to: number,
-    spans: { from: number; to: number }[],
+	from: number,
+	to: number,
+	spans: { from: number; to: number }[],
 ): { from: number; to: number }[] {
-    const gaps: { from: number; to: number }[] = [];
-    let pos = from;
+	const gaps: { from: number; to: number }[] = [];
+	let pos = from;
 
-    for (const span of spans) {
-        if (span.from > pos) gaps.push({ from: pos, to: span.from });
-        pos = Math.max(pos, span.to);
-    }
+	for (const span of spans) {
+		if (span.from > pos) gaps.push({ from: pos, to: span.from });
+		pos = Math.max(pos, span.to);
+	}
 
-    if (pos < to) gaps.push({ from: pos, to });
-    return gaps;
+	if (pos < to) gaps.push({ from: pos, to });
+	return gaps;
 }
 
 function textAtKinds(
-    text: string,
-    highlights: ReturnType<typeof buildJsxTagHighlights>,
-    kind: "name" | "string",
+	text: string,
+	highlights: ReturnType<typeof buildJsxTagHighlights>,
+	kind: "name" | "string",
 ): string[] {
-    return highlights.filter((h) => h.kind === kind).map((h) => text.slice(h.from, h.to));
+	return highlights.filter((h) => h.kind === kind).map((h) => text.slice(h.from, h.to));
 }