@fairyhunter13/opentui-core 0.1.90 → 0.1.92

package/src/syntax-style.test.ts

@@ -1,841 +0,0 @@
-import { describe, expect, it, beforeEach, afterEach } from "bun:test"
-import { SyntaxStyle } from "./syntax-style.js"
-import { RGBA } from "./lib/RGBA.js"
-import type { StyleDefinition, ThemeTokenStyle } from "./syntax-style.js"
-
-describe("NativeSyntaxStyle", () => {
-  let style: SyntaxStyle
-
-  beforeEach(() => {
-    style = SyntaxStyle.create()
-  })
-
-  afterEach(() => {
-    style.destroy()
-  })
-
-  describe("create", () => {
-    it("should create a new NativeSyntaxStyle instance", () => {
-      const newStyle = SyntaxStyle.create()
-      expect(newStyle).toBeDefined()
-      expect(newStyle.getStyleCount()).toBe(0)
-      newStyle.destroy()
-    })
-
-    it("should create multiple independent instances", () => {
-      const style1 = SyntaxStyle.create()
-      const style2 = SyntaxStyle.create()
-
-      style1.registerStyle("test", { fg: RGBA.fromValues(1, 0, 0, 1) })
-
-      expect(style1.getStyleCount()).toBe(1)
-      expect(style2.getStyleCount()).toBe(0)
-
-      style1.destroy()
-      style2.destroy()
-    })
-  })
-
-  describe("registerStyle", () => {
-    it("should register a simple style and return an ID", () => {
-      const id = style.registerStyle("keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should register style with both fg and bg colors", () => {
-      const id = style.registerStyle("string", {
-        fg: RGBA.fromValues(0, 1, 0, 1),
-        bg: RGBA.fromValues(0, 0, 0, 1),
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should register style with attributes", () => {
-      const id = style.registerStyle("bold-keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-        bold: true,
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should register style with multiple attributes", () => {
-      const id = style.registerStyle("styled", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-        bold: true,
-        italic: true,
-        underline: true,
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should register multiple different styles", () => {
-      const id1 = style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      const id2 = style.registerStyle("string", { fg: RGBA.fromValues(0, 1, 0, 1) })
-      const id3 = style.registerStyle("comment", { fg: RGBA.fromValues(0.5, 0.5, 0.5, 1) })
-
-      expect(id1).not.toBe(id2)
-      expect(id2).not.toBe(id3)
-      expect(id1).not.toBe(id3)
-      expect(style.getStyleCount()).toBe(3)
-    })
-
-    it("should return existing ID when registering same style name", () => {
-      const id1 = style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      const id2 = style.registerStyle("keyword", { fg: RGBA.fromValues(0, 1, 0, 1) })
-
-      expect(id1).toBe(id2)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should handle style without colors", () => {
-      const id = style.registerStyle("plain", {})
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should handle style with only background color", () => {
-      const id = style.registerStyle("highlighted", {
-        bg: RGBA.fromValues(1, 1, 0, 1),
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should handle style with only attributes", () => {
-      const id = style.registerStyle("bold-only", {
-        bold: true,
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should handle style with dim attribute", () => {
-      const id = style.registerStyle("dimmed", {
-        fg: RGBA.fromValues(1, 1, 1, 1),
-        dim: true,
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should register styles with special characters in names", () => {
-      const id1 = style.registerStyle("keyword.control", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      const id2 = style.registerStyle("variable.parameter", { fg: RGBA.fromValues(0, 1, 0, 1) })
-
-      expect(id1).toBeGreaterThan(0)
-      expect(id2).toBeGreaterThan(0)
-      expect(id1).not.toBe(id2)
-      expect(style.getStyleCount()).toBe(2)
-    })
-
-    it("should register many styles without issue", () => {
-      const ids: number[] = []
-      for (let i = 0; i < 100; i++) {
-        const id = style.registerStyle(`style-${i}`, {
-          fg: RGBA.fromValues(i / 100, 0, 0, 1),
-        })
-        ids.push(id)
-      }
-
-      expect(style.getStyleCount()).toBe(100)
-      const uniqueIds = new Set(ids)
-      expect(uniqueIds.size).toBe(100)
-    })
-  })
-
-  describe("resolveStyleId", () => {
-    it("should resolve registered style name to ID", () => {
-      const registeredId = style.registerStyle("keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      const resolvedId = style.resolveStyleId("keyword")
-      expect(resolvedId).toBe(registeredId)
-    })
-
-    it("should return null for unregistered style", () => {
-      const id = style.resolveStyleId("nonexistent")
-      expect(id).toBeNull()
-    })
-
-    it("should resolve multiple styles correctly", () => {
-      const id1 = style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      const id2 = style.registerStyle("string", { fg: RGBA.fromValues(0, 1, 0, 1) })
-
-      expect(style.resolveStyleId("keyword")).toBe(id1)
-      expect(style.resolveStyleId("string")).toBe(id2)
-    })
-
-    it("should cache resolved style IDs", () => {
-      const registeredId = style.registerStyle("keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      const resolvedId1 = style.resolveStyleId("keyword")
-      const resolvedId2 = style.resolveStyleId("keyword")
-
-      expect(resolvedId1).toBe(registeredId)
-      expect(resolvedId2).toBe(registeredId)
-    })
-
-    it("should handle empty string style name", () => {
-      const id = style.registerStyle("", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      expect(style.resolveStyleId("")).toBe(id)
-    })
-
-    it("should be case-sensitive", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-
-      expect(style.resolveStyleId("keyword")).not.toBeNull()
-      expect(style.resolveStyleId("Keyword")).toBeNull()
-      expect(style.resolveStyleId("KEYWORD")).toBeNull()
-    })
-  })
-
-  describe("getStyleId", () => {
-    it("should return style ID for exact match", () => {
-      const id = style.registerStyle("keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      expect(style.getStyleId("keyword")).toBe(id)
-    })
-
-    it("should fall back to base scope for dotted names", () => {
-      const baseId = style.registerStyle("keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      expect(style.getStyleId("keyword.control")).toBe(baseId)
-      expect(style.getStyleId("keyword.operator")).toBe(baseId)
-    })
-
-    it("should prefer exact match over base scope", () => {
-      const baseId = style.registerStyle("keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-      const specificId = style.registerStyle("keyword.control", {
-        fg: RGBA.fromValues(0, 1, 0, 1),
-      })
-
-      expect(style.getStyleId("keyword")).toBe(baseId)
-      expect(style.getStyleId("keyword.control")).toBe(specificId)
-      expect(style.getStyleId("keyword.operator")).toBe(baseId)
-    })
-
-    it("should return null for non-existent style without fallback", () => {
-      expect(style.getStyleId("nonexistent")).toBeNull()
-      expect(style.getStyleId("nonexistent.scope")).toBeNull()
-    })
-
-    it("should handle multiple dot levels", () => {
-      const baseId = style.registerStyle("meta", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      expect(style.getStyleId("meta.tag.xml")).toBe(baseId)
-    })
-
-    it("should handle names without dots", () => {
-      const id = style.registerStyle("comment", {
-        fg: RGBA.fromValues(0.5, 0.5, 0.5, 1),
-      })
-
-      expect(style.getStyleId("comment")).toBe(id)
-    })
-  })
-
-  describe("getStyleCount", () => {
-    it("should return 0 for empty style registry", () => {
-      expect(style.getStyleCount()).toBe(0)
-    })
-
-    it("should return correct count after registering styles", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      expect(style.getStyleCount()).toBe(1)
-
-      style.registerStyle("string", { fg: RGBA.fromValues(0, 1, 0, 1) })
-      expect(style.getStyleCount()).toBe(2)
-
-      style.registerStyle("comment", { fg: RGBA.fromValues(0.5, 0.5, 0.5, 1) })
-      expect(style.getStyleCount()).toBe(3)
-    })
-
-    it("should not increment count for duplicate registrations", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      expect(style.getStyleCount()).toBe(1)
-
-      style.registerStyle("keyword", { fg: RGBA.fromValues(0, 1, 0, 1) })
-      expect(style.getStyleCount()).toBe(1)
-    })
-  })
-
-  describe("clearNameCache", () => {
-    it("should clear the name-to-ID cache", () => {
-      const id = style.registerStyle("keyword", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      style.resolveStyleId("keyword")
-      style.clearNameCache()
-
-      // Should still work after clearing cache
-      expect(style.resolveStyleId("keyword")).toBe(id)
-    })
-
-    it("should not affect registered styles", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      style.registerStyle("string", { fg: RGBA.fromValues(0, 1, 0, 1) })
-
-      style.clearNameCache()
-
-      expect(style.getStyleCount()).toBe(2)
-    })
-  })
-
-  describe("ptr getter", () => {
-    it("should return a valid pointer", () => {
-      const ptr = style.ptr
-      expect(ptr).toBeDefined()
-      expect(typeof ptr).toBe("number")
-    })
-
-    it("should return same pointer for same instance", () => {
-      const ptr1 = style.ptr
-      const ptr2 = style.ptr
-      expect(ptr1).toBe(ptr2)
-    })
-
-    it("should return different pointers for different instances", () => {
-      const style2 = SyntaxStyle.create()
-      const ptr1 = style.ptr
-      const ptr2 = style2.ptr
-
-      expect(ptr1).not.toBe(ptr2)
-
-      style2.destroy()
-    })
-  })
-
-  describe("destroy", () => {
-    it("should destroy the style instance", () => {
-      const testStyle = SyntaxStyle.create()
-      testStyle.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-
-      testStyle.destroy()
-
-      expect(() => testStyle.getStyleCount()).toThrow("NativeSyntaxStyle is destroyed")
-    })
-
-    it("should be safe to call destroy multiple times", () => {
-      const testStyle = SyntaxStyle.create()
-
-      testStyle.destroy()
-      expect(() => testStyle.destroy()).not.toThrow()
-    })
-
-    it("should throw error when using destroyed instance", () => {
-      const testStyle = SyntaxStyle.create()
-      testStyle.destroy()
-
-      expect(() => testStyle.registerStyle("test", {})).toThrow("NativeSyntaxStyle is destroyed")
-      expect(() => testStyle.resolveStyleId("test")).toThrow("NativeSyntaxStyle is destroyed")
-      expect(() => testStyle.getStyleId("test")).toThrow("NativeSyntaxStyle is destroyed")
-      expect(() => testStyle.getStyleCount()).toThrow("NativeSyntaxStyle is destroyed")
-      expect(() => testStyle.ptr).toThrow("NativeSyntaxStyle is destroyed")
-    })
-  })
-
-  describe("fromStyles", () => {
-    it("should create style from styles object", () => {
-      const styles: Record<string, StyleDefinition> = {
-        keyword: { fg: RGBA.fromValues(1, 0, 0, 1), bold: true },
-        string: { fg: RGBA.fromValues(0, 1, 0, 1) },
-        comment: { fg: RGBA.fromValues(0.5, 0.5, 0.5, 1), italic: true },
-      }
-
-      const newStyle = SyntaxStyle.fromStyles(styles)
-
-      expect(newStyle.getStyleCount()).toBe(3)
-      expect(newStyle.resolveStyleId("keyword")).not.toBeNull()
-      expect(newStyle.resolveStyleId("string")).not.toBeNull()
-      expect(newStyle.resolveStyleId("comment")).not.toBeNull()
-
-      newStyle.destroy()
-    })
-
-    it("should handle empty styles object", () => {
-      const newStyle = SyntaxStyle.fromStyles({})
-
-      expect(newStyle.getStyleCount()).toBe(0)
-
-      newStyle.destroy()
-    })
-
-    it("should preserve style definitions", () => {
-      const styles: Record<string, StyleDefinition> = {
-        keyword: {
-          fg: RGBA.fromValues(1, 0, 0, 1),
-          bold: true,
-          italic: true,
-        },
-      }
-
-      const newStyle = SyntaxStyle.fromStyles(styles)
-      const id = newStyle.resolveStyleId("keyword")
-
-      expect(id).not.toBeNull()
-
-      newStyle.destroy()
-    })
-  })
-
-  describe("fromTheme", () => {
-    it("should create style from theme", () => {
-      const theme: ThemeTokenStyle[] = [
-        {
-          scope: ["keyword", "keyword.control"],
-          style: {
-            foreground: "#ff0000",
-            bold: true,
-          },
-        },
-        {
-          scope: ["string"],
-          style: {
-            foreground: "#00ff00",
-          },
-        },
-      ]
-
-      const newStyle = SyntaxStyle.fromTheme(theme)
-
-      expect(newStyle.getStyleCount()).toBe(3) // keyword, keyword.control, string
-      expect(newStyle.resolveStyleId("keyword")).not.toBeNull()
-      expect(newStyle.resolveStyleId("keyword.control")).not.toBeNull()
-      expect(newStyle.resolveStyleId("string")).not.toBeNull()
-
-      newStyle.destroy()
-    })
-
-    it("should handle empty theme", () => {
-      const newStyle = SyntaxStyle.fromTheme([])
-
-      expect(newStyle.getStyleCount()).toBe(0)
-
-      newStyle.destroy()
-    })
-
-    it("should handle theme with multiple scopes", () => {
-      const theme: ThemeTokenStyle[] = [
-        {
-          scope: ["comment", "comment.line", "comment.block"],
-          style: {
-            foreground: "#808080",
-            italic: true,
-          },
-        },
-      ]
-
-      const newStyle = SyntaxStyle.fromTheme(theme)
-
-      expect(newStyle.getStyleCount()).toBe(3)
-      expect(newStyle.resolveStyleId("comment")).not.toBeNull()
-      expect(newStyle.resolveStyleId("comment.line")).not.toBeNull()
-      expect(newStyle.resolveStyleId("comment.block")).not.toBeNull()
-
-      newStyle.destroy()
-    })
-
-    it("should handle theme with all style properties", () => {
-      const theme: ThemeTokenStyle[] = [
-        {
-          scope: ["styled"],
-          style: {
-            foreground: "#ff0000",
-            background: "#000000",
-            bold: true,
-            italic: true,
-            underline: true,
-            dim: true,
-          },
-        },
-      ]
-
-      const newStyle = SyntaxStyle.fromTheme(theme)
-
-      expect(newStyle.getStyleCount()).toBe(1)
-      expect(newStyle.resolveStyleId("styled")).not.toBeNull()
-
-      newStyle.destroy()
-    })
-
-    it("should handle theme with rgb color format", () => {
-      const theme: ThemeTokenStyle[] = [
-        {
-          scope: ["keyword"],
-          style: {
-            foreground: "rgb(255, 0, 0)",
-          },
-        },
-      ]
-
-      const newStyle = SyntaxStyle.fromTheme(theme)
-
-      expect(newStyle.resolveStyleId("keyword")).not.toBeNull()
-
-      newStyle.destroy()
-    })
-  })
-
-  describe("integration tests", () => {
-    it("should handle complex syntax highlighting scenario", () => {
-      const theme: ThemeTokenStyle[] = [
-        { scope: ["keyword"], style: { foreground: "#569cd6", bold: true } },
-        { scope: ["string"], style: { foreground: "#ce9178" } },
-        { scope: ["comment"], style: { foreground: "#6a9955", italic: true } },
-        { scope: ["variable"], style: { foreground: "#9cdcfe" } },
-        { scope: ["function"], style: { foreground: "#dcdcaa" } },
-        { scope: ["operator"], style: { foreground: "#d4d4d4" } },
-      ]
-
-      const syntaxStyle = SyntaxStyle.fromTheme(theme)
-
-      expect(syntaxStyle.getStyleCount()).toBe(6)
-
-      const keywordId = syntaxStyle.getStyleId("keyword")
-      const stringId = syntaxStyle.getStyleId("string")
-      const commentId = syntaxStyle.getStyleId("comment")
-
-      expect(keywordId).not.toBeNull()
-      expect(stringId).not.toBeNull()
-      expect(commentId).not.toBeNull()
-
-      expect(keywordId).not.toBe(stringId)
-      expect(stringId).not.toBe(commentId)
-
-      syntaxStyle.destroy()
-    })
-
-    it("should handle registering and resolving many styles efficiently", () => {
-      const start = Date.now()
-
-      for (let i = 0; i < 1000; i++) {
-        style.registerStyle(`style-${i}`, {
-          fg: RGBA.fromValues(Math.random(), Math.random(), Math.random(), 1),
-        })
-      }
-
-      const registerTime = Date.now() - start
-
-      const resolveStart = Date.now()
-      for (let i = 0; i < 1000; i++) {
-        style.resolveStyleId(`style-${i}`)
-      }
-      const resolveTime = Date.now() - resolveStart
-
-      expect(registerTime).toBeLessThan(1000) // Should register 1000 styles in < 1s
-      expect(resolveTime).toBeLessThan(100) // Should resolve 1000 styles in < 100ms
-
-      expect(style.getStyleCount()).toBe(1000)
-    })
-
-    it("should handle style name collisions correctly", () => {
-      const id1 = style.registerStyle("test", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      const id2 = style.registerStyle("test", {
-        fg: RGBA.fromValues(0, 1, 0, 1),
-        bold: true,
-      })
-
-      expect(id1).toBe(id2)
-      expect(style.getStyleCount()).toBe(1)
-    })
-
-    it("should maintain style registry across cache clears", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      style.registerStyle("string", { fg: RGBA.fromValues(0, 1, 0, 1) })
-      style.registerStyle("comment", { fg: RGBA.fromValues(0.5, 0.5, 0.5, 1) })
-
-      const count1 = style.getStyleCount()
-      style.clearNameCache()
-      const count2 = style.getStyleCount()
-
-      expect(count1).toBe(count2)
-      expect(count1).toBe(3)
-    })
-  })
-
-  describe("edge cases", () => {
-    it("should handle very long style names", () => {
-      const longName = "a".repeat(1000)
-      const id = style.registerStyle(longName, {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.resolveStyleId(longName)).toBe(id)
-    })
-
-    it("should handle style names with unicode characters", () => {
-      const id = style.registerStyle("关键字", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      expect(id).toBeGreaterThan(0)
-      expect(style.resolveStyleId("关键字")).toBe(id)
-    })
-
-    it("should handle style names with special characters", () => {
-      const specialNames = [
-        "style-with-dashes",
-        "style_with_underscores",
-        "style.with.dots",
-        "style:with:colons",
-        "style/with/slashes",
-      ]
-
-      for (const name of specialNames) {
-        const id = style.registerStyle(name, {
-          fg: RGBA.fromValues(1, 0, 0, 1),
-        })
-        expect(id).toBeGreaterThan(0)
-        expect(style.resolveStyleId(name)).toBe(id)
-      }
-    })
-
-    it("should handle colors with full alpha range", () => {
-      const id1 = style.registerStyle("transparent", {
-        fg: RGBA.fromValues(1, 0, 0, 0),
-      })
-      const id2 = style.registerStyle("semi-transparent", {
-        fg: RGBA.fromValues(1, 0, 0, 0.5),
-      })
-      const id3 = style.registerStyle("opaque", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-      })
-
-      expect(id1).toBeGreaterThan(0)
-      expect(id2).toBeGreaterThan(0)
-      expect(id3).toBeGreaterThan(0)
-    })
-
-    it("should handle all attribute combinations", () => {
-      const combinations = [
-        { bold: true },
-        { italic: true },
-        { underline: true },
-        { dim: true },
-        { bold: true, italic: true },
-        { bold: true, underline: true },
-        { bold: true, dim: true },
-        { italic: true, underline: true },
-        { italic: true, dim: true },
-        { underline: true, dim: true },
-        { bold: true, italic: true, underline: true },
-        { bold: true, italic: true, dim: true },
-        { bold: true, underline: true, dim: true },
-        { italic: true, underline: true, dim: true },
-        { bold: true, italic: true, underline: true, dim: true },
-      ]
-
-      for (let i = 0; i < combinations.length; i++) {
-        const id = style.registerStyle(`combo-${i}`, {
-          fg: RGBA.fromValues(1, 0, 0, 1),
-          ...combinations[i],
-        })
-        expect(id).toBeGreaterThan(0)
-      }
-
-      expect(style.getStyleCount()).toBe(combinations.length)
-    })
-  })
-
-  describe("getStyle", () => {
-    it("should retrieve registered style definition", () => {
-      const styleDef = { fg: RGBA.fromValues(1, 0, 0, 1), bold: true }
-      style.registerStyle("keyword", styleDef)
-
-      const retrieved = style.getStyle("keyword")
-      expect(retrieved).toBeDefined()
-      expect(retrieved?.fg).toEqual(styleDef.fg)
-      expect(retrieved?.bold).toBe(true)
-    })
-
-    it("should return undefined for unregistered style", () => {
-      expect(style.getStyle("nonexistent")).toBeUndefined()
-    })
-
-    it("should fall back to base scope for dotted names", () => {
-      const baseDef = { fg: RGBA.fromValues(1, 0, 0, 1), bold: true }
-      style.registerStyle("keyword", baseDef)
-
-      const retrieved = style.getStyle("keyword.control")
-      expect(retrieved).toBeDefined()
-      expect(retrieved?.fg).toEqual(baseDef.fg)
-      expect(retrieved?.bold).toBe(true)
-    })
-
-    it("should prefer exact match over base scope", () => {
-      const baseDef = { fg: RGBA.fromValues(1, 0, 0, 1) }
-      const specificDef = { fg: RGBA.fromValues(0, 1, 0, 1), bold: true }
-
-      style.registerStyle("keyword", baseDef)
-      style.registerStyle("keyword.control", specificDef)
-
-      const exactMatch = style.getStyle("keyword.control")
-      expect(exactMatch?.fg).toEqual(specificDef.fg)
-      expect(exactMatch?.bold).toBe(true)
-
-      const baseMatch = style.getStyle("keyword.operator")
-      expect(baseMatch?.fg).toEqual(baseDef.fg)
-    })
-
-    it("should not return Object prototype properties", () => {
-      expect(style.getStyle("constructor")).toBeUndefined()
-      expect(style.getStyle("toString")).toBeUndefined()
-      expect(style.getStyle("hasOwnProperty")).toBeUndefined()
-    })
-
-    it("should handle style named constructor correctly", () => {
-      const constructorDef = { fg: RGBA.fromValues(1, 0.5, 0, 1), bold: true }
-      style.registerStyle("constructor", constructorDef)
-
-      const retrieved = style.getStyle("constructor")
-      expect(retrieved).toBeDefined()
-      expect(retrieved?.fg).toEqual(constructorDef.fg)
-      expect(retrieved?.bold).toBe(true)
-    })
-
-    it("should handle multiple dot levels", () => {
-      const baseDef = { fg: RGBA.fromValues(1, 0, 0, 1) }
-      style.registerStyle("meta", baseDef)
-
-      const retrieved = style.getStyle("meta.tag.xml")
-      expect(retrieved).toBeDefined()
-      expect(retrieved?.fg).toEqual(baseDef.fg)
-    })
-  })
-
-  describe("mergeStyles", () => {
-    it("should merge single style correctly", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1), bold: true })
-
-      const merged = style.mergeStyles("keyword")
-      expect(merged.fg).toEqual(RGBA.fromValues(1, 0, 0, 1))
-      expect(merged.attributes).toBeGreaterThan(0)
-    })
-
-    it("should merge multiple styles with later taking precedence", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1), bold: true })
-      style.registerStyle("emphasis", { italic: true })
-      style.registerStyle("override", { fg: RGBA.fromValues(0, 1, 0, 1) })
-
-      const merged = style.mergeStyles("keyword", "emphasis", "override")
-      expect(merged.fg).toEqual(RGBA.fromValues(0, 1, 0, 1))
-      expect(merged.attributes).toBeGreaterThan(0)
-    })
-
-    it("should handle dotted style names with fallback", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1), bold: true })
-
-      const merged = style.mergeStyles("keyword.operator")
-      expect(merged.fg).toEqual(RGBA.fromValues(1, 0, 0, 1))
-      expect(merged.attributes).toBeGreaterThan(0)
-    })
-
-    it("should return empty merge for non-existent styles", () => {
-      const merged = style.mergeStyles("nonexistent")
-      expect(merged.fg).toBeUndefined()
-      expect(merged.bg).toBeUndefined()
-      expect(merged.attributes).toBe(0)
-    })
-
-    it("should cache merged results", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-
-      expect(style.getCacheSize()).toBe(0)
-
-      const result1 = style.mergeStyles("keyword.operator")
-      expect(style.getCacheSize()).toBe(1)
-
-      const result2 = style.mergeStyles("keyword.operator")
-      expect(style.getCacheSize()).toBe(1)
-
-      expect(result1).toBe(result2)
-    })
-
-    it("should handle all style attributes correctly", () => {
-      style.registerStyle("complex", {
-        fg: RGBA.fromValues(1, 0, 0, 1),
-        bg: RGBA.fromValues(0.2, 0.2, 0.2, 1),
-        bold: true,
-        italic: true,
-        underline: true,
-        dim: true,
-      })
-
-      const merged = style.mergeStyles("complex")
-      expect(merged.fg).toEqual(RGBA.fromValues(1, 0, 0, 1))
-      expect(merged.bg).toEqual(RGBA.fromValues(0.2, 0.2, 0.2, 1))
-      expect(merged.attributes).toBeGreaterThan(0)
-    })
-
-    it("should handle empty style names", () => {
-      const merged = style.mergeStyles()
-      expect(merged.fg).toBeUndefined()
-      expect(merged.bg).toBeUndefined()
-      expect(merged.attributes).toBe(0)
-    })
-  })
-
-  describe("clearCache and getCacheSize", () => {
-    it("should clear merged style cache", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      style.mergeStyles("keyword")
-      style.mergeStyles("keyword.operator")
-
-      expect(style.getCacheSize()).toBe(2)
-
-      style.clearCache()
-      expect(style.getCacheSize()).toBe(0)
-    })
-
-    it("should not affect registered styles when clearing cache", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-      style.mergeStyles("keyword")
-
-      style.clearCache()
-
-      expect(style.getStyleCount()).toBe(1)
-      expect(style.resolveStyleId("keyword")).not.toBeNull()
-    })
-
-    it("should allow re-merging after cache clear", () => {
-      style.registerStyle("keyword", { fg: RGBA.fromValues(1, 0, 0, 1) })
-
-      const result1 = style.mergeStyles("keyword")
-      style.clearCache()
-      const result2 = style.mergeStyles("keyword")
-
-      expect(result1.fg).toEqual(result2.fg)
-      expect(result1.attributes).toBe(result2.attributes)
-    })
-  })
-})